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

Rename and clean up MapleBuffStat

Browse Source
This commit is contained in:
P0nk
2021-09-09 21:02:22 +02:00
parent 6ea9a57e9f
commit 46bd0570d7
23 changed files with 431 additions and 431 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
scripts/npc/2081005.js
View File

@@ -26,8 +26,8 @@ var status = 0;
var price = 100000;
function isTransformed(ch) {
const MapleBuffStat = Java.type('client.MapleBuffStat');
return ch.getBuffSource(MapleBuffStat.MORPH) == 2210003;
const BuffStat = Java.type('client.BuffStat');
return ch.getBuffSource(BuffStat.MORPH) == 2210003;
}
function start() {

4
scripts/npc/2103000.js
View File

@@ -22,8 +22,8 @@
function isTigunMorphed(ch) {
const MapleBuffStat = Java.type('client.MapleBuffStat');
return ch.getBuffSource(MapleBuffStat.MORPH) == 2210005;
const BuffStat = Java.type('client.BuffStat');
return ch.getBuffSource(BuffStat.MORPH) == 2210005;
}
function start() {

4
scripts/npc/2111015.js
View File

@@ -21,8 +21,8 @@
var status;
function isPillUsed(ch) {
const MapleBuffStat = Java.type('client.MapleBuffStat');
return ch.getBuffSource(MapleBuffStat.HPREC) == 2022198;
const BuffStat = Java.type('client.BuffStat');
return ch.getBuffSource(BuffStat.HPREC) == 2022198;
}
function start() {

4
scripts/portal/ariant_queens.js
View File

@@ -19,8 +19,8 @@
*/
function isTigunMorphed(ch) {
const MapleBuffStat = Java.type('client.MapleBuffStat');
return ch.getBuffSource(MapleBuffStat.MORPH) == 2210005;
const BuffStat = Java.type('client.BuffStat');
return ch.getBuffSource(BuffStat.MORPH) == 2210005;
}
function enter(pi) {

4
scripts/quest/3314.js
View File

@@ -21,8 +21,8 @@
var status = -1;
function isPillUsed(ch) {
const MapleBuffStat = Java.type('client.MapleBuffStat');
return ch.getBuffSource(MapleBuffStat.HPREC) == 2022198;
const BuffStat = Java.type('client.BuffStat');
return ch.getBuffSource(BuffStat.HPREC) == 2022198;
}
function end(mode, type, selection) {

4
scripts/quest/3514.js
View File

@@ -44,8 +44,8 @@ function start(mode, type, selection) {
}
function usedPotion(ch) {
const MapleBuffStat = Java.type('client.MapleBuffStat');
return ch.getBuffSource(MapleBuffStat.HPREC) == 2022337;
const BuffStat = Java.type('client.BuffStat');
return ch.getBuffSource(BuffStat.HPREC) == 2022337;
}
function end(mode, type, selection) {

4
scripts/quest/3941.js
View File

@@ -21,8 +21,8 @@
*/
function isTigunMorphed(ch) {
const MapleBuffStat = Java.type('client.MapleBuffStat');
return ch.getBuffSource(MapleBuffStat.MORPH) == 2210005;
const BuffStat = Java.type('client.BuffStat');
return ch.getBuffSource(BuffStat.MORPH) == 2210005;
}
var status = -1;

28
src/main/java/client/MapleBuffStat.java → src/main/java/client/BuffStat.java
View File

@@ -21,7 +21,7 @@
*/
package client;
public enum MapleBuffStat {
public enum BuffStat {
//SLOW(0x1L),
MORPH(0x2L),
RECOVERY(0x4L),
@@ -42,21 +42,21 @@ public enum MapleBuffStat {
GHOST_MORPH(0x20000L),
AURA(0x40000L),
CONFUSE(0x80000L),
// ------ COUPON feature ------
COUPON_EXP1(0x100000L),
COUPON_EXP2(0x200000L),
COUPON_EXP3(0x400000L), COUPON_EXP4(0x400000L),
COUPON_DRP1(0x800000L),
COUPON_DRP2(0x1000000L), COUPON_DRP3(0x1000000L),
// ------ monster card buffs, thanks to Arnah (Vertisy) ------
ITEM_UP_BY_ITEM(0x100000L),
RESPECT_PIMMUNE(0x200000L),
RESPECT_MIMMUNE(0x400000L),
DEFENSE_ATT(0x800000L),
DEFENSE_STATE(0x1000000L),
HPREC(0x2000000L),
MPREC(0x4000000L),
BERSERK_FURY(0x8000000L),
@@ -97,15 +97,15 @@ public enum MapleBuffStat {
EXP_INCREASE(0x2000000000000000L),
WEAKEN(0x4000000000000000L),
MAP_PROTECTION(0x8000000000000000L),
//all incorrect buffstats
SLOW(0x200000000L, true),
ELEMENTAL_RESET(0x200000000L, true),
MAGIC_SHIELD(0x400000000L, true),
MAGIC_RESISTANCE(0x800000000L, true),
SLOW(0x200000000L, true),
ELEMENTAL_RESET(0x200000000L, true),
MAGIC_SHIELD(0x400000000L, true),
MAGIC_RESISTANCE(0x800000000L, true),
// needs Soul Stone
//end incorrect buffstats
WIND_WALK(0x400000000L, true),
ARAN_COMBO(0x1000000000L, true),
COMBO_DRAIN(0x2000000000L, true),
@@ -116,19 +116,19 @@ public enum MapleBuffStat {
ENERGY_CHARGE(0x4000000000000L, true),
DASH2(0x8000000000000L, true), // correct (speed)
DASH(0x10000000000000L, true), // correct (jump)
MONSTER_RIDING(0x20000000000000L, true),
MONSTER_RIDING(0x20000000000000L, true),
SPEED_INFUSION(0x40000000000000L, true),
HOMING_BEACON(0x80000000000000L, true);
private final long i;
private final boolean isFirst;
private MapleBuffStat(long i, boolean isFirst) {
BuffStat(long i, boolean isFirst) {
this.i = i;
this.isFirst = isFirst;
}
private MapleBuffStat(long i) {
BuffStat(long i) {
this.i = i;
this.isFirst = false;
}
@@ -140,7 +140,7 @@ public enum MapleBuffStat {
public boolean isFirst() {
return isFirst;
}
@Override
public String toString() {
return name();

352
src/main/java/client/MapleCharacter.java
View File

@@ -183,10 +183,10 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
private Map<Skill, SkillEntry> skills = new LinkedHashMap<>();
private Map<Integer, Integer> activeCoupons = new LinkedHashMap<>();
private Map<Integer, Integer> activeCouponRates = new LinkedHashMap<>();
private EnumMap<MapleBuffStat, MapleBuffStatValueHolder> effects = new EnumMap<>(MapleBuffStat.class);
private Map<MapleBuffStat, Byte> buffEffectsCount = new LinkedHashMap<>();
private EnumMap<BuffStat, MapleBuffStatValueHolder> effects = new EnumMap<>(BuffStat.class);
private Map<BuffStat, Byte> buffEffectsCount = new LinkedHashMap<>();
private Map<MapleDisease, Long> diseaseExpires = new LinkedHashMap<>();
private Map<Integer, Map<MapleBuffStat, MapleBuffStatValueHolder>> buffEffects = new LinkedHashMap<>(); // non-overriding buffs thanks to Ronan
private Map<Integer, Map<BuffStat, MapleBuffStatValueHolder>> buffEffects = new LinkedHashMap<>(); // non-overriding buffs thanks to Ronan
private Map<Integer, Long> buffExpires = new LinkedHashMap<>();
private Map<Integer, KeyBinding> keymap = new LinkedHashMap<>();
private Map<Integer, MapleSummon> summons = new LinkedHashMap<>();
@@ -755,7 +755,7 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
public void setCombo(short count) {
if (count < combocounter) {
cancelEffectFromBuffStat(MapleBuffStat.ARAN_COMBO);
cancelEffectFromBuffStat(BuffStat.ARAN_COMBO);
}
combocounter = (short) Math.min(30000, count);
if (count > 0) {
@@ -826,7 +826,7 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
if (!hide) {
this.hidden = false;
sendPacket(PacketCreator.getGMEffect(0x10, (byte) 0));
List<MapleBuffStat> dsstat = Collections.singletonList(MapleBuffStat.DARKSIGHT);
List<BuffStat> dsstat = Collections.singletonList(BuffStat.DARKSIGHT);
getMap().broadcastGMMessage(this, PacketCreator.cancelForeignBuff(id, dsstat), false);
getMap().broadcastSpawnPlayerMapObjectMessage(this, this, false);
@@ -844,7 +844,7 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
if (!login) {
getMap().broadcastNONGMMessage(this, PacketCreator.removePlayerFromMap(getId()), false);
}
List<Pair<MapleBuffStat, Integer>> ldsstat = Collections.singletonList(new Pair<MapleBuffStat, Integer>(MapleBuffStat.DARKSIGHT, 0));
List<Pair<BuffStat, Integer>> ldsstat = Collections.singletonList(new Pair<BuffStat, Integer>(BuffStat.DARKSIGHT, 0));
getMap().broadcastGMMessage(this, PacketCreator.giveForeignBuff(id, ldsstat), false);
this.releaseControlledMonsters();
}
@@ -870,7 +870,7 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
}
}
private void cancelPlayerBuffs(List<MapleBuffStat> buffstats) {
private void cancelPlayerBuffs(List<BuffStat> buffstats) {
if (client.getChannelServer().getPlayerStorage().getCharacterById(getId()) != null) {
updateLocalStats();
sendPacket(PacketCreator.cancelBuff(buffstats));
@@ -1166,8 +1166,8 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
broadcastChangeJob();
if (GameConstants.hasSPTable(newJob) && newJob.getId() != 2001) {
if (getBuffedValue(MapleBuffStat.MONSTER_RIDING) != null) {
cancelBuffStats(MapleBuffStat.MONSTER_RIDING);
if (getBuffedValue(BuffStat.MONSTER_RIDING) != null) {
cancelBuffStats(BuffStat.MONSTER_RIDING);
}
createDragon();
}
@@ -1437,8 +1437,8 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
effLock.lock();
chrLock.lock();
try {
for(Entry<MapleBuffStat, MapleBuffStatValueHolder> mbs : effects.entrySet()) {
if(mbs.getKey() == MapleBuffStat.MAP_PROTECTION) {
for(Entry<BuffStat, MapleBuffStatValueHolder> mbs : effects.entrySet()) {
if(mbs.getKey() == BuffStat.MAP_PROTECTION) {
byte value = (byte)mbs.getValue().value;
if(value == 1 && ((returnMapid == 211000000 && thisMapid != 200082300) || returnMapid == 193000000)) {
@@ -2072,7 +2072,7 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
}
public boolean isRidingBattleship() {
Integer bv = getBuffedValue(MapleBuffStat.MONSTER_RIDING);
Integer bv = getBuffedValue(BuffStat.MONSTER_RIDING);
return bv != null && bv.equals(Corsair.BATTLE_SHIP);
}
@@ -2088,7 +2088,7 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
sendPacket(PacketCreator.skillCooldown(Corsair.BATTLE_SHIP, cooldown));
addCooldown(Corsair.BATTLE_SHIP, Server.getInstance().getCurrentTime(), (long)(cooldown * 1000));
removeCooldown(5221999);
cancelEffectFromBuffStat(MapleBuffStat.MONSTER_RIDING);
cancelEffectFromBuffStat(BuffStat.MONSTER_RIDING);
} else {
announceBattleshipHp();
addCooldown(5221999, 0, Long.MAX_VALUE);
@@ -2501,7 +2501,7 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
extraRecoveryTask = TimerManager.getInstance().register(new Runnable() {
@Override
public void run() {
if (getBuffSource(MapleBuffStat.HPREC) == -1 && getBuffSource(MapleBuffStat.MPREC) == -1) {
if (getBuffSource(BuffStat.HPREC) == -1 && getBuffSource(BuffStat.MPREC) == -1) {
stopExtraTask();
return;
}
@@ -3293,7 +3293,7 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
return character;
}
public Long getBuffedStarttime(MapleBuffStat effect) {
public Long getBuffedStarttime(BuffStat effect) {
effLock.lock();
chrLock.lock();
try {
@@ -3308,7 +3308,7 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
}
}
public Integer getBuffedValue(MapleBuffStat effect) {
public Integer getBuffedValue(BuffStat effect) {
effLock.lock();
chrLock.lock();
try {
@@ -3323,7 +3323,7 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
}
}
public int getBuffSource(MapleBuffStat stat) {
public int getBuffSource(BuffStat stat) {
effLock.lock();
chrLock.lock();
try {
@@ -3338,7 +3338,7 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
}
}
public MapleStatEffect getBuffEffect(MapleBuffStat stat) {
public MapleStatEffect getBuffEffect(BuffStat stat) {
effLock.lock();
chrLock.lock();
try {
@@ -3370,7 +3370,7 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
chrLock.lock();
try {
List<MapleBuffStatValueHolder> ret = new ArrayList<>();
for(Map<MapleBuffStat, MapleBuffStatValueHolder> bel : buffEffects.values()) {
for(Map<BuffStat, MapleBuffStatValueHolder> bel : buffEffects.values()) {
for(MapleBuffStatValueHolder mbsvh : bel.values()) {
ret.add(mbsvh);
}
@@ -3389,7 +3389,7 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
long curtime = Server.getInstance().getCurrentTime();
Map<Integer, PlayerBuffValueHolder> ret = new LinkedHashMap<>();
for(Map<MapleBuffStat, MapleBuffStatValueHolder> bel : buffEffects.values()) {
for(Map<BuffStat, MapleBuffStatValueHolder> bel : buffEffects.values()) {
for(MapleBuffStatValueHolder mbsvh : bel.values()) {
int srcid = mbsvh.effect.getBuffSourceId();
if(!ret.containsKey(srcid)) {
@@ -3404,12 +3404,12 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
}
}
public List<Pair<MapleBuffStat, Integer>> getAllActiveStatups() {
public List<Pair<BuffStat, Integer>> getAllActiveStatups() {
effLock.lock();
chrLock.lock();
try {
List<Pair<MapleBuffStat, Integer>> ret = new ArrayList<>();
for (MapleBuffStat mbs : effects.keySet()) {
List<Pair<BuffStat, Integer>> ret = new ArrayList<>();
for (BuffStat mbs : effects.keySet()) {
MapleBuffStatValueHolder mbsvh = effects.get(mbs);
ret.add(new Pair<>(mbs, mbsvh.value));
}
@@ -3451,14 +3451,14 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
return false;
}
private List<Pair<MapleBuffStat, Integer>> getActiveStatupsFromSourceid(int sourceid) { // already under effLock & chrLock
List<Pair<MapleBuffStat, Integer>> ret = new ArrayList<>();
List<Pair<MapleBuffStat, Integer>> singletonStatups = new ArrayList<>();
for(Entry<MapleBuffStat, MapleBuffStatValueHolder> bel : buffEffects.get(sourceid).entrySet()) {
MapleBuffStat mbs = bel.getKey();
private List<Pair<BuffStat, Integer>> getActiveStatupsFromSourceid(int sourceid) { // already under effLock & chrLock
List<Pair<BuffStat, Integer>> ret = new ArrayList<>();
List<Pair<BuffStat, Integer>> singletonStatups = new ArrayList<>();
for(Entry<BuffStat, MapleBuffStatValueHolder> bel : buffEffects.get(sourceid).entrySet()) {
BuffStat mbs = bel.getKey();
MapleBuffStatValueHolder mbsvh = effects.get(bel.getKey());
Pair<MapleBuffStat, Integer> p;
Pair<BuffStat, Integer> p;
if(mbsvh != null) {
p = new Pair<>(mbs, mbsvh.value);
} else {
@@ -3472,17 +3472,17 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
}
}
Collections.sort(ret, new Comparator<Pair<MapleBuffStat, Integer>>() {
Collections.sort(ret, new Comparator<Pair<BuffStat, Integer>>() {
@Override
public int compare(Pair<MapleBuffStat, Integer> p1, Pair<MapleBuffStat, Integer> p2) {
public int compare(Pair<BuffStat, Integer> p1, Pair<BuffStat, Integer> p2) {
return p1.getLeft().compareTo(p2.getLeft());
}
});
if (!singletonStatups.isEmpty()) {
Collections.sort(singletonStatups, new Comparator<Pair<MapleBuffStat, Integer>>() {
Collections.sort(singletonStatups, new Comparator<Pair<BuffStat, Integer>>() {
@Override
public int compare(Pair<MapleBuffStat, Integer> p1, Pair<MapleBuffStat, Integer> p2) {
public int compare(Pair<BuffStat, Integer> p1, Pair<BuffStat, Integer> p2) {
return p1.getLeft().compareTo(p2.getLeft());
}
});
@@ -3493,13 +3493,13 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
return ret;
}
private void addItemEffectHolder(Integer sourceid, long expirationtime, Map<MapleBuffStat, MapleBuffStatValueHolder> statups) {
private void addItemEffectHolder(Integer sourceid, long expirationtime, Map<BuffStat, MapleBuffStatValueHolder> statups) {
buffEffects.put(sourceid, statups);
buffExpires.put(sourceid, expirationtime);
}
private boolean removeEffectFromItemEffectHolder(Integer sourceid, MapleBuffStat buffStat) {
Map<MapleBuffStat, MapleBuffStatValueHolder> lbe = buffEffects.get(sourceid);
private boolean removeEffectFromItemEffectHolder(Integer sourceid, BuffStat buffStat) {
Map<BuffStat, MapleBuffStatValueHolder> lbe = buffEffects.get(sourceid);
if(lbe.remove(buffStat) != null) {
buffEffectsCount.put(buffStat, (byte)(buffEffectsCount.get(buffStat) - 1));
@@ -3516,9 +3516,9 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
}
private void removeItemEffectHolder(Integer sourceid) {
Map<MapleBuffStat, MapleBuffStatValueHolder> be = buffEffects.remove(sourceid);
Map<BuffStat, MapleBuffStatValueHolder> be = buffEffects.remove(sourceid);
if(be != null) {
for(Entry<MapleBuffStat, MapleBuffStatValueHolder> bei : be.entrySet()) {
for(Entry<BuffStat, MapleBuffStatValueHolder> bei : be.entrySet()) {
buffEffectsCount.put(bei.getKey(), (byte)(buffEffectsCount.get(bei.getKey()) - 1));
}
}
@@ -3526,10 +3526,10 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
buffExpires.remove(sourceid);
}
private void dropWorstEffectFromItemEffectHolder(MapleBuffStat mbs) {
private void dropWorstEffectFromItemEffectHolder(BuffStat mbs) {
Integer min = Integer.MAX_VALUE;
Integer srcid = -1;
for(Entry<Integer, Map<MapleBuffStat, MapleBuffStatValueHolder>> bpl: buffEffects.entrySet()) {
for(Entry<Integer, Map<BuffStat, MapleBuffStatValueHolder>> bpl: buffEffects.entrySet()) {
MapleBuffStatValueHolder mbsvh = bpl.getValue().get(mbs);
if(mbsvh != null) {
if(mbsvh.value < min) {
@@ -3542,10 +3542,10 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
removeEffectFromItemEffectHolder(srcid, mbs);
}
private MapleBuffStatValueHolder fetchBestEffectFromItemEffectHolder(MapleBuffStat mbs) {
private MapleBuffStatValueHolder fetchBestEffectFromItemEffectHolder(BuffStat mbs) {
Pair<Integer, Integer> max = new Pair<>(Integer.MIN_VALUE, 0);
MapleBuffStatValueHolder mbsvh = null;
for(Entry<Integer, Map<MapleBuffStat, MapleBuffStatValueHolder>> bpl: buffEffects.entrySet()) {
for(Entry<Integer, Map<BuffStat, MapleBuffStatValueHolder>> bpl: buffEffects.entrySet()) {
MapleBuffStatValueHolder mbsvhi = bpl.getValue().get(mbs);
if(mbsvhi != null) {
if(!mbsvhi.effect.isActive(this)) {
@@ -3568,7 +3568,7 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
return mbsvh;
}
private void extractBuffValue(int sourceid, MapleBuffStat stat) {
private void extractBuffValue(int sourceid, BuffStat stat) {
chrLock.lock();
try {
removeEffectFromItemEffectHolder(sourceid, stat);
@@ -3583,14 +3583,14 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
try {
System.out.println("-------------------");
System.out.println("CACHED BUFF COUNT: ");
for(Entry<MapleBuffStat, Byte> bpl : buffEffectsCount.entrySet()) {
for(Entry<BuffStat, Byte> bpl : buffEffectsCount.entrySet()) {
System.out.println(bpl.getKey() + ": " + bpl.getValue());
}
System.out.println("-------------------");
System.out.println("CACHED BUFFS: ");
for(Entry<Integer, Map<MapleBuffStat, MapleBuffStatValueHolder>> bpl : buffEffects.entrySet()) {
for(Entry<Integer, Map<BuffStat, MapleBuffStatValueHolder>> bpl : buffEffects.entrySet()) {
System.out.print(bpl.getKey() + ": ");
for(Entry<MapleBuffStat, MapleBuffStatValueHolder> pble : bpl.getValue().entrySet()) {
for(Entry<BuffStat, MapleBuffStatValueHolder> pble : bpl.getValue().entrySet()) {
System.out.print(pble.getKey().name() + pble.getValue().value + ", ");
}
System.out.println();
@@ -3598,7 +3598,7 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
System.out.println("-------------------");
System.out.println("IN ACTION:");
for(Entry<MapleBuffStat, MapleBuffStatValueHolder> bpl : effects.entrySet()) {
for(Entry<BuffStat, MapleBuffStatValueHolder> bpl : effects.entrySet()) {
System.out.println(bpl.getKey().name() + " -> " + MapleItemInformationProvider.getInstance().getName(bpl.getValue().effect.getSourceId()));
}
} finally {
@@ -3611,7 +3611,7 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
effLock.lock();
chrLock.lock();
try {
for(Entry<MapleBuffStat, Byte> mbsl : buffEffectsCount.entrySet()) {
for(Entry<BuffStat, Byte> mbsl : buffEffectsCount.entrySet()) {
System.out.println(mbsl.getKey().name() + " -> " + mbsl.getValue());
}
} finally {
@@ -3625,9 +3625,9 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
effLock.lock();
chrLock.lock();
try {
cancelEffectFromBuffStat(MapleBuffStat.SUMMON);
cancelEffectFromBuffStat(MapleBuffStat.PUPPET);
cancelEffectFromBuffStat(MapleBuffStat.COMBO);
cancelEffectFromBuffStat(BuffStat.SUMMON);
cancelEffectFromBuffStat(BuffStat.PUPPET);
cancelEffectFromBuffStat(BuffStat.COMBO);
effects.clear();
@@ -3644,8 +3644,8 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
effLock.lock();
chrLock.lock();
try {
for(Entry<Integer, Map<MapleBuffStat, MapleBuffStatValueHolder>> bpl : buffEffects.entrySet()) {
for(Entry<MapleBuffStat, MapleBuffStatValueHolder> mbse : bpl.getValue().entrySet()) {
for(Entry<Integer, Map<BuffStat, MapleBuffStatValueHolder>> bpl : buffEffects.entrySet()) {
for(Entry<BuffStat, MapleBuffStatValueHolder> mbse : bpl.getValue().entrySet()) {
mseBuffs.put(mbse.getValue().effect, mbse.getValue().startTime);
}
}
@@ -3660,8 +3660,8 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
}
}
private void dropBuffStats(List<Pair<MapleBuffStat, MapleBuffStatValueHolder>> effectsToCancel) {
for (Pair<MapleBuffStat, MapleBuffStatValueHolder> cancelEffectCancelTasks : effectsToCancel) {
private void dropBuffStats(List<Pair<BuffStat, MapleBuffStatValueHolder>> effectsToCancel) {
for (Pair<BuffStat, MapleBuffStatValueHolder> cancelEffectCancelTasks : effectsToCancel) {
//boolean nestedCancel = false;
chrLock.lock();
@@ -3685,18 +3685,18 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
}
}
private List<Pair<MapleBuffStat, MapleBuffStatValueHolder>> deregisterBuffStats(Map<MapleBuffStat, MapleBuffStatValueHolder> stats) {
private List<Pair<BuffStat, MapleBuffStatValueHolder>> deregisterBuffStats(Map<BuffStat, MapleBuffStatValueHolder> stats) {
chrLock.lock();
try {
List<Pair<MapleBuffStat, MapleBuffStatValueHolder>> effectsToCancel = new ArrayList<>(stats.size());
for (Entry<MapleBuffStat, MapleBuffStatValueHolder> stat : stats.entrySet()) {
List<Pair<BuffStat, MapleBuffStatValueHolder>> effectsToCancel = new ArrayList<>(stats.size());
for (Entry<BuffStat, MapleBuffStatValueHolder> stat : stats.entrySet()) {
int sourceid = stat.getValue().effect.getBuffSourceId();
if(!buffEffects.containsKey(sourceid)) {
buffExpires.remove(sourceid);
}
MapleBuffStat mbs = stat.getKey();
BuffStat mbs = stat.getKey();
effectsToCancel.add(new Pair<>(mbs, stat.getValue()));
MapleBuffStatValueHolder mbsvh = effects.get(mbs);
@@ -3704,12 +3704,12 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
mbsvh.bestApplied = true;
effects.remove(mbs);
if (mbs == MapleBuffStat.RECOVERY) {
if (mbs == BuffStat.RECOVERY) {
if (recoveryTask != null) {
recoveryTask.cancel(false);
recoveryTask = null;
}
} else if (mbs == MapleBuffStat.SUMMON || mbs == MapleBuffStat.PUPPET) {
} else if (mbs == BuffStat.SUMMON || mbs == BuffStat.PUPPET) {
int summonId = mbsvh.effect.getSourceId();
MapleSummon summon = summons.get(summonId);
@@ -3732,11 +3732,11 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
}
}
}
} else if (mbs == MapleBuffStat.DRAGONBLOOD) {
} else if (mbs == BuffStat.DRAGONBLOOD) {
dragonBloodSchedule.cancel(false);
dragonBloodSchedule = null;
} else if (mbs == MapleBuffStat.HPREC || mbs == MapleBuffStat.MPREC) {
if(mbs == MapleBuffStat.HPREC) {
} else if (mbs == BuffStat.HPREC || mbs == BuffStat.MPREC) {
if(mbs == BuffStat.HPREC) {
extraHpRec = 0;
} else {
extraMpRec = 0;
@@ -3792,7 +3792,7 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
return ret;
}
private static MapleStatEffect getEffectFromBuffSource(Map<MapleBuffStat, MapleBuffStatValueHolder> buffSource) {
private static MapleStatEffect getEffectFromBuffSource(Map<BuffStat, MapleBuffStatValueHolder> buffSource) {
try {
return buffSource.entrySet().iterator().next().getValue().effect;
} catch (Exception e) {
@@ -3815,23 +3815,23 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
public void updateActiveEffects() {
effLock.lock(); // thanks davidlafriniere, maple006, RedHat for pointing a deadlock occurring here
try {
Set<MapleBuffStat> updatedBuffs = new LinkedHashSet<>();
Set<BuffStat> updatedBuffs = new LinkedHashSet<>();
Set<MapleStatEffect> activeEffects = new LinkedHashSet<>();
for (MapleBuffStatValueHolder mse : effects.values()) {
activeEffects.add(mse.effect);
}
for (Map<MapleBuffStat, MapleBuffStatValueHolder> buff : buffEffects.values()) {
for (Map<BuffStat, MapleBuffStatValueHolder> buff : buffEffects.values()) {
MapleStatEffect mse = getEffectFromBuffSource(buff);
if (isUpdatingEffect(activeEffects, mse)) {
for (Pair<MapleBuffStat, Integer> p : mse.getStatups()) {
for (Pair<BuffStat, Integer> p : mse.getStatups()) {
updatedBuffs.add(p.getLeft());
}
}
}
for (MapleBuffStat mbs : updatedBuffs) {
for (BuffStat mbs : updatedBuffs) {
effects.remove(mbs);
}
@@ -3841,18 +3841,18 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
}
}
private void updateEffects(Set<MapleBuffStat> removedStats) {
private void updateEffects(Set<BuffStat> removedStats) {
effLock.lock();
chrLock.lock();
try {
Set<MapleBuffStat> retrievedStats = new LinkedHashSet<>();
Set<BuffStat> retrievedStats = new LinkedHashSet<>();
for (MapleBuffStat mbs : removedStats) {
for (BuffStat mbs : removedStats) {
fetchBestEffectFromItemEffectHolder(mbs);
MapleBuffStatValueHolder mbsvh = effects.get(mbs);
if (mbsvh != null) {
for (Pair<MapleBuffStat, Integer> statup : mbsvh.effect.getStatups()) {
for (Pair<BuffStat, Integer> statup : mbsvh.effect.getStatups()) {
retrievedStats.add(statup.getLeft());
}
}
@@ -3866,7 +3866,7 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
}
private boolean cancelEffect(MapleStatEffect effect, boolean overwrite, long startTime, boolean firstCancel) {
Set<MapleBuffStat> removedStats = new LinkedHashSet<>();
Set<BuffStat> removedStats = new LinkedHashSet<>();
dropBuffStats(cancelEffectInternal(effect, overwrite, startTime, removedStats));
updateLocalStats();
updateEffects(removedStats);
@@ -3874,9 +3874,9 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
return !removedStats.isEmpty();
}
private List<Pair<MapleBuffStat, MapleBuffStatValueHolder>> cancelEffectInternal(MapleStatEffect effect, boolean overwrite, long startTime, Set<MapleBuffStat> removedStats) {
Map<MapleBuffStat, MapleBuffStatValueHolder> buffstats = null;
MapleBuffStat ombs;
private List<Pair<BuffStat, MapleBuffStatValueHolder>> cancelEffectInternal(MapleStatEffect 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
buffstats = extractCurrentBuffStats(effect);
} else if ((ombs = getSingletonStatupFromEffect(effect)) != null) { // removing all effects of a buff having non-shareable buff stat.
@@ -3894,7 +3894,7 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
stopChairTask();
}
List<Pair<MapleBuffStat, MapleBuffStatValueHolder>> toCancel = deregisterBuffStats(buffstats);
List<Pair<BuffStat, MapleBuffStatValueHolder>> toCancel = deregisterBuffStats(buffstats);
if (effect.isMonsterRiding()) {
this.getClient().getWorldServer().unregisterMountHunger(this);
this.getMount().setActive(false);
@@ -3907,7 +3907,7 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
return toCancel;
}
public void cancelEffectFromBuffStat(MapleBuffStat stat) {
public void cancelEffectFromBuffStat(BuffStat stat) {
MapleBuffStatValueHolder effect;
effLock.lock();
@@ -3923,14 +3923,14 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
}
}
public void cancelBuffStats(MapleBuffStat stat) {
public void cancelBuffStats(BuffStat stat) {
effLock.lock();
try {
List<Pair<Integer, MapleBuffStatValueHolder>> cancelList = new LinkedList<>();
chrLock.lock();
try {
for(Entry<Integer, Map<MapleBuffStat, MapleBuffStatValueHolder>> bel : this.buffEffects.entrySet()) {
for(Entry<Integer, Map<BuffStat, MapleBuffStatValueHolder>> bel : this.buffEffects.entrySet()) {
MapleBuffStatValueHolder beli = bel.getValue().get(stat);
if(beli != null) {
cancelList.add(new Pair<>(bel.getKey(), beli));
@@ -3940,7 +3940,7 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
chrLock.unlock();
}
Map<MapleBuffStat, MapleBuffStatValueHolder> buffStatList = new LinkedHashMap<>();
Map<BuffStat, MapleBuffStatValueHolder> buffStatList = new LinkedHashMap<>();
for(Pair<Integer, MapleBuffStatValueHolder> p : cancelList) {
buffStatList.put(stat, p.getRight());
extractBuffValue(p.getLeft(), stat);
@@ -3953,14 +3953,14 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
cancelPlayerBuffs(Arrays.asList(stat));
}
private Map<MapleBuffStat, MapleBuffStatValueHolder> extractCurrentBuffStats(MapleStatEffect effect) {
private Map<BuffStat, MapleBuffStatValueHolder> extractCurrentBuffStats(MapleStatEffect effect) {
chrLock.lock();
try {
Map<MapleBuffStat, MapleBuffStatValueHolder> stats = new LinkedHashMap<>();
Map<MapleBuffStat, MapleBuffStatValueHolder> buffList = buffEffects.remove(effect.getBuffSourceId());
Map<BuffStat, MapleBuffStatValueHolder> stats = new LinkedHashMap<>();
Map<BuffStat, MapleBuffStatValueHolder> buffList = buffEffects.remove(effect.getBuffSourceId());
if(buffList != null) {
for (Entry<MapleBuffStat, MapleBuffStatValueHolder> stateffect : buffList.entrySet()) {
for (Entry<BuffStat, MapleBuffStatValueHolder> stateffect : buffList.entrySet()) {
stats.put(stateffect.getKey(), stateffect.getValue());
buffEffectsCount.put(stateffect.getKey(), (byte)(buffEffectsCount.get(stateffect.getKey()) - 1));
}
@@ -3972,17 +3972,17 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
}
}
private Map<MapleBuffStat, MapleBuffStatValueHolder> extractLeastRelevantStatEffectsIfFull(MapleStatEffect effect) {
Map<MapleBuffStat, MapleBuffStatValueHolder> extractedStatBuffs = new LinkedHashMap<>();
private Map<BuffStat, MapleBuffStatValueHolder> extractLeastRelevantStatEffectsIfFull(MapleStatEffect effect) {
Map<BuffStat, MapleBuffStatValueHolder> extractedStatBuffs = new LinkedHashMap<>();
chrLock.lock();
try {
Map<MapleBuffStat, Byte> stats = new LinkedHashMap<>();
Map<MapleBuffStat, MapleBuffStatValueHolder> minStatBuffs = new LinkedHashMap<>();
Map<BuffStat, Byte> stats = new LinkedHashMap<>();
Map<BuffStat, MapleBuffStatValueHolder> minStatBuffs = new LinkedHashMap<>();
for(Entry<Integer, Map<MapleBuffStat, MapleBuffStatValueHolder>> mbsvhi : buffEffects.entrySet()) {
for(Entry<MapleBuffStat, MapleBuffStatValueHolder> mbsvhe : mbsvhi.getValue().entrySet()) {
MapleBuffStat mbs = mbsvhe.getKey();
for(Entry<Integer, Map<BuffStat, MapleBuffStatValueHolder>> mbsvhi : buffEffects.entrySet()) {
for(Entry<BuffStat, MapleBuffStatValueHolder> mbsvhe : mbsvhi.getValue().entrySet()) {
BuffStat mbs = mbsvhe.getKey();
Byte b = stats.get(mbs);
if(b != null) {
@@ -3997,18 +3997,18 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
}
}
Set<MapleBuffStat> effectStatups = new LinkedHashSet<>();
for(Pair<MapleBuffStat, Integer> efstat : effect.getStatups()) {
Set<BuffStat> effectStatups = new LinkedHashSet<>();
for(Pair<BuffStat, Integer> efstat : effect.getStatups()) {
effectStatups.add(efstat.getLeft());
}
for(Entry<MapleBuffStat, Byte> it : stats.entrySet()) {
for(Entry<BuffStat, Byte> it : stats.entrySet()) {
boolean uniqueBuff = isSingletonStatup(it.getKey());
if(it.getValue() >= (!uniqueBuff ? YamlConfig.config.server.MAX_MONITORED_BUFFSTATS : 1) && effectStatups.contains(it.getKey())) {
MapleBuffStatValueHolder mbsvh = minStatBuffs.get(it.getKey());
Map<MapleBuffStat, MapleBuffStatValueHolder> lpbe = buffEffects.get(mbsvh.effect.getBuffSourceId());
Map<BuffStat, MapleBuffStatValueHolder> lpbe = buffEffects.get(mbsvh.effect.getBuffSourceId());
lpbe.remove(it.getKey());
buffEffectsCount.put(it.getKey(), (byte)(buffEffectsCount.get(it.getKey()) - 1));
@@ -4025,9 +4025,9 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
return extractedStatBuffs;
}
private void cancelInactiveBuffStats(Set<MapleBuffStat> retrievedStats, Set<MapleBuffStat> removedStats) {
List<MapleBuffStat> inactiveStats = new LinkedList<>();
for (MapleBuffStat mbs : removedStats) {
private void cancelInactiveBuffStats(Set<BuffStat> retrievedStats, Set<BuffStat> removedStats) {
List<BuffStat> inactiveStats = new LinkedList<>();
for (BuffStat mbs : removedStats) {
if (!retrievedStats.contains(mbs)) {
inactiveStats.add(mbs);
}
@@ -4039,10 +4039,10 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
}
}
private static Map<MapleStatEffect, Integer> topologicalSortLeafStatCount(Map<MapleBuffStat, Stack<MapleStatEffect>> buffStack) {
private static Map<MapleStatEffect, Integer> topologicalSortLeafStatCount(Map<BuffStat, Stack<MapleStatEffect>> buffStack) {
Map<MapleStatEffect, Integer> leafBuffCount = new LinkedHashMap<>();
for (Entry<MapleBuffStat, Stack<MapleStatEffect>> e : buffStack.entrySet()) {
for (Entry<BuffStat, Stack<MapleStatEffect>> e : buffStack.entrySet()) {
Stack<MapleStatEffect> mseStack = e.getValue();
if (mseStack.isEmpty()) {
continue;
@@ -4060,9 +4060,9 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
return leafBuffCount;
}
private static List<MapleStatEffect> topologicalSortRemoveLeafStats(Map<MapleStatEffect, Set<MapleBuffStat>> stackedBuffStats, Map<MapleBuffStat, Stack<MapleStatEffect>> buffStack, Map<MapleStatEffect, Integer> leafStatCount) {
private static List<MapleStatEffect> topologicalSortRemoveLeafStats(Map<MapleStatEffect, Set<BuffStat>> stackedBuffStats, Map<BuffStat, Stack<MapleStatEffect>> buffStack, Map<MapleStatEffect, Integer> leafStatCount) {
List<MapleStatEffect> clearedStatEffects = new LinkedList<>();
Set<MapleBuffStat> clearedStats = new LinkedHashSet<>();
Set<BuffStat> clearedStats = new LinkedHashSet<>();
for (Entry<MapleStatEffect, Integer> e : leafStatCount.entrySet()) {
MapleStatEffect mse = e.getKey();
@@ -4070,13 +4070,13 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
if (stackedBuffStats.get(mse).size() <= e.getValue()) {
clearedStatEffects.add(mse);
for (MapleBuffStat mbs : stackedBuffStats.get(mse)) {
for (BuffStat mbs : stackedBuffStats.get(mse)) {
clearedStats.add(mbs);
}
}
}
for (MapleBuffStat mbs : clearedStats) {
for (BuffStat mbs : clearedStats) {
MapleStatEffect mse = buffStack.get(mbs).pop();
stackedBuffStats.get(mse).remove(mbs);
}
@@ -4084,8 +4084,8 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
return clearedStatEffects;
}
private static void topologicalSortRebaseLeafStats(Map<MapleStatEffect, Set<MapleBuffStat>> stackedBuffStats, Map<MapleBuffStat, Stack<MapleStatEffect>> buffStack) {
for (Entry<MapleBuffStat, Stack<MapleStatEffect>> e : buffStack.entrySet()) {
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();
if (!mseStack.isEmpty()) {
@@ -4095,12 +4095,12 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
}
}
private static List<MapleStatEffect> topologicalSortEffects(Map<MapleBuffStat, List<Pair<MapleStatEffect, Integer>>> buffEffects) {
Map<MapleStatEffect, Set<MapleBuffStat>> stackedBuffStats = new LinkedHashMap<>();
Map<MapleBuffStat, Stack<MapleStatEffect>> buffStack = new LinkedHashMap<>();
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<>();
for (Entry<MapleBuffStat, List<Pair<MapleStatEffect, Integer>>> e : buffEffects.entrySet()) {
MapleBuffStat mbs = e.getKey();
for (Entry<BuffStat, List<Pair<MapleStatEffect, Integer>>> e : buffEffects.entrySet()) {
BuffStat mbs = e.getKey();
Stack<MapleStatEffect> mbsStack = new Stack<>();
buffStack.put(mbs, mbsStack);
@@ -4109,7 +4109,7 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
MapleStatEffect mse = emse.getLeft();
mbsStack.push(mse);
Set<MapleBuffStat> mbsStats = stackedBuffStats.get(mse);
Set<BuffStat> mbsStats = stackedBuffStats.get(mse);
if (mbsStats == null) {
mbsStats = new LinkedHashSet<>();
stackedBuffStats.put(mse, mbsStats);
@@ -4136,13 +4136,13 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
}
private static List<MapleStatEffect> sortEffectsList(Map<MapleStatEffect, Integer> updateEffectsList) {
Map<MapleBuffStat, List<Pair<MapleStatEffect, Integer>>> buffEffects = new LinkedHashMap<>();
Map<BuffStat, List<Pair<MapleStatEffect, Integer>>> buffEffects = new LinkedHashMap<>();
for (Entry<MapleStatEffect, Integer> p : updateEffectsList.entrySet()) {
MapleStatEffect mse = p.getKey();
for (Pair<MapleBuffStat, Integer> statup : mse.getStatups()) {
MapleBuffStat stat = statup.getLeft();
for (Pair<BuffStat, Integer> statup : mse.getStatups()) {
BuffStat stat = statup.getLeft();
List<Pair<MapleStatEffect, Integer>> statBuffs = buffEffects.get(stat);
if (statBuffs == null) {
@@ -4162,14 +4162,14 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
}
};
for (Entry<MapleBuffStat, List<Pair<MapleStatEffect, Integer>>> statBuffs : buffEffects.entrySet()) {
for (Entry<BuffStat, List<Pair<MapleStatEffect, Integer>>> statBuffs : buffEffects.entrySet()) {
Collections.sort(statBuffs.getValue(), cmp);
}
return topologicalSortEffects(buffEffects);
}
private List<Pair<Integer, Pair<MapleStatEffect, Long>>> propagatePriorityBuffEffectUpdates(Set<MapleBuffStat> retrievedStats) {
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<>();
@@ -4183,8 +4183,8 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
MapleStatEffect mse = mbsvh.effect;
int buffSourceId = mse.getBuffSourceId();
if (isPriorityBuffSourceid(buffSourceId) && !hasActiveBuff(buffSourceId)) {
for (Pair<MapleBuffStat, Integer> ps : mse.getStatups()) {
MapleBuffStat mbs = ps.getLeft();
for (Pair<BuffStat, Integer> ps : mse.getStatups()) {
BuffStat mbs = ps.getLeft();
if (retrievedStats.contains(mbs)) {
MapleBuffStatValueHolder mbsvhe = effects.get(mbs);
@@ -4207,14 +4207,14 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
return priorityUpdateEffects;
}
private void propagateBuffEffectUpdates(Map<Integer, Pair<MapleStatEffect, Long>> retrievedEffects, Set<MapleBuffStat> retrievedStats, Set<MapleBuffStat> removedStats) {
private void propagateBuffEffectUpdates(Map<Integer, Pair<MapleStatEffect, Long>> retrievedEffects, Set<BuffStat> retrievedStats, Set<BuffStat> removedStats) {
cancelInactiveBuffStats(retrievedStats, removedStats);
if (retrievedStats.isEmpty()) {
return;
}
Map<MapleBuffStat, Pair<Integer, MapleStatEffect>> maxBuffValue = new LinkedHashMap<>();
for(MapleBuffStat mbs : retrievedStats) {
Map<BuffStat, Pair<Integer, MapleStatEffect>> maxBuffValue = new LinkedHashMap<>();
for(BuffStat mbs : retrievedStats) {
MapleBuffStatValueHolder mbsvh = effects.get(mbs);
if(mbsvh != null) {
retrievedEffects.put(mbsvh.effect.getBuffSourceId(), new Pair<>(mbsvh.effect, mbsvh.startTime));
@@ -4237,15 +4237,15 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
for(MapleStatEffect mse : mseList) {
int maxEffectiveStatup = Integer.MIN_VALUE;
for(Pair<MapleBuffStat, Integer> st : mse.getStatups()) {
MapleBuffStat mbs = st.getLeft();
for(Pair<BuffStat, Integer> st : mse.getStatups()) {
BuffStat mbs = st.getLeft();
boolean relevantStatup = true;
if(mbs == MapleBuffStat.WATK) { // not relevant for mages
if(mbs == BuffStat.WATK) { // not relevant for mages
if(mageJob) {
relevantStatup = false;
}
} else if(mbs == MapleBuffStat.MATK) { // not relevant for non-mages
} else if(mbs == BuffStat.MATK) { // not relevant for non-mages
if(!mageJob) {
relevantStatup = false;
}
@@ -4283,11 +4283,11 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
toUpdateEffects.add(new Pair<>(mse.getBuffSourceId(), retrievedEffects.get(mse.getBuffSourceId())));
}
List<Pair<MapleBuffStat, Integer>> activeStatups = new LinkedList<>();
List<Pair<BuffStat, Integer>> activeStatups = new LinkedList<>();
for(Pair<Integer, Pair<MapleStatEffect, Long>> lmse: toUpdateEffects) {
Pair<MapleStatEffect, Long> msel = lmse.getRight();
for(Pair<MapleBuffStat, Integer> statup : getActiveStatupsFromSourceid(lmse.getLeft())) {
for(Pair<BuffStat, Integer> statup : getActiveStatupsFromSourceid(lmse.getLeft())) {
activeStatups.add(statup);
}
@@ -4299,7 +4299,7 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
for(Pair<Integer, Pair<MapleStatEffect, Long>> lmse: priorityEffects) {
Pair<MapleStatEffect, Long> msel = lmse.getRight();
for(Pair<MapleBuffStat, Integer> statup : getActiveStatupsFromSourceid(lmse.getLeft())) {
for(Pair<BuffStat, Integer> statup : getActiveStatupsFromSourceid(lmse.getLeft())) {
activeStatups.add(statup);
}
@@ -4308,15 +4308,15 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
}
if (this.isRidingBattleship()) {
List<Pair<MapleBuffStat, Integer>> statups = new ArrayList<>(1);
statups.add(new Pair<>(MapleBuffStat.MONSTER_RIDING, 0));
List<Pair<BuffStat, Integer>> statups = new ArrayList<>(1);
statups.add(new Pair<>(BuffStat.MONSTER_RIDING, 0));
this.sendPacket(PacketCreator.giveBuff(1932000, 5221006, statups));
this.announceBattleshipHp();
}
}
private static MapleBuffStat getSingletonStatupFromEffect(MapleStatEffect mse) {
for(Pair<MapleBuffStat, Integer> mbs : mse.getStatups()) {
private static BuffStat getSingletonStatupFromEffect(MapleStatEffect mse) {
for(Pair<BuffStat, Integer> mbs : mse.getStatups()) {
if(isSingletonStatup(mbs.getLeft())) {
return mbs.getLeft();
}
@@ -4325,7 +4325,7 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
return null;
}
private static boolean isSingletonStatup(MapleBuffStat mbs) {
private static boolean isSingletonStatup(BuffStat mbs) {
switch(mbs) { //HPREC and MPREC are supposed to be singleton
case COUPON_EXP1:
case COUPON_EXP2:
@@ -4367,7 +4367,7 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
}
}
private void addItemEffectHolderCount(MapleBuffStat stat) {
private void addItemEffectHolderCount(BuffStat stat) {
Byte val = buffEffectsCount.get(stat);
if (val != null) {
val = (byte) (val + 1);
@@ -4441,7 +4441,7 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
recoveryTask = TimerManager.getInstance().register(new Runnable() {
@Override
public void run() {
if (getBuffSource(MapleBuffStat.RECOVERY) == -1) {
if (getBuffSource(BuffStat.RECOVERY) == -1) {
chrLock.lock();
try {
if (recoveryTask != null) {
@@ -4491,10 +4491,10 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
chrLock.lock();
try {
Integer sourceid = effect.getBuffSourceId();
Map<MapleBuffStat, MapleBuffStatValueHolder> toDeploy;
Map<MapleBuffStat, MapleBuffStatValueHolder> appliedStatups = new LinkedHashMap<>();
Map<BuffStat, MapleBuffStatValueHolder> toDeploy;
Map<BuffStat, MapleBuffStatValueHolder> appliedStatups = new LinkedHashMap<>();
for(Pair<MapleBuffStat, Integer> ps : effect.getStatups()) {
for(Pair<BuffStat, Integer> ps : effect.getStatups()) {
appliedStatups.put(ps.getLeft(), new MapleBuffStatValueHolder(effect, starttime, ps.getRight()));
}
@@ -4502,8 +4502,8 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
if(YamlConfig.config.server.USE_BUFF_MOST_SIGNIFICANT) {
toDeploy = new LinkedHashMap<>();
Map<Integer, Pair<MapleStatEffect, Long>> retrievedEffects = new LinkedHashMap<>();
Set<MapleBuffStat> retrievedStats = new LinkedHashSet<>();
for (Entry<MapleBuffStat, MapleBuffStatValueHolder> statup : appliedStatups.entrySet()) {
Set<BuffStat> retrievedStats = new LinkedHashSet<>();
for (Entry<BuffStat, MapleBuffStatValueHolder> statup : appliedStatups.entrySet()) {
MapleBuffStatValueHolder mbsvh = effects.get(statup.getKey());
MapleBuffStatValueHolder statMbsvh = statup.getValue();
@@ -4512,7 +4512,7 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
toDeploy.put(statup.getKey(), statMbsvh);
} else {
if(!isSingletonStatup(statup.getKey())) {
for(Pair<MapleBuffStat, Integer> mbs : mbsvh.effect.getStatups()) {
for(Pair<BuffStat, Integer> mbs : mbsvh.effect.getStatups()) {
retrievedStats.add(mbs.getLeft());
}
}
@@ -4523,10 +4523,10 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
}
// should also propagate update from buffs shared with priority sourceids
Set<MapleBuffStat> updated = appliedStatups.keySet();
Set<BuffStat> updated = appliedStatups.keySet();
for (MapleBuffStatValueHolder mbsvh : this.getAllStatups()) {
if (isPriorityBuffSourceid(mbsvh.effect.getBuffSourceId())) {
for (Pair<MapleBuffStat, Integer> p : mbsvh.effect.getStatups()) {
for (Pair<BuffStat, Integer> p : mbsvh.effect.getStatups()) {
if (updated.contains(p.getLeft())) {
retrievedStats.add(p.getLeft());
}
@@ -4536,7 +4536,7 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
if(!isSilent) {
addItemEffectHolder(sourceid, expirationtime, appliedStatups);
for (Entry<MapleBuffStat, MapleBuffStatValueHolder> statup : toDeploy.entrySet()) {
for (Entry<BuffStat, MapleBuffStatValueHolder> statup : toDeploy.entrySet()) {
effects.put(statup.getKey(), statup.getValue());
}
@@ -4544,18 +4544,18 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
retrievedEffects.put(sourceid, new Pair<>(effect, starttime));
}
propagateBuffEffectUpdates(retrievedEffects, retrievedStats, new LinkedHashSet<MapleBuffStat>());
propagateBuffEffectUpdates(retrievedEffects, retrievedStats, new LinkedHashSet<BuffStat>());
}
} else {
for (Entry<MapleBuffStat, MapleBuffStatValueHolder> statup : appliedStatups.entrySet()) {
for (Entry<BuffStat, MapleBuffStatValueHolder> statup : appliedStatups.entrySet()) {
addItemEffectHolderCount(statup.getKey());
}
toDeploy = (active ? appliedStatups : new LinkedHashMap<MapleBuffStat, MapleBuffStatValueHolder>());
toDeploy = (active ? appliedStatups : new LinkedHashMap<BuffStat, MapleBuffStatValueHolder>());
}
addItemEffectHolder(sourceid, expirationtime, appliedStatups);
for (Entry<MapleBuffStat, MapleBuffStatValueHolder> statup : toDeploy.entrySet()) {
for (Entry<BuffStat, MapleBuffStatValueHolder> statup : toDeploy.entrySet()) {
effects.put(statup.getKey(), statup.getValue());
}
} finally {
@@ -4936,12 +4936,12 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
float rate = 100.0f;
if (itemid == 0) {
MapleStatEffect mseMeso = getBuffEffect(MapleBuffStat.MESO_UP_BY_ITEM);
MapleStatEffect mseMeso = getBuffEffect(BuffStat.MESO_UP_BY_ITEM);
if (mseMeso != null) {
rate += mseMeso.getCardRate(mapid, itemid);
}
} else {
MapleStatEffect mseItem = getBuffEffect(MapleBuffStat.ITEM_UP_BY_ITEM);
MapleStatEffect mseItem = getBuffEffect(BuffStat.ITEM_UP_BY_ITEM);
if (mseItem != null) {
rate += mseItem.getCardRate(mapid, itemid);
}
@@ -5846,7 +5846,7 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
return Collections.unmodifiableList(ret);
}
public MapleStatEffect getStatForBuff(MapleBuffStat effect) {
public MapleStatEffect getStatForBuff(BuffStat effect) {
effLock.lock();
chrLock.lock();
try {
@@ -5954,8 +5954,8 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
if (energybar > 10000) {
energybar = 10000;
}
List<Pair<MapleBuffStat, Integer>> stat = Collections.singletonList(new Pair<>(MapleBuffStat.ENERGY_CHARGE, energybar));
setBuffedValue(MapleBuffStat.ENERGY_CHARGE, energybar);
List<Pair<BuffStat, Integer>> stat = Collections.singletonList(new Pair<>(BuffStat.ENERGY_CHARGE, energybar));
setBuffedValue(BuffStat.ENERGY_CHARGE, energybar);
sendPacket(PacketCreator.giveBuff(energybar, 0, stat));
sendPacket(PacketCreator.showOwnBuffEffect(energycharge.getId(), 2));
getMap().broadcastPacket(this, PacketCreator.showBuffEffect(id, energycharge.getId(), 2));
@@ -5968,8 +5968,8 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
@Override
public void run() {
energybar = 0;
List<Pair<MapleBuffStat, Integer>> stat = Collections.singletonList(new Pair<>(MapleBuffStat.ENERGY_CHARGE, energybar));
setBuffedValue(MapleBuffStat.ENERGY_CHARGE, energybar);
List<Pair<BuffStat, Integer>> stat = Collections.singletonList(new Pair<>(BuffStat.ENERGY_CHARGE, energybar));
setBuffedValue(BuffStat.ENERGY_CHARGE, energybar);
sendPacket(PacketCreator.giveBuff(energybar, 0, stat));
getMap().broadcastPacket(chr, PacketCreator.cancelForeignFirstDebuff(id, ((long) 1) << 50));
}
@@ -5980,9 +5980,9 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
public void handleOrbconsume() {
int skillid = isCygnus() ? DawnWarrior.COMBO : Crusader.COMBO;
Skill combo = SkillFactory.getSkill(skillid);
List<Pair<MapleBuffStat, Integer>> stat = Collections.singletonList(new Pair<>(MapleBuffStat.COMBO, 1));
setBuffedValue(MapleBuffStat.COMBO, 1);
sendPacket(PacketCreator.giveBuff(skillid, combo.getEffect(getSkillLevel(combo)).getDuration() + (int) ((getBuffedStarttime(MapleBuffStat.COMBO) - System.currentTimeMillis())), stat));
List<Pair<BuffStat, Integer>> stat = Collections.singletonList(new Pair<>(BuffStat.COMBO, 1));
setBuffedValue(BuffStat.COMBO, 1);
sendPacket(PacketCreator.giveBuff(skillid, combo.getEffect(getSkillLevel(combo)).getDuration() + (int) ((getBuffedStarttime(BuffStat.COMBO) - System.currentTimeMillis())), stat));
getMap().broadcastMessage(this, PacketCreator.giveForeignBuff(getId(), stat), false);
}
@@ -6142,7 +6142,7 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
return true;
}
public boolean isBuffFrom(MapleBuffStat stat, Skill skill) {
public boolean isBuffFrom(BuffStat stat, Skill skill) {
effLock.lock();
chrLock.lock();
try {
@@ -7596,12 +7596,12 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
}
}
if (getBuffedValue(MapleBuffStat.MORPH) != null) {
cancelEffectFromBuffStat(MapleBuffStat.MORPH);
if (getBuffedValue(BuffStat.MORPH) != null) {
cancelEffectFromBuffStat(BuffStat.MORPH);
}
if (getBuffedValue(MapleBuffStat.MONSTER_RIDING) != null) {
cancelEffectFromBuffStat(MapleBuffStat.MONSTER_RIDING);
if (getBuffedValue(BuffStat.MONSTER_RIDING) != null) {
cancelEffectFromBuffStat(BuffStat.MONSTER_RIDING);
}
unsitChairInternal();
@@ -7750,11 +7750,11 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
localmagic = Math.min(localmagic, 2000);
Integer hbhp = getBuffedValue(MapleBuffStat.HYPERBODYHP);
Integer hbhp = getBuffedValue(BuffStat.HYPERBODYHP);
if (hbhp != null) {
localmaxhp += (hbhp.doubleValue() / 100) * localmaxhp;
}
Integer hbmp = getBuffedValue(MapleBuffStat.HYPERBODYMP);
Integer hbmp = getBuffedValue(BuffStat.HYPERBODYMP);
if (hbmp != null) {
localmaxmp += (hbmp.doubleValue() / 100) * localmaxmp;
}
@@ -7762,7 +7762,7 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
localmaxhp = Math.min(30000, localmaxhp);
localmaxmp = Math.min(30000, localmaxmp);
MapleStatEffect combo = getBuffEffect(MapleBuffStat.ARAN_COMBO);
MapleStatEffect combo = getBuffEffect(BuffStat.ARAN_COMBO);
if (combo != null) {
localwatk += combo.getX();
}
@@ -7773,7 +7773,7 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
localwatk += ceffect.getWatk();
}
Integer mwarr = getBuffedValue(MapleBuffStat.MAPLE_WARRIOR);
Integer mwarr = getBuffedValue(BuffStat.MAPLE_WARRIOR);
if (mwarr != null) {
localstr += getStr() * mwarr / 100;
localdex += getDex() * mwarr / 100;
@@ -7795,21 +7795,21 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
}
}
Integer watkbuff = getBuffedValue(MapleBuffStat.WATK);
Integer watkbuff = getBuffedValue(BuffStat.WATK);
if (watkbuff != null) {
localwatk += watkbuff.intValue();
}
Integer matkbuff = getBuffedValue(MapleBuffStat.MATK);
Integer matkbuff = getBuffedValue(BuffStat.MATK);
if (matkbuff != null) {
localmagic += matkbuff.intValue();
}
/*
Integer speedbuff = getBuffedValue(MapleBuffStat.SPEED);
Integer speedbuff = getBuffedValue(BuffStat.SPEED);
if (speedbuff != null) {
localspeed += speedbuff.intValue();
}
Integer jumpbuff = getBuffedValue(MapleBuffStat.JUMP);
Integer jumpbuff = getBuffedValue(BuffStat.JUMP);
if (jumpbuff != null) {
localjump += jumpbuff.intValue();
}
@@ -8831,7 +8831,7 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
sendPacket(PacketCreator.updateBuddyCapacity(capacity));
}
public void setBuffedValue(MapleBuffStat effect, int value) {
public void setBuffedValue(BuffStat effect, int value) {
effLock.lock();
chrLock.lock();
try {
@@ -10080,7 +10080,7 @@ public class MapleCharacter extends AbstractMapleCharacterObject {
}
if (this.isHidden()) {
List<Pair<MapleBuffStat, Integer>> dsstat = Collections.singletonList(new Pair<>(MapleBuffStat.DARKSIGHT, 0));
List<Pair<BuffStat, Integer>> dsstat = Collections.singletonList(new Pair<>(BuffStat.DARKSIGHT, 0));
getMap().broadcastGMMessage(this, PacketCreator.giveForeignBuff(getId(), dsstat), false);
}
}

6
src/main/java/client/command/commands/gm3/CheckDmgCommand.java
View File

@@ -23,7 +23,7 @@
*/
package client.command.commands.gm3;
import client.MapleBuffStat;
import client.BuffStat;
import client.MapleCharacter;
import client.MapleClient;
import client.command.Command;
@@ -39,8 +39,8 @@ public class CheckDmgCommand extends Command {
MapleCharacter victim = c.getWorldServer().getPlayerStorage().getCharacterByName(params[0]);
if (victim != null) {
int maxBase = victim.calculateMaxBaseDamage(victim.getTotalWatk());
Integer watkBuff = victim.getBuffedValue(MapleBuffStat.WATK);
Integer matkBuff = victim.getBuffedValue(MapleBuffStat.MATK);
Integer watkBuff = victim.getBuffedValue(BuffStat.WATK);
Integer matkBuff = victim.getBuffedValue(BuffStat.MATK);
int blessing = victim.getSkillLevel(10000000 * player.getJobType() + 12);
if (watkBuff == null) watkBuff = 0;
if (matkBuff == null) matkBuff = 0;

6
src/main/java/client/inventory/manipulator/InventoryManipulator.java
View File

@@ -21,7 +21,7 @@
*/
package client.inventory.manipulator;
import client.MapleBuffStat;
import client.BuffStat;
import client.MapleCharacter;
import client.MapleClient;
import client.inventory.*;
@@ -620,8 +620,8 @@ public class InventoryManipulator {
target.setPosition(src);
eqpInv.addItemFromDB(target);
}
if (chr.getBuffedValue(MapleBuffStat.BOOSTER) != null && ItemConstants.isWeapon(source.getItemId())) {
chr.cancelBuffStats(MapleBuffStat.BOOSTER);
if (chr.getBuffedValue(BuffStat.BOOSTER) != null && ItemConstants.isWeapon(source.getItemId())) {
chr.cancelBuffStats(BuffStat.BOOSTER);
}
mods.add(new ModifyInventory(2, source, src));

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

@@ -248,12 +248,12 @@ public abstract class AbstractDealDamageHandler extends AbstractPacketHandler {
}
totDamage += totDamageToOneMonster;
monster.aggroMonsterDamage(player, totDamageToOneMonster);
if (player.getBuffedValue(MapleBuffStat.PICKPOCKET) != null && (attack.skill == 0 || attack.skill == Rogue.DOUBLE_STAB || attack.skill == Bandit.SAVAGE_BLOW || attack.skill == ChiefBandit.ASSAULTER || attack.skill == ChiefBandit.BAND_OF_THIEVES || attack.skill == Shadower.ASSASSINATE || attack.skill == Shadower.TAUNT || attack.skill == Shadower.BOOMERANG_STEP)) {
if (player.getBuffedValue(BuffStat.PICKPOCKET) != null && (attack.skill == 0 || attack.skill == Rogue.DOUBLE_STAB || attack.skill == Bandit.SAVAGE_BLOW || attack.skill == ChiefBandit.ASSAULTER || attack.skill == ChiefBandit.BAND_OF_THIEVES || attack.skill == Shadower.ASSASSINATE || attack.skill == Shadower.TAUNT || attack.skill == Shadower.BOOMERANG_STEP)) {
Skill pickpocket = SkillFactory.getSkill(ChiefBandit.PICKPOCKET);
int picklv = (player.isGM()) ? pickpocket.getMaxLevel() : player.getSkillLevel(pickpocket);
if(picklv > 0) {
int delay = 0;
final int maxmeso = player.getBuffedValue(MapleBuffStat.PICKPOCKET);
final int maxmeso = player.getBuffedValue(BuffStat.PICKPOCKET);
for (Integer eachd : onedList) {
eachd += Integer.MAX_VALUE;
@@ -312,7 +312,7 @@ public abstract class AbstractDealDamageHandler extends AbstractPacketHandler {
}
if (player.isAran()) {
if (player.getBuffedValue(MapleBuffStat.WK_CHARGE) != null) {
if (player.getBuffedValue(BuffStat.WK_CHARGE) != null) {
Skill snowCharge = SkillFactory.getSkill(Aran.SNOW_CHARGE);
if (totDamageToOneMonster > 0) {
MonsterStatusEffect monsterStatusEffect = new MonsterStatusEffect(Collections.singletonMap(MonsterStatus.SPEED, snowCharge.getEffect(player.getSkillLevel(snowCharge)).getX()), snowCharge, null, false);
@@ -320,21 +320,21 @@ public abstract class AbstractDealDamageHandler extends AbstractPacketHandler {
}
}
}
if (player.getBuffedValue(MapleBuffStat.HAMSTRING) != null) {
if (player.getBuffedValue(BuffStat.HAMSTRING) != null) {
Skill hamstring = SkillFactory.getSkill(Bowmaster.HAMSTRING);
if (hamstring.getEffect(player.getSkillLevel(hamstring)).makeChanceResult()) {
MonsterStatusEffect monsterStatusEffect = new MonsterStatusEffect(Collections.singletonMap(MonsterStatus.SPEED, hamstring.getEffect(player.getSkillLevel(hamstring)).getX()), hamstring, null, false);
monster.applyStatus(player, monsterStatusEffect, false, hamstring.getEffect(player.getSkillLevel(hamstring)).getY() * 1000);
}
}
if (player.getBuffedValue(MapleBuffStat.SLOW) != null) {
if (player.getBuffedValue(BuffStat.SLOW) != null) {
Skill slow = SkillFactory.getSkill(Evan.SLOW);
if (slow.getEffect(player.getSkillLevel(slow)).makeChanceResult()) {
MonsterStatusEffect monsterStatusEffect = new MonsterStatusEffect(Collections.singletonMap(MonsterStatus.SPEED, slow.getEffect(player.getSkillLevel(slow)).getX()), slow, null, false);
monster.applyStatus(player, monsterStatusEffect, false, slow.getEffect(player.getSkillLevel(slow)).getY() * 60 * 1000);
}
}
if (player.getBuffedValue(MapleBuffStat.BLIND) != null) {
if (player.getBuffedValue(BuffStat.BLIND) != null) {
Skill blind = SkillFactory.getSkill(Marksman.BLIND);
if (blind.getEffect(player.getSkillLevel(blind)).makeChanceResult()) {
MonsterStatusEffect monsterStatusEffect = new MonsterStatusEffect(Collections.singletonMap(MonsterStatus.ACC, blind.getEffect(player.getSkillLevel(blind)).getX()), blind, null, false);
@@ -344,7 +344,7 @@ public abstract class AbstractDealDamageHandler extends AbstractPacketHandler {
if (job == 121 || job == 122) {
for (int charge = 1211005; charge < 1211007; charge++) {
Skill chargeSkill = SkillFactory.getSkill(charge);
if (player.isBuffFrom(MapleBuffStat.WK_CHARGE, chargeSkill)) {
if (player.isBuffFrom(BuffStat.WK_CHARGE, chargeSkill)) {
if (totDamageToOneMonster > 0) {
if (charge == WhiteKnight.BW_ICE_CHARGE || charge == WhiteKnight.SWORD_ICE_CHARGE) {
monster.setTempEffectiveness(Element.ICE, ElementalEffectiveness.WEAK, chargeSkill.getEffect(player.getSkillLevel(chargeSkill)).getY() * 1000);
@@ -360,7 +360,7 @@ public abstract class AbstractDealDamageHandler extends AbstractPacketHandler {
if (job == 122) {
for (int charge = 1221003; charge < 1221004; charge++) {
Skill chargeSkill = SkillFactory.getSkill(charge);
if (player.isBuffFrom(MapleBuffStat.WK_CHARGE, chargeSkill)) {
if (player.isBuffFrom(BuffStat.WK_CHARGE, chargeSkill)) {
if (totDamageToOneMonster > 0) {
monster.setTempEffectiveness(Element.HOLY, ElementalEffectiveness.WEAK, chargeSkill.getEffect(player.getSkillLevel(chargeSkill)).getY() * 1000);
break;
@@ -368,9 +368,9 @@ public abstract class AbstractDealDamageHandler extends AbstractPacketHandler {
}
}
}
} else if (player.getBuffedValue(MapleBuffStat.COMBO_DRAIN) != null) {
} else if (player.getBuffedValue(BuffStat.COMBO_DRAIN) != null) {
Skill skill;
if (player.getBuffedValue(MapleBuffStat.COMBO_DRAIN) != null) {
if (player.getBuffedValue(BuffStat.COMBO_DRAIN) != null) {
skill = SkillFactory.getSkill(21100005);
player.addHP(((totDamage * skill.getEffect(player.getSkillLevel(skill)).getX()) / 100));
}
@@ -660,7 +660,7 @@ public abstract class AbstractDealDamageHandler extends AbstractPacketHandler {
}
}
Integer comboBuff = chr.getBuffedValue(MapleBuffStat.COMBO);
Integer comboBuff = chr.getBuffedValue(BuffStat.COMBO);
if(comboBuff != null && comboBuff > 0) {
int oid = chr.isCygnus() ? DawnWarrior.COMBO : Crusader.COMBO;
int advcomboid = chr.isCygnus() ? DawnWarrior.ADVANCED_COMBO : Hero.ADVANCED_COMBO;
@@ -720,7 +720,7 @@ public abstract class AbstractDealDamageHandler extends AbstractPacketHandler {
canCrit = true;
}
if(chr.getBuffEffect(MapleBuffStat.SHARP_EYES) != null) {
if(chr.getBuffEffect(BuffStat.SHARP_EYES) != null) {
// Any class that has sharp eyes can crit. Also, since it stacks with normal crit go ahead
// and calc it in.
@@ -729,7 +729,7 @@ public abstract class AbstractDealDamageHandler extends AbstractPacketHandler {
}
boolean shadowPartner = false;
if(chr.getBuffEffect(MapleBuffStat.SHADOWPARTNER) != null) {
if(chr.getBuffEffect(BuffStat.SHADOWPARTNER) != null) {
shadowPartner = true;
}
@@ -744,10 +744,10 @@ public abstract class AbstractDealDamageHandler extends AbstractPacketHandler {
List<Integer> allDamageNumbers = new ArrayList<>();
MapleMonster monster = chr.getMap().getMonsterByOid(oid);
if(chr.getBuffEffect(MapleBuffStat.WK_CHARGE) != null) {
if(chr.getBuffEffect(BuffStat.WK_CHARGE) != null) {
// Charge, so now we need to check elemental effectiveness
int sourceID = chr.getBuffSource(MapleBuffStat.WK_CHARGE);
int level = chr.getBuffedValue(MapleBuffStat.WK_CHARGE);
int sourceID = chr.getBuffSource(BuffStat.WK_CHARGE);
int level = chr.getBuffedValue(BuffStat.WK_CHARGE);
if(monster != null) {
if(sourceID == WhiteKnight.BW_FIRE_CHARGE || sourceID == WhiteKnight.SWORD_FIRE_CHARGE) {
if(monster.getStats().getEffectiveness(Element.FIRE) == ElementalEffectiveness.WEAK) {
@@ -775,7 +775,7 @@ public abstract class AbstractDealDamageHandler extends AbstractPacketHandler {
if(ret.skill != 0) {
Skill skill = SkillFactory.getSkill(ret.skill);
if(skill.getElement() != Element.NEUTRAL && chr.getBuffedValue(MapleBuffStat.ELEMENTAL_RESET) == null) {
if(skill.getElement() != Element.NEUTRAL && chr.getBuffedValue(BuffStat.ELEMENTAL_RESET) == null) {
// The skill has an element effect, so we need to factor that in.
if(monster != null) {
ElementalEffectiveness eff = monster.getElementalEffectiveness(skill.getElement());

28
src/main/java/net/server/channel/handlers/CloseRangeDamageHandler.java
View File

@@ -47,8 +47,8 @@ public final class CloseRangeDamageHandler extends AbstractDealDamageHandler {
chr.getAutobanManager().spam(8);*/
AttackInfo attack = parseDamage(p, chr, false, false);
if (chr.getBuffEffect(MapleBuffStat.MORPH) != null) {
if(chr.getBuffEffect(MapleBuffStat.MORPH).isMorphWithoutAttack()) {
if (chr.getBuffEffect(BuffStat.MORPH) != null) {
if(chr.getBuffEffect(BuffStat.MORPH).isMorphWithoutAttack()) {
// How are they attacking when the client won't let them?
chr.getClient().disconnect(false, false);
return;
@@ -64,7 +64,7 @@ public final class CloseRangeDamageHandler extends AbstractDealDamageHandler {
chr.getMap().broadcastMessage(chr, PacketCreator.closeRangeAttack(chr, attack.skill, attack.skilllevel, attack.stance, attack.numAttackedAndDamage, attack.allDamage, attack.speed, attack.direction, attack.display), false, true);
int numFinisherOrbs = 0;
Integer comboBuff = chr.getBuffedValue(MapleBuffStat.COMBO);
Integer comboBuff = chr.getBuffedValue(BuffStat.COMBO);
if (GameConstants.isFinisherSkill(attack.skill)) {
if (comboBuff != null) {
numFinisherOrbs = comboBuff - 1;
@@ -72,7 +72,7 @@ public final class CloseRangeDamageHandler extends AbstractDealDamageHandler {
chr.handleOrbconsume();
} else if (attack.numAttacked > 0) {
if (attack.skill != 1111008 && comboBuff != null) {
int orbcount = chr.getBuffedValue(MapleBuffStat.COMBO);
int orbcount = chr.getBuffedValue(BuffStat.COMBO);
int oid = chr.isCygnus() ? DawnWarrior.COMBO : Crusader.COMBO;
int advcomboid = chr.isCygnus() ? DawnWarrior.ADVANCED_COMBO : Hero.ADVANCED_COMBO;
Skill combo = SkillFactory.getSkill(oid);
@@ -101,9 +101,9 @@ public final class CloseRangeDamageHandler extends AbstractDealDamageHandler {
if(olv <= 0) olv = SkillFactory.getSkill(oid).getMaxLevel();
int duration = combo.getEffect(olv).getDuration();
List<Pair<MapleBuffStat, Integer>> stat = Collections.singletonList(new Pair<>(MapleBuffStat.COMBO, neworbcount));
chr.setBuffedValue(MapleBuffStat.COMBO, neworbcount);
duration -= (int) (currentServerTime() - chr.getBuffedStarttime(MapleBuffStat.COMBO));
List<Pair<BuffStat, Integer>> stat = Collections.singletonList(new Pair<>(BuffStat.COMBO, neworbcount));
chr.setBuffedValue(BuffStat.COMBO, neworbcount);
duration -= (int) (currentServerTime() - chr.getBuffedStarttime(BuffStat.COMBO));
c.sendPacket(PacketCreator.giveBuff(oid, duration, stat));
chr.getMap().broadcastMessage(chr, PacketCreator.giveForeignBuff(chr.getId(), stat), false);
}
@@ -130,7 +130,7 @@ public final class CloseRangeDamageHandler extends AbstractDealDamageHandler {
advcharge_prob = SkillFactory.getSkill(1220010).getEffect(advcharge_level).makeChanceResult();
}
if (!advcharge_prob) {
chr.cancelEffectFromBuffStat(MapleBuffStat.WK_CHARGE);
chr.cancelEffectFromBuffStat(BuffStat.WK_CHARGE);
}
}
int attackCount = 1;
@@ -160,12 +160,12 @@ public final class CloseRangeDamageHandler extends AbstractDealDamageHandler {
}
}
}
if ((chr.getSkillLevel(SkillFactory.getSkill(NightWalker.VANISH)) > 0 || chr.getSkillLevel(SkillFactory.getSkill(Rogue.DARK_SIGHT)) > 0) && chr.getBuffedValue(MapleBuffStat.DARKSIGHT) != null) {// && chr.getBuffSource(MapleBuffStat.DARKSIGHT) != 9101004
chr.cancelEffectFromBuffStat(MapleBuffStat.DARKSIGHT);
chr.cancelBuffStats(MapleBuffStat.DARKSIGHT);
} else if(chr.getSkillLevel(SkillFactory.getSkill(WindArcher.WIND_WALK)) > 0 && chr.getBuffedValue(MapleBuffStat.WIND_WALK) != null) {
chr.cancelEffectFromBuffStat(MapleBuffStat.WIND_WALK);
chr.cancelBuffStats(MapleBuffStat.WIND_WALK);
if ((chr.getSkillLevel(SkillFactory.getSkill(NightWalker.VANISH)) > 0 || chr.getSkillLevel(SkillFactory.getSkill(Rogue.DARK_SIGHT)) > 0) && chr.getBuffedValue(BuffStat.DARKSIGHT) != null) {// && chr.getBuffSource(BuffStat.DARKSIGHT) != 9101004
chr.cancelEffectFromBuffStat(BuffStat.DARKSIGHT);
chr.cancelBuffStats(BuffStat.DARKSIGHT);
} else if(chr.getSkillLevel(SkillFactory.getSkill(WindArcher.WIND_WALK)) > 0 && chr.getBuffedValue(BuffStat.WIND_WALK) != null) {
chr.cancelEffectFromBuffStat(BuffStat.WIND_WALK);
chr.cancelBuffStats(BuffStat.WIND_WALK);
}
applyAttack(attack, chr, attackCount);

4
src/main/java/net/server/channel/handlers/DamageSummonHandler.java
View File

@@ -21,7 +21,7 @@
*/
package net.server.channel.handlers;
import client.MapleBuffStat;
import client.BuffStat;
import client.MapleCharacter;
import client.MapleClient;
import net.AbstractPacketHandler;
@@ -46,7 +46,7 @@ public final class DamageSummonHandler extends AbstractPacketHandler {
summon.addHP(-damage);
if (summon.getHP() <= 0) {
player.cancelEffectFromBuffStat(MapleBuffStat.PUPPET);
player.cancelEffectFromBuffStat(BuffStat.PUPPET);
}
player.getMap().broadcastMessage(player, PacketCreator.damageSummon(player.getId(), oid, damage, monsterIdFrom), summon.getPosition());
}

4
src/main/java/net/server/channel/handlers/MagicDamageHandler.java
View File

@@ -46,8 +46,8 @@ public final class MagicDamageHandler extends AbstractDealDamageHandler {
AttackInfo attack = parseDamage(p, chr, false, true);
if (chr.getBuffEffect(MapleBuffStat.MORPH) != null) {
if(chr.getBuffEffect(MapleBuffStat.MORPH).isMorphWithoutAttack()) {
if (chr.getBuffEffect(BuffStat.MORPH) != null) {
if(chr.getBuffEffect(BuffStat.MORPH).isMorphWithoutAttack()) {
// How are they attacking when the client won't let them?
chr.getClient().disconnect(false, false);
return;

8
src/main/java/net/server/channel/handlers/PlayerMapTransitionHandler.java
View File

@@ -20,7 +20,7 @@
package net.server.channel.handlers;
import client.MapleBuffStat;
import client.BuffStat;
import client.MapleCharacter;
import client.MapleClient;
import net.AbstractPacketHandler;
@@ -44,11 +44,11 @@ public final class PlayerMapTransitionHandler extends AbstractPacketHandler {
MapleCharacter chr = c.getPlayer();
chr.setMapTransitionComplete();
int beaconid = chr.getBuffSource(MapleBuffStat.HOMING_BEACON);
int beaconid = chr.getBuffSource(BuffStat.HOMING_BEACON);
if (beaconid != -1) {
chr.cancelBuffStats(MapleBuffStat.HOMING_BEACON);
chr.cancelBuffStats(BuffStat.HOMING_BEACON);
final List<Pair<MapleBuffStat, Integer>> stat = Collections.singletonList(new Pair<>(MapleBuffStat.HOMING_BEACON, 0));
final List<Pair<BuffStat, Integer>> stat = Collections.singletonList(new Pair<>(BuffStat.HOMING_BEACON, 0));
chr.sendPacket(PacketCreator.giveBuff(1, beaconid, stat));
}

22
src/main/java/net/server/channel/handlers/RangedAttackHandler.java
View File

@@ -53,8 +53,8 @@ public final class RangedAttackHandler extends AbstractDealDamageHandler {
AttackInfo attack = parseDamage(p, chr, true, false);
if (chr.getBuffEffect(MapleBuffStat.MORPH) != null) {
if(chr.getBuffEffect(MapleBuffStat.MORPH).isMorphWithoutAttack()) {
if (chr.getBuffEffect(BuffStat.MORPH) != null) {
if(chr.getBuffEffect(BuffStat.MORPH).isMorphWithoutAttack()) {
// How are they attacking when the client won't let them?
chr.getClient().disconnect(false, false);
return;
@@ -119,7 +119,7 @@ public final class RangedAttackHandler extends AbstractDealDamageHandler {
}
}
}
boolean hasShadowPartner = chr.getBuffedValue(MapleBuffStat.SHADOWPARTNER) != null;
boolean hasShadowPartner = chr.getBuffedValue(BuffStat.SHADOWPARTNER) != null;
if (hasShadowPartner) {
bulletCount *= 2;
}
@@ -156,8 +156,8 @@ public final class RangedAttackHandler extends AbstractDealDamageHandler {
}
}
}
boolean soulArrow = chr.getBuffedValue(MapleBuffStat.SOULARROW) != null;
boolean shadowClaw = chr.getBuffedValue(MapleBuffStat.SHADOW_CLAW) != null;
boolean soulArrow = chr.getBuffedValue(BuffStat.SOULARROW) != null;
boolean shadowClaw = chr.getBuffedValue(BuffStat.SHADOW_CLAW) != null;
if (projectile != 0) {
if (!soulArrow && !shadowClaw && attack.skill != 11101004 && attack.skill != 15111007 && attack.skill != 14101006) {
short bulletConsume = bulletCount;
@@ -215,12 +215,12 @@ public final class RangedAttackHandler extends AbstractDealDamageHandler {
}
}
if (chr.getSkillLevel(SkillFactory.getSkill(NightWalker.VANISH)) > 0 && chr.getBuffedValue(MapleBuffStat.DARKSIGHT) != null && attack.numAttacked > 0 && chr.getBuffSource(MapleBuffStat.DARKSIGHT) != 9101004) {
chr.cancelEffectFromBuffStat(MapleBuffStat.DARKSIGHT);
chr.cancelBuffStats(MapleBuffStat.DARKSIGHT);
} else if(chr.getSkillLevel(SkillFactory.getSkill(WindArcher.WIND_WALK)) > 0 && chr.getBuffedValue(MapleBuffStat.WIND_WALK) != null && attack.numAttacked > 0) {
chr.cancelEffectFromBuffStat(MapleBuffStat.WIND_WALK);
chr.cancelBuffStats(MapleBuffStat.WIND_WALK);
if (chr.getSkillLevel(SkillFactory.getSkill(NightWalker.VANISH)) > 0 && chr.getBuffedValue(BuffStat.DARKSIGHT) != null && attack.numAttacked > 0 && chr.getBuffSource(BuffStat.DARKSIGHT) != 9101004) {
chr.cancelEffectFromBuffStat(BuffStat.DARKSIGHT);
chr.cancelBuffStats(BuffStat.DARKSIGHT);
} else if(chr.getSkillLevel(SkillFactory.getSkill(WindArcher.WIND_WALK)) > 0 && chr.getBuffedValue(BuffStat.WIND_WALK) != null && attack.numAttacked > 0) {
chr.cancelEffectFromBuffStat(BuffStat.WIND_WALK);
chr.cancelBuffStats(BuffStat.WIND_WALK);
}
applyAttack(attack, chr, bulletCount);

22
src/main/java/net/server/channel/handlers/TakeDamageHandler.java
View File

@@ -87,7 +87,7 @@ public final class TakeDamageHandler extends AbstractPacketHandler {
if (damage > 0) {
loseItems = attacker.getStats().loseItem();
if (loseItems != null) {
if (chr.getBuffEffect(MapleBuffStat.AURA) == null) {
if (chr.getBuffEffect(BuffStat.AURA) == null) {
InventoryType type;
final int playerpos = chr.getPosition().x;
byte d = 1;
@@ -157,12 +157,12 @@ public final class TakeDamageHandler extends AbstractPacketHandler {
}
attacker.setMp(attacker.getMp() - attackInfo.getMpCon());
if (chr.getBuffedValue(MapleBuffStat.MANA_REFLECTION) != null && damage > 0 && !attacker.isBoss()) {
if (chr.getBuffedValue(BuffStat.MANA_REFLECTION) != null && damage > 0 && !attacker.isBoss()) {
int jobid = chr.getJob().getId();
if (jobid == 212 || jobid == 222 || jobid == 232) {
int id = jobid * 10000 + 1002;
Skill manaReflectSkill = SkillFactory.getSkill(id);
if (chr.isBuffFrom(MapleBuffStat.MANA_REFLECTION, manaReflectSkill) && chr.getSkillLevel(manaReflectSkill) > 0 && manaReflectSkill.getEffect(chr.getSkillLevel(manaReflectSkill)).makeChanceResult()) {
if (chr.isBuffFrom(BuffStat.MANA_REFLECTION, manaReflectSkill) && chr.getSkillLevel(manaReflectSkill) > 0 && manaReflectSkill.getEffect(chr.getSkillLevel(manaReflectSkill)).makeChanceResult()) {
int bouncedamage = (damage * manaReflectSkill.getEffect(chr.getSkillLevel(manaReflectSkill)).getX() / 100);
if (bouncedamage > attacker.getMaxHp() / 5) {
bouncedamage = attacker.getMaxHp() / 5;
@@ -196,15 +196,15 @@ public final class TakeDamageHandler extends AbstractPacketHandler {
if (damage > 0 && !chr.isHidden()) {
if (attacker != null) {
if (damagefrom == -1) {
if (chr.getBuffedValue(MapleBuffStat.POWERGUARD) != null) { // PG works on bosses, but only at half of the rate.
int bouncedamage = (int) (damage * (chr.getBuffedValue(MapleBuffStat.POWERGUARD).doubleValue() / (attacker.isBoss() ? 200 : 100)));
if (chr.getBuffedValue(BuffStat.POWERGUARD) != null) { // PG works on bosses, but only at half of the rate.
int bouncedamage = (int) (damage * (chr.getBuffedValue(BuffStat.POWERGUARD).doubleValue() / (attacker.isBoss() ? 200 : 100)));
bouncedamage = Math.min(bouncedamage, attacker.getMaxHp() / 10);
damage -= bouncedamage;
map.damageMonster(chr, attacker, bouncedamage);
map.broadcastMessage(chr, PacketCreator.damageMonster(oid, bouncedamage), false, true);
attacker.aggroMonsterDamage(chr, bouncedamage);
}
MapleStatEffect bPressure = chr.getBuffEffect(MapleBuffStat.BODY_PRESSURE); // thanks Atoot for noticing an issue on Body Pressure neutralise
MapleStatEffect 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)) {
@@ -215,7 +215,7 @@ public final class TakeDamageHandler extends AbstractPacketHandler {
}
}
MapleStatEffect cBarrier = chr.getBuffEffect(MapleBuffStat.COMBO_BARRIER); // thanks BHB for noticing Combo Barrier buff not working
MapleStatEffect cBarrier = chr.getBuffEffect(BuffStat.COMBO_BARRIER); // thanks BHB for noticing Combo Barrier buff not working
if (cBarrier != null) {
damage *= (cBarrier.getX() / 1000.0);
}
@@ -238,9 +238,9 @@ public final class TakeDamageHandler extends AbstractPacketHandler {
damage *= Math.ceil(highDef.getEffect(hdLevel).getX() / 1000.0);
}
}
Integer mesoguard = chr.getBuffedValue(MapleBuffStat.MESOGUARD);
if (chr.getBuffedValue(MapleBuffStat.MAGIC_GUARD) != null && mpattack == 0) {
int mploss = (int) (damage * (chr.getBuffedValue(MapleBuffStat.MAGIC_GUARD).doubleValue() / 100.0));
Integer mesoguard = chr.getBuffedValue(BuffStat.MESOGUARD);
if (chr.getBuffedValue(BuffStat.MAGIC_GUARD) != null && mpattack == 0) {
int mploss = (int) (damage * (chr.getBuffedValue(BuffStat.MAGIC_GUARD).doubleValue() / 100.0));
int hploss = damage - mploss;
int curmp = chr.getMp();
@@ -255,7 +255,7 @@ public final class TakeDamageHandler extends AbstractPacketHandler {
int mesoloss = (int) (damage * (mesoguard.doubleValue() / 100.0));
if (chr.getMeso() < mesoloss) {
chr.gainMeso(-chr.getMeso(), false);
chr.cancelBuffStats(MapleBuffStat.MESOGUARD);
chr.cancelBuffStats(BuffStat.MESOGUARD);
} else {
chr.gainMeso(-mesoloss, false);
}

6
src/main/java/net/server/channel/handlers/TouchMonsterDamageHandler.java
View File

@@ -21,16 +21,16 @@
*/
package net.server.channel.handlers;
import client.MapleBuffStat;
import client.MapleClient;
import client.BuffStat;
import client.MapleCharacter;
import client.MapleClient;
import net.packet.InPacket;
public final class TouchMonsterDamageHandler extends AbstractDealDamageHandler {
@Override
public final void handlePacket(InPacket p, MapleClient c) {
MapleCharacter chr = c.getPlayer();
if (chr.getEnergyBar() == 15000 || chr.getBuffedValue(MapleBuffStat.BODY_PRESSURE) != null) {
if (chr.getEnergyBar() == 15000 || chr.getBuffedValue(BuffStat.BODY_PRESSURE) != null) {
applyAttack(parseDamage(p, chr, false, false), c.getPlayer(), 1);
}
}

220
src/main/java/server/MapleStatEffect.java
View File

@@ -71,7 +71,7 @@ public class MapleStatEffect {
private int cp, nuffSkill;
private List<MapleDisease> cureDebuffs;
private boolean skill;
private List<Pair<MapleBuffStat, Integer>> statups;
private List<Pair<BuffStat, Integer>> statups;
private Map<MonsterStatus, Integer> monsterStatus;
private int x, y, mobCount, moneyCon, cooldown, morphId = 0, ghost, fatigue, berserk, booster;
private double prop;
@@ -153,7 +153,7 @@ public class MapleStatEffect {
return loadFromData(source, itemid, false, false);
}
private static void addBuffStatPairToListIfNotZero(List<Pair<MapleBuffStat, Integer>> list, MapleBuffStat buffstat, Integer val) {
private static void addBuffStatPairToListIfNotZero(List<Pair<BuffStat, Integer>> list, BuffStat buffstat, Integer val) {
if (val != 0) {
list.add(new Pair<>(buffstat, val));
}
@@ -235,7 +235,7 @@ public class MapleStatEffect {
ret.overTime = overTime;
}
ArrayList<Pair<MapleBuffStat, Integer>> statups = new ArrayList<>();
ArrayList<Pair<BuffStat, Integer>> statups = new ArrayList<>();
ret.watk = (short) MapleDataTool.getInt("pad", source, 0);
ret.wdef = (short) MapleDataTool.getInt("pdd", source, 0);
ret.matk = (short) MapleDataTool.getInt("mad", source, 0);
@@ -247,10 +247,10 @@ public class MapleStatEffect {
ret.jump = (short) MapleDataTool.getInt("jump", source, 0);
ret.barrier = MapleDataTool.getInt("barrier", source, 0);
addBuffStatPairToListIfNotZero(statups, MapleBuffStat.AURA, ret.barrier);
addBuffStatPairToListIfNotZero(statups, BuffStat.AURA, ret.barrier);
ret.mapProtection = mapProtection(sourceid);
addBuffStatPairToListIfNotZero(statups, MapleBuffStat.MAP_PROTECTION, (int) ret.mapProtection);
addBuffStatPairToListIfNotZero(statups, BuffStat.MAP_PROTECTION, (int) ret.mapProtection);
if (ret.overTime && ret.getSummonMovementType() == null) {
if (!skill) {
@@ -258,8 +258,8 @@ public class MapleStatEffect {
ret.berserk = MapleDataTool.getInt("berserk", source, 0);
ret.booster = MapleDataTool.getInt("booster", source, 0);
addBuffStatPairToListIfNotZero(statups, MapleBuffStat.BERSERK, ret.berserk);
addBuffStatPairToListIfNotZero(statups, MapleBuffStat.BOOSTER, ret.booster);
addBuffStatPairToListIfNotZero(statups, BuffStat.BERSERK, ret.berserk);
addBuffStatPairToListIfNotZero(statups, BuffStat.BOOSTER, ret.booster);
} else if (isDojoBuff(sourceid) || isHpMpRecovery(sourceid)) {
ret.mhpR = (byte) MapleDataTool.getInt("mhpR", source, 0);
@@ -267,39 +267,39 @@ public class MapleStatEffect {
ret.mmpR = (byte) MapleDataTool.getInt("mmpR", source, 0);
ret.mmpRRate = (short) (MapleDataTool.getInt("mmpRRate", source, 0) * 100);
addBuffStatPairToListIfNotZero(statups, MapleBuffStat.HPREC, (int) ret.mhpR);
addBuffStatPairToListIfNotZero(statups, MapleBuffStat.MPREC, (int) ret.mmpR);
addBuffStatPairToListIfNotZero(statups, BuffStat.HPREC, (int) ret.mhpR);
addBuffStatPairToListIfNotZero(statups, BuffStat.MPREC, (int) ret.mmpR);
} else if (isRateCoupon(sourceid)) {
switch (MapleDataTool.getInt("expR", source, 0)) {
case 1:
addBuffStatPairToListIfNotZero(statups, MapleBuffStat.COUPON_EXP1, 1);
addBuffStatPairToListIfNotZero(statups, BuffStat.COUPON_EXP1, 1);
break;
case 2:
addBuffStatPairToListIfNotZero(statups, MapleBuffStat.COUPON_EXP2, 1);
addBuffStatPairToListIfNotZero(statups, BuffStat.COUPON_EXP2, 1);
break;
case 3:
addBuffStatPairToListIfNotZero(statups, MapleBuffStat.COUPON_EXP3, 1);
addBuffStatPairToListIfNotZero(statups, BuffStat.COUPON_EXP3, 1);
break;
case 4:
addBuffStatPairToListIfNotZero(statups, MapleBuffStat.COUPON_EXP4, 1);
addBuffStatPairToListIfNotZero(statups, BuffStat.COUPON_EXP4, 1);
break;
}
switch (MapleDataTool.getInt("drpR", source, 0)) {
case 1:
addBuffStatPairToListIfNotZero(statups, MapleBuffStat.COUPON_DRP1, 1);
addBuffStatPairToListIfNotZero(statups, BuffStat.COUPON_DRP1, 1);
break;
case 2:
addBuffStatPairToListIfNotZero(statups, MapleBuffStat.COUPON_DRP2, 1);
addBuffStatPairToListIfNotZero(statups, BuffStat.COUPON_DRP2, 1);
break;
case 3:
addBuffStatPairToListIfNotZero(statups, MapleBuffStat.COUPON_DRP3, 1);
addBuffStatPairToListIfNotZero(statups, BuffStat.COUPON_DRP3, 1);
break;
}
} else if (isMonsterCard(sourceid)) {
@@ -330,13 +330,13 @@ public class MapleStatEffect {
}
if (MapleDataTool.getInt("mesoupbyitem", source, 0) != 0) {
addBuffStatPairToListIfNotZero(statups, MapleBuffStat.MESO_UP_BY_ITEM, 4);
addBuffStatPairToListIfNotZero(statups, BuffStat.MESO_UP_BY_ITEM, 4);
prob = MapleDataTool.getInt("prob", source, 1);
}
int itemupType = MapleDataTool.getInt("itemupbyitem", source, 0);
if (itemupType != 0) {
addBuffStatPairToListIfNotZero(statups, MapleBuffStat.ITEM_UP_BY_ITEM, 4);
addBuffStatPairToListIfNotZero(statups, BuffStat.ITEM_UP_BY_ITEM, 4);
prob = MapleDataTool.getInt("prob", source, 1);
switch (itemupType) {
@@ -351,47 +351,47 @@ public class MapleStatEffect {
}
if (MapleDataTool.getInt("respectPimmune", source, 0) != 0) {
addBuffStatPairToListIfNotZero(statups, MapleBuffStat.RESPECT_PIMMUNE, 4);
addBuffStatPairToListIfNotZero(statups, BuffStat.RESPECT_PIMMUNE, 4);
}
if (MapleDataTool.getInt("respectMimmune", source, 0) != 0) {
addBuffStatPairToListIfNotZero(statups, MapleBuffStat.RESPECT_MIMMUNE, 4);
addBuffStatPairToListIfNotZero(statups, BuffStat.RESPECT_MIMMUNE, 4);
}
if (MapleDataTool.getString("defenseAtt", source, null) != null) {
addBuffStatPairToListIfNotZero(statups, MapleBuffStat.DEFENSE_ATT, 4);
addBuffStatPairToListIfNotZero(statups, BuffStat.DEFENSE_ATT, 4);
}
if (MapleDataTool.getString("defenseState", source, null) != null) {
addBuffStatPairToListIfNotZero(statups, MapleBuffStat.DEFENSE_STATE, 4);
addBuffStatPairToListIfNotZero(statups, BuffStat.DEFENSE_STATE, 4);
}
int thaw = MapleDataTool.getInt("thaw", source, 0);
if (thaw != 0) {
addBuffStatPairToListIfNotZero(statups, MapleBuffStat.MAP_PROTECTION, thaw > 0 ? 1 : 2);
addBuffStatPairToListIfNotZero(statups, BuffStat.MAP_PROTECTION, thaw > 0 ? 1 : 2);
}
ret.cardStats = new CardItemupStats(itemupCode, prob, areas, inParty);
} else if (isExpIncrease(sourceid)) {
addBuffStatPairToListIfNotZero(statups, MapleBuffStat.EXP_INCREASE, MapleDataTool.getInt("expinc", source, 0));
addBuffStatPairToListIfNotZero(statups, BuffStat.EXP_INCREASE, MapleDataTool.getInt("expinc", source, 0));
}
} else {
if (isMapChair(sourceid)) {
addBuffStatPairToListIfNotZero(statups, MapleBuffStat.MAP_CHAIR, 1);
addBuffStatPairToListIfNotZero(statups, BuffStat.MAP_CHAIR, 1);
} else if ((sourceid == Beginner.NIMBLE_FEET || sourceid == Noblesse.NIMBLE_FEET || sourceid == Evan.NIMBLE_FEET || sourceid == Legend.AGILE_BODY) && YamlConfig.config.server.USE_ULTRA_NIMBLE_FEET == true) {
ret.jump = (short) (ret.speed * 4);
ret.speed *= 15;
}
}
addBuffStatPairToListIfNotZero(statups, MapleBuffStat.WATK, (int) ret.watk);
addBuffStatPairToListIfNotZero(statups, MapleBuffStat.WDEF, (int) ret.wdef);
addBuffStatPairToListIfNotZero(statups, MapleBuffStat.MATK, (int) ret.matk);
addBuffStatPairToListIfNotZero(statups, MapleBuffStat.MDEF, (int) ret.mdef);
addBuffStatPairToListIfNotZero(statups, MapleBuffStat.ACC, (int) ret.acc);
addBuffStatPairToListIfNotZero(statups, MapleBuffStat.AVOID, (int) ret.avoid);
addBuffStatPairToListIfNotZero(statups, MapleBuffStat.SPEED, (int) ret.speed);
addBuffStatPairToListIfNotZero(statups, MapleBuffStat.JUMP, (int) ret.jump);
addBuffStatPairToListIfNotZero(statups, BuffStat.WATK, (int) ret.watk);
addBuffStatPairToListIfNotZero(statups, BuffStat.WDEF, (int) ret.wdef);
addBuffStatPairToListIfNotZero(statups, BuffStat.MATK, (int) ret.matk);
addBuffStatPairToListIfNotZero(statups, BuffStat.MDEF, (int) ret.mdef);
addBuffStatPairToListIfNotZero(statups, BuffStat.ACC, (int) ret.acc);
addBuffStatPairToListIfNotZero(statups, BuffStat.AVOID, (int) ret.avoid);
addBuffStatPairToListIfNotZero(statups, BuffStat.SPEED, (int) ret.speed);
addBuffStatPairToListIfNotZero(statups, BuffStat.JUMP, (int) ret.jump);
}
MapleData ltd = source.getChildByPath("lt");
@@ -430,13 +430,13 @@ public class MapleStatEffect {
case Noblesse.RECOVERY:
case Legend.RECOVERY:
case Evan.RECOVERY:
statups.add(new Pair<>(MapleBuffStat.RECOVERY, x));
statups.add(new Pair<>(BuffStat.RECOVERY, x));
break;
case Beginner.ECHO_OF_HERO:
case Noblesse.ECHO_OF_HERO:
case Legend.ECHO_OF_HERO:
case Evan.ECHO_OF_HERO:
statups.add(new Pair<>(MapleBuffStat.ECHO_OF_HERO, ret.x));
statups.add(new Pair<>(BuffStat.ECHO_OF_HERO, ret.x));
break;
case Beginner.MONSTER_RIDER:
case Noblesse.MONSTER_RIDER:
@@ -456,27 +456,27 @@ public class MapleStatEffect {
case Beginner.BALROG_MOUNT:
case Noblesse.BALROG_MOUNT:
case Legend.BALROG_MOUNT:
statups.add(new Pair<>(MapleBuffStat.MONSTER_RIDING, sourceid));
statups.add(new Pair<>(BuffStat.MONSTER_RIDING, sourceid));
break;
case Beginner.INVINCIBLE_BARRIER:
case Noblesse.INVINCIBLE_BARRIER:
case Legend.INVICIBLE_BARRIER:
case Evan.INVINCIBLE_BARRIER:
statups.add(new Pair<>(MapleBuffStat.DIVINE_BODY, 1));
statups.add(new Pair<>(BuffStat.DIVINE_BODY, 1));
break;
case Fighter.POWER_GUARD:
case Page.POWER_GUARD:
statups.add(new Pair<>(MapleBuffStat.POWERGUARD, x));
statups.add(new Pair<>(BuffStat.POWERGUARD, x));
break;
case Spearman.HYPER_BODY:
case GM.HYPER_BODY:
case SuperGM.HYPER_BODY:
statups.add(new Pair<>(MapleBuffStat.HYPERBODYHP, x));
statups.add(new Pair<>(MapleBuffStat.HYPERBODYMP, ret.y));
statups.add(new Pair<>(BuffStat.HYPERBODYHP, x));
statups.add(new Pair<>(BuffStat.HYPERBODYMP, ret.y));
break;
case Crusader.COMBO:
case DawnWarrior.COMBO:
statups.add(new Pair<>(MapleBuffStat.COMBO, 1));
statups.add(new Pair<>(BuffStat.COMBO, 1));
break;
case WhiteKnight.BW_FIRE_CHARGE:
case WhiteKnight.BW_ICE_CHARGE:
@@ -488,130 +488,130 @@ public class MapleStatEffect {
case Paladin.SWORD_HOLY_CHARGE:
case DawnWarrior.SOUL_CHARGE:
case ThunderBreaker.LIGHTNING_CHARGE:
statups.add(new Pair<>(MapleBuffStat.WK_CHARGE, x));
statups.add(new Pair<>(BuffStat.WK_CHARGE, x));
break;
case DragonKnight.DRAGON_BLOOD:
statups.add(new Pair<>(MapleBuffStat.DRAGONBLOOD, ret.x));
statups.add(new Pair<>(BuffStat.DRAGONBLOOD, ret.x));
break;
case Hero.STANCE:
case Paladin.STANCE:
case DarkKnight.STANCE:
case Aran.FREEZE_STANDING:
statups.add(new Pair<>(MapleBuffStat.STANCE, iprop));
statups.add(new Pair<>(BuffStat.STANCE, iprop));
break;
case DawnWarrior.FINAL_ATTACK:
case WindArcher.FINAL_ATTACK:
statups.add(new Pair<>(MapleBuffStat.FINALATTACK, x));
statups.add(new Pair<>(BuffStat.FINALATTACK, x));
break;
// MAGICIAN
case Magician.MAGIC_GUARD:
case BlazeWizard.MAGIC_GUARD:
case Evan.MAGIC_GUARD:
statups.add(new Pair<>(MapleBuffStat.MAGIC_GUARD, x));
statups.add(new Pair<>(BuffStat.MAGIC_GUARD, x));
break;
case Cleric.INVINCIBLE:
statups.add(new Pair<>(MapleBuffStat.INVINCIBLE, x));
statups.add(new Pair<>(BuffStat.INVINCIBLE, x));
break;
case Priest.HOLY_SYMBOL:
case SuperGM.HOLY_SYMBOL:
statups.add(new Pair<>(MapleBuffStat.HOLY_SYMBOL, x));
statups.add(new Pair<>(BuffStat.HOLY_SYMBOL, x));
break;
case FPArchMage.INFINITY:
case ILArchMage.INFINITY:
case Bishop.INFINITY:
statups.add(new Pair<>(MapleBuffStat.INFINITY, x));
statups.add(new Pair<>(BuffStat.INFINITY, x));
break;
case FPArchMage.MANA_REFLECTION:
case ILArchMage.MANA_REFLECTION:
case Bishop.MANA_REFLECTION:
statups.add(new Pair<>(MapleBuffStat.MANA_REFLECTION, 1));
statups.add(new Pair<>(BuffStat.MANA_REFLECTION, 1));
break;
case Bishop.HOLY_SHIELD:
statups.add(new Pair<>(MapleBuffStat.HOLY_SHIELD, x));
statups.add(new Pair<>(BuffStat.HOLY_SHIELD, x));
break;
case BlazeWizard.ELEMENTAL_RESET:
case Evan.ELEMENTAL_RESET:
statups.add(new Pair<>(MapleBuffStat.ELEMENTAL_RESET, x));
statups.add(new Pair<>(BuffStat.ELEMENTAL_RESET, x));
break;
case Evan.MAGIC_SHIELD:
statups.add(new Pair<>(MapleBuffStat.MAGIC_SHIELD, x));
statups.add(new Pair<>(BuffStat.MAGIC_SHIELD, x));
break;
case Evan.MAGIC_RESISTANCE:
statups.add(new Pair<>(MapleBuffStat.MAGIC_RESISTANCE, x));
statups.add(new Pair<>(BuffStat.MAGIC_RESISTANCE, x));
break;
case Evan.SLOW:
statups.add(new Pair<>(MapleBuffStat.SLOW, x));
statups.add(new Pair<>(BuffStat.SLOW, x));
// BOWMAN
case Priest.MYSTIC_DOOR:
case Hunter.SOUL_ARROW:
case Crossbowman.SOUL_ARROW:
case WindArcher.SOUL_ARROW:
statups.add(new Pair<>(MapleBuffStat.SOULARROW, x));
statups.add(new Pair<>(BuffStat.SOULARROW, x));
break;
case Ranger.PUPPET:
case Sniper.PUPPET:
case WindArcher.PUPPET:
case Outlaw.OCTOPUS:
case Corsair.WRATH_OF_THE_OCTOPI:
statups.add(new Pair<>(MapleBuffStat.PUPPET, 1));
statups.add(new Pair<>(BuffStat.PUPPET, 1));
break;
case Bowmaster.CONCENTRATE:
statups.add(new Pair<>(MapleBuffStat.CONCENTRATE, x));
statups.add(new Pair<>(BuffStat.CONCENTRATE, x));
break;
case Bowmaster.HAMSTRING:
statups.add(new Pair<>(MapleBuffStat.HAMSTRING, x));
statups.add(new Pair<>(BuffStat.HAMSTRING, x));
monsterStatus.put(MonsterStatus.SPEED, x);
break;
case Marksman.BLIND:
statups.add(new Pair<>(MapleBuffStat.BLIND, x));
statups.add(new Pair<>(BuffStat.BLIND, x));
monsterStatus.put(MonsterStatus.ACC, x);
break;
case Bowmaster.SHARP_EYES:
case Marksman.SHARP_EYES:
statups.add(new Pair<>(MapleBuffStat.SHARP_EYES, ret.x << 8 | ret.y));
statups.add(new Pair<>(BuffStat.SHARP_EYES, ret.x << 8 | ret.y));
break;
case WindArcher.WIND_WALK:
statups.add(new Pair<>(MapleBuffStat.WIND_WALK, x));
statups.add(new Pair<>(BuffStat.WIND_WALK, x));
//break; thanks Vcoc for noticing WW not showing for other players when changing maps
case Rogue.DARK_SIGHT:
case NightWalker.DARK_SIGHT:
statups.add(new Pair<>(MapleBuffStat.DARKSIGHT, x));
statups.add(new Pair<>(BuffStat.DARKSIGHT, x));
break;
case Hermit.MESO_UP:
statups.add(new Pair<>(MapleBuffStat.MESOUP, x));
statups.add(new Pair<>(BuffStat.MESOUP, x));
break;
case Hermit.SHADOW_PARTNER:
case NightWalker.SHADOW_PARTNER:
statups.add(new Pair<>(MapleBuffStat.SHADOWPARTNER, x));
statups.add(new Pair<>(BuffStat.SHADOWPARTNER, x));
break;
case ChiefBandit.MESO_GUARD:
statups.add(new Pair<>(MapleBuffStat.MESOGUARD, x));
statups.add(new Pair<>(BuffStat.MESOGUARD, x));
break;
case ChiefBandit.PICKPOCKET:
statups.add(new Pair<>(MapleBuffStat.PICKPOCKET, x));
statups.add(new Pair<>(BuffStat.PICKPOCKET, x));
break;
case NightLord.SHADOW_STARS:
statups.add(new Pair<>(MapleBuffStat.SHADOW_CLAW, 0));
statups.add(new Pair<>(BuffStat.SHADOW_CLAW, 0));
break;
// PIRATE
case Pirate.DASH:
case ThunderBreaker.DASH:
case Beginner.SPACE_DASH:
case Noblesse.SPACE_DASH:
statups.add(new Pair<>(MapleBuffStat.DASH2, ret.x));
statups.add(new Pair<>(MapleBuffStat.DASH, ret.y));
statups.add(new Pair<>(BuffStat.DASH2, ret.x));
statups.add(new Pair<>(BuffStat.DASH, ret.y));
break;
case Corsair.SPEED_INFUSION:
case Buccaneer.SPEED_INFUSION:
case ThunderBreaker.SPEED_INFUSION:
statups.add(new Pair<>(MapleBuffStat.SPEED_INFUSION, x));
statups.add(new Pair<>(BuffStat.SPEED_INFUSION, x));
break;
case Outlaw.HOMING_BEACON:
case Corsair.BULLSEYE:
statups.add(new Pair<>(MapleBuffStat.HOMING_BEACON, x));
statups.add(new Pair<>(BuffStat.HOMING_BEACON, x));
break;
case ThunderBreaker.SPARK:
statups.add(new Pair<>(MapleBuffStat.SPARK, x));
statups.add(new Pair<>(BuffStat.SPARK, x));
break;
// MULTIPLE
case Aran.POLEARM_BOOSTER:
@@ -638,7 +638,7 @@ public class MapleStatEffect {
case Beginner.POWER_EXPLOSION:
case Noblesse.POWER_EXPLOSION:
case Legend.POWER_EXPLOSION:
statups.add(new Pair<>(MapleBuffStat.BOOSTER, x));
statups.add(new Pair<>(BuffStat.BOOSTER, x));
break;
case Hero.MAPLE_WARRIOR:
case Paladin.MAPLE_WARRIOR:
@@ -654,17 +654,17 @@ public class MapleStatEffect {
case Buccaneer.MAPLE_WARRIOR:
case Aran.MAPLE_WARRIOR:
case Evan.MAPLE_WARRIOR:
statups.add(new Pair<>(MapleBuffStat.MAPLE_WARRIOR, ret.x));
statups.add(new Pair<>(BuffStat.MAPLE_WARRIOR, ret.x));
break;
// SUMMON
case Ranger.SILVER_HAWK:
case Sniper.GOLDEN_EAGLE:
statups.add(new Pair<>(MapleBuffStat.SUMMON, 1));
statups.add(new Pair<>(BuffStat.SUMMON, 1));
monsterStatus.put(MonsterStatus.STUN, 1);
break;
case FPArchMage.ELQUINES:
case Marksman.FROST_PREY:
statups.add(new Pair<>(MapleBuffStat.SUMMON, 1));
statups.add(new Pair<>(BuffStat.SUMMON, 1));
monsterStatus.put(MonsterStatus.FREEZE, 1);
break;
case Priest.SUMMON_DRAGON:
@@ -679,7 +679,7 @@ public class MapleStatEffect {
case NightWalker.DARKNESS:
case ThunderBreaker.LIGHTNING:
case BlazeWizard.IFRIT:
statups.add(new Pair<>(MapleBuffStat.SUMMON, 1));
statups.add(new Pair<>(BuffStat.SUMMON, 1));
break;
// ----------------------------- MONSTER STATUS ---------------------------------- //
case Crusader.ARMOR_CRASH:
@@ -774,32 +774,32 @@ public class MapleStatEffect {
monsterStatus.put(MonsterStatus.PHANTOM_IMPRINT, x);
//ARAN
case Aran.COMBO_ABILITY:
statups.add(new Pair<>(MapleBuffStat.ARAN_COMBO, 100));
statups.add(new Pair<>(BuffStat.ARAN_COMBO, 100));
break;
case Aran.COMBO_BARRIER:
statups.add(new Pair<>(MapleBuffStat.COMBO_BARRIER, ret.x));
statups.add(new Pair<>(BuffStat.COMBO_BARRIER, ret.x));
break;
case Aran.COMBO_DRAIN:
statups.add(new Pair<>(MapleBuffStat.COMBO_DRAIN, ret.x));
statups.add(new Pair<>(BuffStat.COMBO_DRAIN, ret.x));
break;
case Aran.SMART_KNOCKBACK:
statups.add(new Pair<>(MapleBuffStat.SMART_KNOCKBACK, ret.x));
statups.add(new Pair<>(BuffStat.SMART_KNOCKBACK, ret.x));
break;
case Aran.BODY_PRESSURE:
statups.add(new Pair<>(MapleBuffStat.BODY_PRESSURE, ret.x));
statups.add(new Pair<>(BuffStat.BODY_PRESSURE, ret.x));
break;
case Aran.SNOW_CHARGE:
statups.add(new Pair<>(MapleBuffStat.WK_CHARGE, ret.duration));
statups.add(new Pair<>(BuffStat.WK_CHARGE, ret.duration));
break;
default:
break;
}
}
if (ret.isMorph()) {
statups.add(new Pair<>(MapleBuffStat.MORPH, ret.getMorph()));
statups.add(new Pair<>(BuffStat.MORPH, ret.getMorph()));
}
if (ret.ghost > 0 && !skill) {
statups.add(new Pair<>(MapleBuffStat.GHOST_MORPH, ret.ghost));
statups.add(new Pair<>(BuffStat.GHOST_MORPH, ret.ghost));
}
ret.monsterStatus = monsterStatus;
statups.trimToSize();
@@ -966,9 +966,9 @@ public class MapleStatEffect {
if (overTime || isCygnusFA() || summonMovementType != null) {
if (summonMovementType != null && pos != null) {
if (summonMovementType.getValue() == summonMovementType.STATIONARY.getValue()) {
applyto.cancelBuffStats(MapleBuffStat.PUPPET);
applyto.cancelBuffStats(BuffStat.PUPPET);
} else {
applyto.cancelBuffStats(MapleBuffStat.SUMMON);
applyto.cancelBuffStats(BuffStat.SUMMON);
}
applyto.sendPacket(PacketCreator.enableActions());
@@ -1024,7 +1024,7 @@ public class MapleStatEffect {
applyto.dropMessage(5, "There are no door portals available for the town at this moment. Try again later.");
}
applyto.cancelBuffStats(MapleBuffStat.SOULARROW); // cancel door buff
applyto.cancelBuffStats(BuffStat.SOULARROW); // cancel door buff
}
} else if (isMist()) {
Rectangle bounds = calculateBoundingBox(sourceid == NightWalker.POISON_BOMB ? pos : applyfrom.getPosition(), applyfrom.isFacingLeft());
@@ -1182,7 +1182,7 @@ public class MapleStatEffect {
}
public final void applyComboBuff(final MapleCharacter applyto, int combo) {
final List<Pair<MapleBuffStat, Integer>> stat = Collections.singletonList(new Pair<>(MapleBuffStat.ARAN_COMBO, combo));
final List<Pair<BuffStat, Integer>> stat = Collections.singletonList(new Pair<>(BuffStat.ARAN_COMBO, combo));
applyto.sendPacket(PacketCreator.giveBuff(sourceid, 99999, stat));
final long starttime = Server.getInstance().getCurrentTime();
@@ -1192,14 +1192,14 @@ public class MapleStatEffect {
}
public final void applyBeaconBuff(final MapleCharacter applyto, int objectid) { // thanks Thora & Hyun for reporting an issue with homing beacon autoflagging mobs when changing maps
final List<Pair<MapleBuffStat, Integer>> stat = Collections.singletonList(new Pair<>(MapleBuffStat.HOMING_BEACON, objectid));
final List<Pair<BuffStat, Integer>> stat = Collections.singletonList(new Pair<>(BuffStat.HOMING_BEACON, objectid));
applyto.sendPacket(PacketCreator.giveBuff(1, sourceid, stat));
final long starttime = Server.getInstance().getCurrentTime();
applyto.registerEffect(this, starttime, Long.MAX_VALUE, false);
}
public void updateBuffEffect(MapleCharacter target, List<Pair<MapleBuffStat, Integer>> activeStats, long starttime) {
public void updateBuffEffect(MapleCharacter target, List<Pair<BuffStat, Integer>> activeStats, long starttime) {
int localDuration = getBuffLocalDuration();
localDuration = alchemistModifyVal(target, localDuration, false);
@@ -1218,7 +1218,7 @@ public class MapleStatEffect {
applyto.cancelEffect(this, true, -1);
}
List<Pair<MapleBuffStat, Integer>> localstatups = statups;
List<Pair<BuffStat, Integer>> localstatups = statups;
int localDuration = getBuffLocalDuration();
int localsourceid = sourceid;
int seconds = localDuration / 1000;
@@ -1250,11 +1250,11 @@ public class MapleStatEffect {
localDuration = sourceid;
localsourceid = ridingMountId;
localstatups = Collections.singletonList(new Pair<>(MapleBuffStat.MONSTER_RIDING, 0));
localstatups = Collections.singletonList(new Pair<>(BuffStat.MONSTER_RIDING, 0));
} else if (isSkillMorph()) {
for (int i = 0; i < localstatups.size(); i++) {
if (localstatups.get(i).getLeft().equals(MapleBuffStat.MORPH)) {
localstatups.set(i, new Pair<>(MapleBuffStat.MORPH, getMorph(applyto)));
if (localstatups.get(i).getLeft().equals(BuffStat.MORPH)) {
localstatups.set(i, new Pair<>(BuffStat.MORPH, getMorph(applyto)));
break;
}
}
@@ -1278,16 +1278,16 @@ public class MapleStatEffect {
buff = PacketCreator.givePirateBuff(localstatups, sourceid, seconds);
mbuff = PacketCreator.giveForeignPirateBuff(applyto.getId(), sourceid, seconds, localstatups);
} else if (isDs()) {
List<Pair<MapleBuffStat, Integer>> dsstat = Collections.singletonList(new Pair<>(MapleBuffStat.DARKSIGHT, 0));
List<Pair<BuffStat, Integer>> dsstat = Collections.singletonList(new Pair<>(BuffStat.DARKSIGHT, 0));
mbuff = PacketCreator.giveForeignBuff(applyto.getId(), dsstat);
} else if (isWw()) {
List<Pair<MapleBuffStat, Integer>> dsstat = Collections.singletonList(new Pair<>(MapleBuffStat.WIND_WALK, 0));
List<Pair<BuffStat, Integer>> dsstat = Collections.singletonList(new Pair<>(BuffStat.WIND_WALK, 0));
mbuff = PacketCreator.giveForeignBuff(applyto.getId(), dsstat);
} else if (isCombo()) {
Integer comboCount = applyto.getBuffedValue(MapleBuffStat.COMBO);
Integer comboCount = applyto.getBuffedValue(BuffStat.COMBO);
if (comboCount == null) comboCount = 0;
List<Pair<MapleBuffStat, Integer>> cbstat = Collections.singletonList(new Pair<>(MapleBuffStat.COMBO, comboCount));
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);
} else if (isMonsterRiding()) {
@@ -1302,18 +1302,18 @@ public class MapleStatEffect {
mbuff = PacketCreator.showMonsterRiding(applyto.getId(), givemount);
localDuration = duration;
} else if (isShadowPartner()) {
List<Pair<MapleBuffStat, Integer>> stat = Collections.singletonList(new Pair<>(MapleBuffStat.SHADOWPARTNER, 0));
List<Pair<BuffStat, Integer>> stat = Collections.singletonList(new Pair<>(BuffStat.SHADOWPARTNER, 0));
mbuff = PacketCreator.giveForeignBuff(applyto.getId(), stat);
} else if (isSoulArrow()) {
List<Pair<MapleBuffStat, Integer>> stat = Collections.singletonList(new Pair<>(MapleBuffStat.SOULARROW, 0));
List<Pair<BuffStat, Integer>> stat = Collections.singletonList(new Pair<>(BuffStat.SOULARROW, 0));
mbuff = PacketCreator.giveForeignBuff(applyto.getId(), stat);
} else if (isEnrage()) {
applyto.handleOrbconsume();
} else if (isMorph()) {
List<Pair<MapleBuffStat, Integer>> stat = Collections.singletonList(new Pair<>(MapleBuffStat.MORPH, getMorph(applyto)));
List<Pair<BuffStat, Integer>> stat = Collections.singletonList(new Pair<>(BuffStat.MORPH, getMorph(applyto)));
mbuff = PacketCreator.giveForeignBuff(applyto.getId(), stat);
} else if (isAriantShield()) {
List<Pair<MapleBuffStat, Integer>> stat = Collections.singletonList(new Pair<>(MapleBuffStat.AURA, 1));
List<Pair<BuffStat, Integer>> stat = Collections.singletonList(new Pair<>(BuffStat.AURA, 1));
mbuff = PacketCreator.giveForeignBuff(applyto.getId(), stat);
}
@@ -1405,10 +1405,10 @@ public class MapleStatEffect {
}
}
mpchange -= mpCon * mod;
if (applyfrom.getBuffedValue(MapleBuffStat.INFINITY) != null) {
if (applyfrom.getBuffedValue(BuffStat.INFINITY) != null) {
mpchange = 0;
} else if (applyfrom.getBuffedValue(MapleBuffStat.CONCENTRATE) != null) {
mpchange -= (int) (mpchange * (applyfrom.getBuffedValue(MapleBuffStat.CONCENTRATE).doubleValue() / 100));
} else if (applyfrom.getBuffedValue(BuffStat.CONCENTRATE) != null) {
mpchange -= (int) (mpchange * (applyfrom.getBuffedValue(BuffStat.CONCENTRATE).doubleValue() / 100));
}
}
}
@@ -1683,8 +1683,8 @@ public class MapleStatEffect {
return false;
}
for (Pair<MapleBuffStat, Integer> p : statups) {
if (p.getLeft().equals(MapleBuffStat.WK_CHARGE)) {
for (Pair<BuffStat, Integer> p : statups) {
if (p.getLeft().equals(BuffStat.WK_CHARGE)) {
return true;
}
}
@@ -1854,7 +1854,7 @@ public class MapleStatEffect {
return duration;
}
public List<Pair<MapleBuffStat, Integer>> getStatups() {
public List<Pair<BuffStat, Integer>> getStatups() {
return statups;
}

8
src/main/java/server/life/MapleMonster.java
View File

@@ -670,7 +670,7 @@ public class MapleMonster extends AbstractLoadedMapleLife {
float multiplier = 1.0f;
// thanks Prophecy & Aika for finding out Holy Symbol not being applied on party bonuses
Integer holySymbol = attacker.getBuffedValue(MapleBuffStat.HOLY_SYMBOL);
Integer holySymbol = attacker.getBuffedValue(BuffStat.HOLY_SYMBOL);
if (holySymbol != null) {
if (YamlConfig.config.server.USE_FULL_HOLY_SYMBOL) { // thanks Mordred, xinyifly, AyumiLove, andy33 for noticing HS hands out 20% of its potential on less than 3 players
multiplier *= (1.0 + (holySymbol.doubleValue() / 100.0));
@@ -711,7 +711,7 @@ public class MapleMonster extends AbstractLoadedMapleLife {
personalExp = 0.0f;
}
Integer expBonus = attacker.getBuffedValue(MapleBuffStat.EXP_INCREASE);
Integer expBonus = attacker.getBuffedValue(BuffStat.EXP_INCREASE);
if (expBonus != null) { // exp increase player buff found thanks to HighKey21
personalExp += expBonus;
}
@@ -1797,7 +1797,7 @@ public class MapleMonster extends AbstractLoadedMapleLife {
}
public boolean isCharacterPuppetInVicinity(MapleCharacter chr) {
MapleStatEffect mse = chr.getBuffEffect(MapleBuffStat.PUPPET);
MapleStatEffect mse = chr.getBuffEffect(BuffStat.PUPPET);
if (mse != null) {
MapleSummon summon = chr.getSummonByKey(mse.getSourceId());
@@ -2139,7 +2139,7 @@ public class MapleMonster extends AbstractLoadedMapleLife {
return;
}
MapleStatEffect puppetEffect = chrController.getBuffEffect(MapleBuffStat.PUPPET);
MapleStatEffect puppetEffect = chrController.getBuffEffect(BuffStat.PUPPET);
if (puppetEffect != null) {
MapleSummon puppet = chrController.getSummonByKey(puppetEffect.getSourceId());

18
src/main/java/server/maps/MapleMap.java
View File

@@ -21,7 +21,7 @@
*/
package server.maps;
import client.MapleBuffStat;
import client.BuffStat;
import client.MapleCharacter;
import client.MapleClient;
import client.autoban.AutobanFactory;
@@ -648,8 +648,8 @@ public class MapleMap {
int mesos = Randomizer.nextInt(de.Maximum - de.Minimum) + de.Minimum;
if (mesos > 0) {
if (chr.getBuffedValue(MapleBuffStat.MESOUP) != null) {
mesos = (int) (mesos * chr.getBuffedValue(MapleBuffStat.MESOUP).doubleValue() / 100.0);
if (chr.getBuffedValue(BuffStat.MESOUP) != null) {
mesos = (int) (mesos * chr.getBuffedValue(BuffStat.MESOUP).doubleValue() / 100.0);
}
mesos = mesos * chr.getMesoRate();
if (mesos <= 0) {
@@ -2389,9 +2389,9 @@ public class MapleMap {
msm.runMapScript(chr.getClient(), "onUserEnter/" + onUserEnter, false);
}
if (FieldLimit.CANNOTUSEMOUNTS.check(fieldLimit) && chr.getBuffedValue(MapleBuffStat.MONSTER_RIDING) != null) {
chr.cancelEffectFromBuffStat(MapleBuffStat.MONSTER_RIDING);
chr.cancelBuffStats(MapleBuffStat.MONSTER_RIDING);
if (FieldLimit.CANNOTUSEMOUNTS.check(fieldLimit) && chr.getBuffedValue(BuffStat.MONSTER_RIDING) != null) {
chr.cancelEffectFromBuffStat(BuffStat.MONSTER_RIDING);
chr.cancelBuffStats(BuffStat.MONSTER_RIDING);
}
if (mapid == 200090060) { // To Rien
@@ -2494,7 +2494,7 @@ public class MapleMap {
broadcastGMSpawnPlayerMapObjectMessage(chr, chr, true);
chr.sendPacket(PacketCreator.getGMEffect(0x10, (byte) 1));
List<Pair<MapleBuffStat, Integer>> dsstat = Collections.singletonList(new Pair<>(MapleBuffStat.DARKSIGHT, 0));
List<Pair<BuffStat, Integer>> dsstat = Collections.singletonList(new Pair<>(BuffStat.DARKSIGHT, 0));
broadcastGMMessage(chr, PacketCreator.giveForeignBuff(chr.getId(), dsstat), false);
} else {
broadcastSpawnPlayerMapObjectMessage(chr, chr, true);
@@ -2534,7 +2534,7 @@ public class MapleMap {
}
}
MapleStatEffect summonStat = chr.getStatForBuff(MapleBuffStat.SUMMON);
MapleStatEffect summonStat = chr.getStatForBuff(BuffStat.SUMMON);
if (summonStat != null) {
MapleSummon summon = chr.getSummonByKey(summonStat.getSourceId());
summon.setPosition(chr.getPosition());
@@ -2700,7 +2700,7 @@ public class MapleMap {
for (MapleSummon summon : new ArrayList<>(chr.getSummonsValues())) {
if (summon.isStationary()) {
chr.cancelEffectFromBuffStat(MapleBuffStat.PUPPET);
chr.cancelEffectFromBuffStat(BuffStat.PUPPET);
} else {
removeMapObject(summon);
}

68
src/main/java/tools/PacketCreator.java
View File

@@ -1797,32 +1797,32 @@ public class PacketCreator {
p.writeShort(0); //v83
p.writeByte(0xFC);
p.writeByte(1);
if (chr.getBuffedValue(MapleBuffStat.MORPH) != null) {
if (chr.getBuffedValue(BuffStat.MORPH) != null) {
p.writeInt(2);
} else {
p.writeInt(0);
}
long buffmask = 0;
Integer buffvalue = null;
if ((chr.getBuffedValue(MapleBuffStat.DARKSIGHT) != null || chr.getBuffedValue(MapleBuffStat.WIND_WALK) != null) && !chr.isHidden()) {
buffmask |= MapleBuffStat.DARKSIGHT.getValue();
if ((chr.getBuffedValue(BuffStat.DARKSIGHT) != null || chr.getBuffedValue(BuffStat.WIND_WALK) != null) && !chr.isHidden()) {
buffmask |= BuffStat.DARKSIGHT.getValue();
}
if (chr.getBuffedValue(MapleBuffStat.COMBO) != null) {
buffmask |= MapleBuffStat.COMBO.getValue();
buffvalue = Integer.valueOf(chr.getBuffedValue(MapleBuffStat.COMBO));
if (chr.getBuffedValue(BuffStat.COMBO) != null) {
buffmask |= BuffStat.COMBO.getValue();
buffvalue = Integer.valueOf(chr.getBuffedValue(BuffStat.COMBO));
}
if (chr.getBuffedValue(MapleBuffStat.SHADOWPARTNER) != null) {
buffmask |= MapleBuffStat.SHADOWPARTNER.getValue();
if (chr.getBuffedValue(BuffStat.SHADOWPARTNER) != null) {
buffmask |= BuffStat.SHADOWPARTNER.getValue();
}
if (chr.getBuffedValue(MapleBuffStat.SOULARROW) != null) {
buffmask |= MapleBuffStat.SOULARROW.getValue();
if (chr.getBuffedValue(BuffStat.SOULARROW) != null) {
buffmask |= BuffStat.SOULARROW.getValue();
}
if (chr.getBuffedValue(MapleBuffStat.MORPH) != null) {
buffvalue = Integer.valueOf(chr.getBuffedValue(MapleBuffStat.MORPH));
if (chr.getBuffedValue(BuffStat.MORPH) != null) {
buffvalue = Integer.valueOf(chr.getBuffedValue(BuffStat.MORPH));
}
p.writeInt((int) ((buffmask >> 32) & 0xffffffffL));
if (buffvalue != null) {
if (chr.getBuffedValue(MapleBuffStat.MORPH) != null) { //TEST
if (chr.getBuffedValue(BuffStat.MORPH) != null) { //TEST
p.writeShort(buffvalue);
} else {
p.writeByte(buffvalue.byteValue());
@@ -1835,7 +1835,7 @@ public class PacketCreator {
p.writeShort(0);
p.skip(4);
boolean dashBuff = chr.getBuffedValue(MapleBuffStat.DASH) != null;
boolean dashBuff = chr.getBuffedValue(BuffStat.DASH) != null;
// Dash Speed
p.writeInt(dashBuff ? 1 << 24 : 0);
p.skip(11);
@@ -1847,7 +1847,7 @@ public class PacketCreator {
p.writeByte(0);
// Monster Riding
Integer bv = chr.getBuffedValue(MapleBuffStat.MONSTER_RIDING);
Integer bv = chr.getBuffedValue(BuffStat.MONSTER_RIDING);
if (bv != null) {
MapleMount mount = chr.getMount();
if (mount != null) {
@@ -2754,7 +2754,7 @@ public class PacketCreator {
/**
* It is important that statups is in the correct order (see declaration
* order in MapleBuffStat) since this method doesn't do automagical
* order in BuffStat) since this method doesn't do automagical
* reordering.
*
* @param buffid
@@ -2763,12 +2763,12 @@ public class PacketCreator {
* @return
*/
//1F 00 00 00 00 00 03 00 00 40 00 00 00 E0 00 00 00 00 00 00 00 00 E0 01 8E AA 4F 00 00 C2 EB 0B E0 01 8E AA 4F 00 00 C2 EB 0B 0C 00 8E AA 4F 00 00 C2 EB 0B 44 02 8E AA 4F 00 00 C2 EB 0B 44 02 8E AA 4F 00 00 C2 EB 0B 00 00 E0 7A 1D 00 8E AA 4F 00 00 00 00 00 00 00 00 03
public static Packet giveBuff(int buffid, int bufflength, List<Pair<MapleBuffStat, Integer>> statups) {
public static Packet giveBuff(int buffid, int bufflength, List<Pair<BuffStat, Integer>> statups) {
final OutPacket p = OutPacket.create(SendOpcode.GIVE_BUFF);
boolean special = false;
writeLongMask(p, statups);
for (Pair<MapleBuffStat, Integer> statup : statups) {
if (statup.getLeft().equals(MapleBuffStat.MONSTER_RIDING) || statup.getLeft().equals(MapleBuffStat.HOMING_BEACON)) {
for (Pair<BuffStat, Integer> statup : statups) {
if (statup.getLeft().equals(BuffStat.MONSTER_RIDING) || statup.getLeft().equals(BuffStat.HOMING_BEACON)) {
special = true;
}
p.writeShort(statup.getRight().shortValue());
@@ -2794,7 +2794,7 @@ public class PacketCreator {
public static Packet showMonsterRiding(int cid, MapleMount mount) { //Gtfo with this, this is just giveForeignBuff
final OutPacket p = OutPacket.create(SendOpcode.GIVE_FOREIGN_BUFF);
p.writeInt(cid);
p.writeLong(MapleBuffStat.MONSTER_RIDING.getValue());
p.writeLong(BuffStat.MONSTER_RIDING.getValue());
p.writeLong(0);
p.writeShort(0);
p.writeInt(mount.getItemId());
@@ -2806,7 +2806,7 @@ public class PacketCreator {
}
/* p.writeInt(cid);
writeLongMask(mplew, statups);
for (Pair<MapleBuffStat, Integer> statup : statups) {
for (Pair<BuffStat, Integer> statup : statups) {
if (morph) {
p.writeInt(statup.getRight().intValue());
} else {
@@ -2956,11 +2956,11 @@ public class PacketCreator {
return p;
}
public static Packet giveForeignBuff(int chrId, List<Pair<MapleBuffStat, Integer>> statups) {
public static Packet giveForeignBuff(int chrId, List<Pair<BuffStat, Integer>> statups) {
OutPacket p = OutPacket.create(SendOpcode.GIVE_FOREIGN_BUFF);
p.writeInt(chrId);
writeLongMask(p, statups);
for (Pair<MapleBuffStat, Integer> statup : statups) {
for (Pair<BuffStat, Integer> statup : statups) {
p.writeShort(statup.getRight().shortValue());
}
p.writeInt(0);
@@ -2968,24 +2968,24 @@ public class PacketCreator {
return p;
}
public static Packet cancelForeignBuff(int chrId, List<MapleBuffStat> statups) {
public static Packet cancelForeignBuff(int chrId, List<BuffStat> statups) {
OutPacket p = OutPacket.create(SendOpcode.CANCEL_FOREIGN_BUFF);
p.writeInt(chrId);
writeLongMaskFromList(p, statups);
return p;
}
public static Packet cancelBuff(List<MapleBuffStat> statups) {
public static Packet cancelBuff(List<BuffStat> statups) {
OutPacket p = OutPacket.create(SendOpcode.CANCEL_BUFF);
writeLongMaskFromList(p, statups);
p.writeByte(1);//?
return p;
}
private static void writeLongMask(final OutPacket p, List<Pair<MapleBuffStat, Integer>> statups) {
private static void writeLongMask(final OutPacket p, List<Pair<BuffStat, Integer>> statups) {
long firstmask = 0;
long secondmask = 0;
for (Pair<MapleBuffStat, Integer> statup : statups) {
for (Pair<BuffStat, Integer> statup : statups) {
if (statup.getLeft().isFirst()) {
firstmask |= statup.getLeft().getValue();
} else {
@@ -2996,10 +2996,10 @@ public class PacketCreator {
p.writeLong(secondmask);
}
private static void writeLongMaskFromList(OutPacket p, List<MapleBuffStat> statups) {
private static void writeLongMaskFromList(OutPacket p, List<BuffStat> statups) {
long firstmask = 0;
long secondmask = 0;
for (MapleBuffStat statup : statups) {
for (BuffStat statup : statups) {
if (statup.isFirst()) {
firstmask |= statup.getValue();
} else {
@@ -3087,7 +3087,7 @@ public class PacketCreator {
}
// packet found thanks to Ronan
public static Packet giveForeignWKChargeEffect(int cid, int buffid, List<Pair<MapleBuffStat, Integer>> statups) {
public static Packet giveForeignWKChargeEffect(int cid, int buffid, List<Pair<BuffStat, Integer>> statups) {
OutPacket p = OutPacket.create(SendOpcode.GIVE_FOREIGN_BUFF);
p.writeInt(cid);
writeLongMask(p, statups);
@@ -5312,12 +5312,12 @@ public class PacketCreator {
return p;
}
public static Packet givePirateBuff(List<Pair<MapleBuffStat, Integer>> statups, int buffid, int duration) {
public static Packet givePirateBuff(List<Pair<BuffStat, Integer>> statups, int buffid, int duration) {
OutPacket p = OutPacket.create(SendOpcode.GIVE_BUFF);
boolean infusion = buffid == Buccaneer.SPEED_INFUSION || buffid == ThunderBreaker.SPEED_INFUSION || buffid == Corsair.SPEED_INFUSION;
writeLongMask(p, statups);
p.writeShort(0);
for (Pair<MapleBuffStat, Integer> stat : statups) {
for (Pair<BuffStat, Integer> stat : statups) {
p.writeInt(stat.getRight().shortValue());
p.writeInt(buffid);
p.skip(infusion ? 10 : 5);
@@ -5327,13 +5327,13 @@ public class PacketCreator {
return p;
}
public static Packet giveForeignPirateBuff(int cid, int buffid, int time, List<Pair<MapleBuffStat, Integer>> statups) {
public static Packet giveForeignPirateBuff(int cid, int buffid, int time, List<Pair<BuffStat, Integer>> statups) {
OutPacket p = OutPacket.create(SendOpcode.GIVE_FOREIGN_BUFF);
boolean infusion = buffid == Buccaneer.SPEED_INFUSION || buffid == ThunderBreaker.SPEED_INFUSION || buffid == Corsair.SPEED_INFUSION;
p.writeInt(cid);
writeLongMask(p, statups);
p.writeShort(0);
for (Pair<MapleBuffStat, Integer> statup : statups) {
for (Pair<BuffStat, Integer> statup : statups) {
p.writeInt(statup.getRight().shortValue());
p.writeInt(buffid);
p.skip(infusion ? 10 : 5);