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

Rename and clean up MapleDisease

Browse Source
This commit is contained in:
P0nk
2021-09-09 21:15:22 +02:00
parent b07e6799dc
commit 0c721b85dd
14 changed files with 149 additions and 148 deletions
Download Patch File Download Diff File Expand all files Collapse all files

86
src/main/java/client/Character.java
View File

@@ -185,13 +185,13 @@ public class Character extends AbstractCharacterObject {
private final Map<Integer, Integer> activeCouponRates = new LinkedHashMap<>(); private final Map<Integer, Integer> activeCouponRates = new LinkedHashMap<>();
private final EnumMap<BuffStat, MapleBuffStatValueHolder> effects = new EnumMap<>(BuffStat.class); private final EnumMap<BuffStat, MapleBuffStatValueHolder> effects = new EnumMap<>(BuffStat.class);
private final Map<BuffStat, Byte> buffEffectsCount = new LinkedHashMap<>(); private final Map<BuffStat, Byte> buffEffectsCount = new LinkedHashMap<>();
private final Map<MapleDisease, Long> diseaseExpires = new LinkedHashMap<>(); private final Map<Disease, Long> diseaseExpires = new LinkedHashMap<>();
private final Map<Integer, Map<BuffStat, MapleBuffStatValueHolder>> buffEffects = new LinkedHashMap<>(); // non-overriding buffs thanks to Ronan private final Map<Integer, Map<BuffStat, MapleBuffStatValueHolder>> buffEffects = new LinkedHashMap<>(); // non-overriding buffs thanks to Ronan
private final Map<Integer, Long> buffExpires = new LinkedHashMap<>(); private final Map<Integer, Long> buffExpires = new LinkedHashMap<>();
private final Map<Integer, KeyBinding> keymap = new LinkedHashMap<>(); private final Map<Integer, KeyBinding> keymap = new LinkedHashMap<>();
private final Map<Integer, MapleSummon> summons = new LinkedHashMap<>(); private final Map<Integer, MapleSummon> summons = new LinkedHashMap<>();
private final Map<Integer, MapleCoolDownValueHolder> coolDowns = new LinkedHashMap<>(); private final Map<Integer, MapleCoolDownValueHolder> coolDowns = new LinkedHashMap<>();
private final EnumMap<MapleDisease, Pair<MapleDiseaseValueHolder, MobSkill>> diseases = new EnumMap<>(MapleDisease.class); private final EnumMap<Disease, Pair<MapleDiseaseValueHolder, MobSkill>> diseases = new EnumMap<>(Disease.class);
private byte[] m_aQuickslotLoaded; private byte[] m_aQuickslotLoaded;
private QuickslotBinding m_pQuickslotKeyMapped; private QuickslotBinding m_pQuickslotKeyMapped;
private MapleDoor pdoor = null; private MapleDoor pdoor = null;
@@ -2536,7 +2536,7 @@ public class Character extends AbstractCharacterObject {
} }
} }
public final boolean hasDisease(final MapleDisease dis) { public final boolean hasDisease(final Disease dis) {
chrLock.lock(); chrLock.lock();
try { try {
return diseases.containsKey(dis); return diseases.containsKey(dis);
@@ -2554,13 +2554,13 @@ public class Character extends AbstractCharacterObject {
} }
} }
public Map<MapleDisease, Pair<Long, MobSkill>> getAllDiseases() { public Map<Disease, Pair<Long, MobSkill>> getAllDiseases() {
chrLock.lock(); chrLock.lock();
try { try {
long curtime = Server.getInstance().getCurrentTime(); long curtime = Server.getInstance().getCurrentTime();
Map<MapleDisease, Pair<Long, MobSkill>> ret = new LinkedHashMap<>(); Map<Disease, Pair<Long, MobSkill>> ret = new LinkedHashMap<>();
for (Entry<MapleDisease, Long> de : diseaseExpires.entrySet()) { for (Entry<Disease, Long> de : diseaseExpires.entrySet()) {
Pair<MapleDiseaseValueHolder, MobSkill> dee = diseases.get(de.getKey()); Pair<MapleDiseaseValueHolder, MobSkill> dee = diseases.get(de.getKey());
MapleDiseaseValueHolder mdvh = dee.getLeft(); MapleDiseaseValueHolder mdvh = dee.getLeft();
@@ -2573,12 +2573,12 @@ public class Character extends AbstractCharacterObject {
} }
} }
public void silentApplyDiseases(Map<MapleDisease, Pair<Long, MobSkill>> diseaseMap) { public void silentApplyDiseases(Map<Disease, Pair<Long, MobSkill>> diseaseMap) {
chrLock.lock(); chrLock.lock();
try { try {
long curTime = Server.getInstance().getCurrentTime(); long curTime = Server.getInstance().getCurrentTime();
for (Entry<MapleDisease, Pair<Long, MobSkill>> di : diseaseMap.entrySet()) { for (Entry<Disease, Pair<Long, MobSkill>> di : diseaseMap.entrySet()) {
long expTime = curTime + di.getValue().getLeft(); long expTime = curTime + di.getValue().getLeft();
diseaseExpires.put(di.getKey(), expTime); diseaseExpires.put(di.getKey(), expTime);
@@ -2590,7 +2590,7 @@ public class Character extends AbstractCharacterObject {
} }
public void announceDiseases() { public void announceDiseases() {
Set<Entry<MapleDisease, Pair<MapleDiseaseValueHolder, MobSkill>>> chrDiseases; Set<Entry<Disease, Pair<MapleDiseaseValueHolder, MobSkill>>> chrDiseases;
chrLock.lock(); chrLock.lock();
try { try {
@@ -2604,12 +2604,12 @@ public class Character extends AbstractCharacterObject {
chrLock.unlock(); chrLock.unlock();
} }
for (Entry<MapleDisease, Pair<MapleDiseaseValueHolder, MobSkill>> di : chrDiseases) { for (Entry<Disease, Pair<MapleDiseaseValueHolder, MobSkill>> di : chrDiseases) {
MapleDisease disease = di.getKey(); Disease disease = di.getKey();
MobSkill skill = di.getValue().getRight(); MobSkill skill = di.getValue().getRight();
final List<Pair<MapleDisease, Integer>> debuff = Collections.singletonList(new Pair<>(disease, Integer.valueOf(skill.getX()))); final List<Pair<Disease, Integer>> debuff = Collections.singletonList(new Pair<>(disease, Integer.valueOf(skill.getX())));
if (disease != MapleDisease.SLOW) { if (disease != Disease.SLOW) {
map.broadcastMessage(PacketCreator.giveForeignDebuff(id, debuff, skill)); map.broadcastMessage(PacketCreator.giveForeignDebuff(id, debuff, skill));
} else { } else {
map.broadcastMessage(PacketCreator.giveForeignSlowDebuff(id, debuff, skill)); map.broadcastMessage(PacketCreator.giveForeignSlowDebuff(id, debuff, skill));
@@ -2621,12 +2621,12 @@ public class Character extends AbstractCharacterObject {
for (Character chr : map.getAllPlayers()) { for (Character chr : map.getAllPlayers()) {
int cid = chr.getId(); int cid = chr.getId();
for (Entry<MapleDisease, Pair<Long, MobSkill>> di : chr.getAllDiseases().entrySet()) { for (Entry<Disease, Pair<Long, MobSkill>> di : chr.getAllDiseases().entrySet()) {
MapleDisease disease = di.getKey(); Disease disease = di.getKey();
MobSkill skill = di.getValue().getRight(); MobSkill skill = di.getValue().getRight();
final List<Pair<MapleDisease, Integer>> debuff = Collections.singletonList(new Pair<>(disease, Integer.valueOf(skill.getX()))); final List<Pair<Disease, Integer>> debuff = Collections.singletonList(new Pair<>(disease, Integer.valueOf(skill.getX())));
if (disease != MapleDisease.SLOW) { if (disease != Disease.SLOW) {
this.sendPacket(PacketCreator.giveForeignDebuff(cid, debuff, skill)); this.sendPacket(PacketCreator.giveForeignDebuff(cid, debuff, skill));
} else { } else {
this.sendPacket(PacketCreator.giveForeignSlowDebuff(cid, debuff, skill)); this.sendPacket(PacketCreator.giveForeignSlowDebuff(cid, debuff, skill));
@@ -2635,9 +2635,9 @@ public class Character extends AbstractCharacterObject {
} }
} }
public void giveDebuff(final MapleDisease disease, MobSkill skill) { public void giveDebuff(final Disease disease, MobSkill skill) {
if (!hasDisease(disease) && getDiseasesSize() < 2) { if (!hasDisease(disease) && getDiseasesSize() < 2) {
if (!(disease == MapleDisease.SEDUCE || disease == MapleDisease.STUN)) { if (!(disease == Disease.SEDUCE || disease == Disease.STUN)) {
if (hasActiveBuff(Bishop.HOLY_SHIELD)) { if (hasActiveBuff(Bishop.HOLY_SHIELD)) {
return; return;
} }
@@ -2652,14 +2652,14 @@ public class Character extends AbstractCharacterObject {
chrLock.unlock(); chrLock.unlock();
} }
if (disease == MapleDisease.SEDUCE && chair.get() < 0) { if (disease == Disease.SEDUCE && chair.get() < 0) {
sitChair(-1); sitChair(-1);
} }
final List<Pair<MapleDisease, Integer>> debuff = Collections.singletonList(new Pair<>(disease, Integer.valueOf(skill.getX()))); final List<Pair<Disease, Integer>> debuff = Collections.singletonList(new Pair<>(disease, Integer.valueOf(skill.getX())));
sendPacket(PacketCreator.giveDebuff(debuff, skill)); sendPacket(PacketCreator.giveDebuff(debuff, skill));
if (disease != MapleDisease.SLOW) { if (disease != Disease.SLOW) {
map.broadcastMessage(this, PacketCreator.giveForeignDebuff(id, debuff, skill), false); map.broadcastMessage(this, PacketCreator.giveForeignDebuff(id, debuff, skill), false);
} else { } else {
map.broadcastMessage(this, PacketCreator.giveForeignSlowDebuff(id, debuff, skill), false); map.broadcastMessage(this, PacketCreator.giveForeignSlowDebuff(id, debuff, skill), false);
@@ -2667,12 +2667,12 @@ public class Character extends AbstractCharacterObject {
} }
} }
public void dispelDebuff(MapleDisease debuff) { public void dispelDebuff(Disease debuff) {
if (hasDisease(debuff)) { if (hasDisease(debuff)) {
long mask = debuff.getValue(); long mask = debuff.getValue();
sendPacket(PacketCreator.cancelDebuff(mask)); sendPacket(PacketCreator.cancelDebuff(mask));
if (debuff != MapleDisease.SLOW) { if (debuff != Disease.SLOW) {
map.broadcastMessage(this, PacketCreator.cancelForeignDebuff(id, mask), false); map.broadcastMessage(this, PacketCreator.cancelForeignDebuff(id, mask), false);
} else { } else {
map.broadcastMessage(this, PacketCreator.cancelForeignSlowDebuff(id), false); map.broadcastMessage(this, PacketCreator.cancelForeignSlowDebuff(id), false);
@@ -2689,18 +2689,18 @@ public class Character extends AbstractCharacterObject {
} }
public void dispelDebuffs() { public void dispelDebuffs() {
dispelDebuff(MapleDisease.CURSE); dispelDebuff(Disease.CURSE);
dispelDebuff(MapleDisease.DARKNESS); dispelDebuff(Disease.DARKNESS);
dispelDebuff(MapleDisease.POISON); dispelDebuff(Disease.POISON);
dispelDebuff(MapleDisease.SEAL); dispelDebuff(Disease.SEAL);
dispelDebuff(MapleDisease.WEAKEN); dispelDebuff(Disease.WEAKEN);
dispelDebuff(MapleDisease.SLOW); // thanks Conrad for noticing ZOMBIFY isn't dispellable dispelDebuff(Disease.SLOW); // thanks Conrad for noticing ZOMBIFY isn't dispellable
} }
public void purgeDebuffs() { public void purgeDebuffs() {
dispelDebuff(MapleDisease.SEDUCE); dispelDebuff(Disease.SEDUCE);
dispelDebuff(MapleDisease.ZOMBIFY); dispelDebuff(Disease.ZOMBIFY);
dispelDebuff(MapleDisease.CONFUSE); dispelDebuff(Disease.CONFUSE);
dispelDebuffs(); dispelDebuffs();
} }
@@ -2815,13 +2815,13 @@ public class Character extends AbstractCharacterObject {
diseaseExpireTask = TimerManager.getInstance().register(new Runnable() { diseaseExpireTask = TimerManager.getInstance().register(new Runnable() {
@Override @Override
public void run() { public void run() {
Set<MapleDisease> toExpire = new LinkedHashSet<>(); Set<Disease> toExpire = new LinkedHashSet<>();
chrLock.lock(); chrLock.lock();
try { try {
long curTime = Server.getInstance().getCurrentTime(); long curTime = Server.getInstance().getCurrentTime();
for (Entry<MapleDisease, Long> de : diseaseExpires.entrySet()) { for (Entry<Disease, Long> de : diseaseExpires.entrySet()) {
if (de.getValue() < curTime) { if (de.getValue() < curTime) {
toExpire.add(de.getKey()); toExpire.add(de.getKey());
} }
@@ -2830,7 +2830,7 @@ public class Character extends AbstractCharacterObject {
chrLock.unlock(); chrLock.unlock();
} }
for (MapleDisease d : toExpire) { for (Disease d : toExpire) {
dispelDebuff(d); dispelDebuff(d);
} }
} }
@@ -3052,7 +3052,7 @@ public class Character extends AbstractCharacterObject {
} }
public void gainExp(int gain, int party, boolean show, boolean inChat, boolean white) { public void gainExp(int gain, int party, boolean show, boolean inChat, boolean white) {
if (hasDisease(MapleDisease.CURSE)) { if (hasDisease(Disease.CURSE)) {
gain *= 0.5; gain *= 0.5;
party *= 0.5; party *= 0.5;
} }
@@ -7328,14 +7328,14 @@ public class Character extends AbstractCharacterObject {
} }
// Debuffs (load) // Debuffs (load)
Map<MapleDisease, Pair<Long, MobSkill>> loadedDiseases = new LinkedHashMap<>(); Map<Disease, Pair<Long, MobSkill>> loadedDiseases = new LinkedHashMap<>();
try (PreparedStatement ps = con.prepareStatement("SELECT * FROM playerdiseases WHERE charid = ?")) { try (PreparedStatement ps = con.prepareStatement("SELECT * FROM playerdiseases WHERE charid = ?")) {
ps.setInt(1, ret.getId()); ps.setInt(1, ret.getId());
try (ResultSet rs = ps.executeQuery()) { try (ResultSet rs = ps.executeQuery()) {
while (rs.next()) { while (rs.next()) {
final MapleDisease disease = MapleDisease.ordinal(rs.getInt("disease")); final Disease disease = Disease.ordinal(rs.getInt("disease"));
if (disease == MapleDisease.NULL) { if (disease == Disease.NULL) {
continue; continue;
} }
@@ -8106,14 +8106,14 @@ public class Character extends AbstractCharacterObject {
} }
} }
Map<MapleDisease, Pair<Long, MobSkill>> listds = getAllDiseases(); Map<Disease, Pair<Long, MobSkill>> listds = getAllDiseases();
if (!listds.isEmpty()) { if (!listds.isEmpty()) {
try (Connection con = DatabaseConnection.getConnection()) { try (Connection con = DatabaseConnection.getConnection()) {
deleteWhereCharacterId(con, "DELETE FROM playerdiseases WHERE charid = ?"); deleteWhereCharacterId(con, "DELETE FROM playerdiseases WHERE charid = ?");
try (PreparedStatement ps = con.prepareStatement("INSERT INTO playerdiseases (charid, disease, mobskillid, mobskilllv, length) VALUES (?, ?, ?, ?, ?)")) { try (PreparedStatement ps = con.prepareStatement("INSERT INTO playerdiseases (charid, disease, mobskillid, mobskilllv, length) VALUES (?, ?, ?, ?, ?)")) {
ps.setInt(1, getId()); ps.setInt(1, getId());
for (Entry<MapleDisease, Pair<Long, MobSkill>> e : listds.entrySet()) { for (Entry<Disease, Pair<Long, MobSkill>> e : listds.entrySet()) {
ps.setInt(2, e.getKey().ordinal()); ps.setInt(2, e.getKey().ordinal());
MobSkill ms = e.getValue().getRight(); MobSkill ms = e.getValue().getRight();
@@ -9085,7 +9085,7 @@ public class Character extends AbstractCharacterObject {
} }
public boolean applyHpMpChange(int hpCon, int hpchange, int mpchange) { public boolean applyHpMpChange(int hpCon, int hpchange, int mpchange) {
boolean zombify = hasDisease(MapleDisease.ZOMBIFY); boolean zombify = hasDisease(Disease.ZOMBIFY);
effLock.lock(); effLock.lock();
statWlock.lock(); statWlock.lock();

44
src/main/java/client/MapleDisease.java → src/main/java/client/Disease.java
View File

@@ -23,7 +23,7 @@ package client;
import constants.game.GameConstants; import constants.game.GameConstants;
public enum MapleDisease { public enum Disease {
NULL(0x0), NULL(0x0),
SLOW(0x1, 126), SLOW(0x1, 126),
SEDUCE(0x80, 128), SEDUCE(0x80, 128),
@@ -36,25 +36,25 @@ public enum MapleDisease {
DARKNESS(0x10000000000000L, 121), DARKNESS(0x10000000000000L, 121),
WEAKEN(0x4000000000000000L, 122), WEAKEN(0x4000000000000000L, 122),
CURSE(0x8000000000000000L, 124); CURSE(0x8000000000000000L, 124);
private long i; private final long i;
private boolean first; private final boolean first;
private int mobskill; private final int mobskill;
private MapleDisease(long i) { Disease(long i) {
this(i, false, 0); this(i, false, 0);
} }
private MapleDisease(long i, int skill) { Disease(long i, int skill) {
this(i, false, skill); this(i, false, skill);
} }
private MapleDisease(long i, boolean first, int skill) { Disease(long i, boolean first, int skill) {
this.i = i; this.i = i;
this.first = first; this.first = first;
this.mobskill = skill; this.mobskill = skill;
} }
public long getValue() { public long getValue() {
return i; return i;
} }
@@ -62,31 +62,31 @@ public enum MapleDisease {
public boolean isFirst() { public boolean isFirst() {
return first; return first;
} }
public int getDisease() { public int getDisease() {
return mobskill; return mobskill;
} }
public static MapleDisease ordinal(int ord) { public static Disease ordinal(int ord) {
try { try {
return MapleDisease.values()[ord]; return Disease.values()[ord];
} catch (IndexOutOfBoundsException io) { } catch (IndexOutOfBoundsException io) {
return NULL; return NULL;
} }
} }
public static final MapleDisease getRandom() { public static final Disease getRandom() {
MapleDisease[] diseases = GameConstants.CPQ_DISEASES; Disease[] diseases = GameConstants.CPQ_DISEASES;
return diseases[(int) (Math.random() * diseases.length)]; return diseases[(int) (Math.random() * diseases.length)];
} }
public static final MapleDisease getBySkill(final int skill) { public static final Disease getBySkill(final int skill) {
for (MapleDisease d : MapleDisease.values()) { for (Disease d : Disease.values()) {
if (d.getDisease() == skill && d.getDisease() != 0) { if (d.getDisease() == skill && d.getDisease() != 0) {
return d; return d;
} }
} }
return null; return null;
} }
} }

24
src/main/java/client/command/commands/gm3/DebuffCommand.java
View File

@@ -25,7 +25,7 @@ package client.command.commands.gm3;
import client.Character; import client.Character;
import client.Client; import client.Client;
import client.MapleDisease; import client.Disease;
import client.command.Command; import client.command.Command;
import server.life.MobSkill; import server.life.MobSkill;
import server.life.MobSkillFactory; import server.life.MobSkillFactory;
@@ -47,57 +47,57 @@ public class DebuffCommand extends Command {
return; return;
} }
MapleDisease disease = null; Disease disease = null;
MobSkill skill = null; MobSkill skill = null;
switch (params[0].toUpperCase()) { switch (params[0].toUpperCase()) {
case "SLOW": case "SLOW":
disease = MapleDisease.SLOW; disease = Disease.SLOW;
skill = MobSkillFactory.getMobSkill(126, 7); skill = MobSkillFactory.getMobSkill(126, 7);
break; break;
case "SEDUCE": case "SEDUCE":
disease = MapleDisease.SEDUCE; disease = Disease.SEDUCE;
skill = MobSkillFactory.getMobSkill(128, 7); skill = MobSkillFactory.getMobSkill(128, 7);
break; break;
case "ZOMBIFY": case "ZOMBIFY":
disease = MapleDisease.ZOMBIFY; disease = Disease.ZOMBIFY;
skill = MobSkillFactory.getMobSkill(133, 1); skill = MobSkillFactory.getMobSkill(133, 1);
break; break;
case "CONFUSE": case "CONFUSE":
disease = MapleDisease.CONFUSE; disease = Disease.CONFUSE;
skill = MobSkillFactory.getMobSkill(132, 2); skill = MobSkillFactory.getMobSkill(132, 2);
break; break;
case "STUN": case "STUN":
disease = MapleDisease.STUN; disease = Disease.STUN;
skill = MobSkillFactory.getMobSkill(123, 7); skill = MobSkillFactory.getMobSkill(123, 7);
break; break;
case "POISON": case "POISON":
disease = MapleDisease.POISON; disease = Disease.POISON;
skill = MobSkillFactory.getMobSkill(125, 5); skill = MobSkillFactory.getMobSkill(125, 5);
break; break;
case "SEAL": case "SEAL":
disease = MapleDisease.SEAL; disease = Disease.SEAL;
skill = MobSkillFactory.getMobSkill(120, 1); skill = MobSkillFactory.getMobSkill(120, 1);
break; break;
case "DARKNESS": case "DARKNESS":
disease = MapleDisease.DARKNESS; disease = Disease.DARKNESS;
skill = MobSkillFactory.getMobSkill(121, 1); skill = MobSkillFactory.getMobSkill(121, 1);
break; break;
case "WEAKEN": case "WEAKEN":
disease = MapleDisease.WEAKEN; disease = Disease.WEAKEN;
skill = MobSkillFactory.getMobSkill(122, 1); skill = MobSkillFactory.getMobSkill(122, 1);
break; break;
case "CURSE": case "CURSE":
disease = MapleDisease.CURSE; disease = Disease.CURSE;
skill = MobSkillFactory.getMobSkill(124, 1); skill = MobSkillFactory.getMobSkill(124, 1);
break; break;
} }

6
src/main/java/constants/game/GameConstants.java
View File

@@ -1,6 +1,6 @@
package constants.game; package constants.game;
import client.MapleDisease; import client.Disease;
import client.MapleJob; import client.MapleJob;
import config.YamlConfig; import config.YamlConfig;
import constants.skills.Aran; import constants.skills.Aran;
@@ -35,8 +35,8 @@ public class GameConstants {
private final static NumberFormat nfFormatter = new DecimalFormat("#,###,###,###"); private final static NumberFormat nfFormatter = new DecimalFormat("#,###,###,###");
private final static NumberFormat nfParser = NumberFormat.getInstance(YamlConfig.config.server.USE_UNITPRICE_WITH_COMMA ? Locale.FRANCE : Locale.UK); private final static NumberFormat nfParser = NumberFormat.getInstance(YamlConfig.config.server.USE_UNITPRICE_WITH_COMMA ? Locale.FRANCE : Locale.UK);
public static final MapleDisease[] CPQ_DISEASES = {MapleDisease.SLOW, MapleDisease.SEDUCE, MapleDisease.STUN, MapleDisease.POISON, public static final Disease[] CPQ_DISEASES = {Disease.SLOW, Disease.SEDUCE, Disease.STUN, Disease.POISON,
MapleDisease.SEAL, MapleDisease.DARKNESS, MapleDisease.WEAKEN, MapleDisease.CURSE}; Disease.SEAL, Disease.DARKNESS, Disease.WEAKEN, Disease.CURSE};
public static final int MAX_FIELD_MOB_DAMAGE = getMaxObstacleMobDamageFromWz() * 2; public static final int MAX_FIELD_MOB_DAMAGE = getMaxObstacleMobDamageFromWz() * 2;

17
src/main/java/net/server/PlayerBuffStorage.java
View File

@@ -21,15 +21,16 @@
*/ */
package net.server; package net.server;
import client.MapleDisease; import client.Disease;
import net.server.audit.locks.MonitoredLockType;
import net.server.audit.locks.factory.MonitoredReentrantLockFactory;
import server.life.MobSkill;
import tools.Pair;
import java.util.HashMap; import java.util.HashMap;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.Lock;
import server.life.MobSkill;
import tools.Pair;
import net.server.audit.locks.MonitoredLockType;
import net.server.audit.locks.factory.MonitoredReentrantLockFactory;
/** /**
* *
@@ -40,7 +41,7 @@ public class PlayerBuffStorage {
private int id = (int) (Math.random() * 100); private int id = (int) (Math.random() * 100);
private final Lock lock = MonitoredReentrantLockFactory.createLock(MonitoredLockType.BUFF_STORAGE, true); private final Lock lock = MonitoredReentrantLockFactory.createLock(MonitoredLockType.BUFF_STORAGE, true);
private Map<Integer, List<PlayerBuffValueHolder>> buffs = new HashMap<>(); private Map<Integer, List<PlayerBuffValueHolder>> buffs = new HashMap<>();
private Map<Integer, Map<MapleDisease, Pair<Long, MobSkill>>> diseases = new HashMap<>(); private Map<Integer, Map<Disease, Pair<Long, MobSkill>>> diseases = new HashMap<>();
public void addBuffsToStorage(int chrid, List<PlayerBuffValueHolder> toStore) { public void addBuffsToStorage(int chrid, List<PlayerBuffValueHolder> toStore) {
lock.lock(); lock.lock();
@@ -60,7 +61,7 @@ public class PlayerBuffStorage {
} }
} }
public void addDiseasesToStorage(int chrid, Map<MapleDisease, Pair<Long, MobSkill>> toStore) { public void addDiseasesToStorage(int chrid, Map<Disease, Pair<Long, MobSkill>> toStore) {
lock.lock(); lock.lock();
try { try {
diseases.put(chrid, toStore); diseases.put(chrid, toStore);
@@ -69,7 +70,7 @@ public class PlayerBuffStorage {
} }
} }
public Map<MapleDisease, Pair<Long, MobSkill>> getDiseasesFromStorage(int chrid) { public Map<Disease, Pair<Long, MobSkill>> getDiseasesFromStorage(int chrid) {
lock.lock(); lock.lock();
try { try {
return diseases.remove(chrid); return diseases.remove(chrid);

6
src/main/java/net/server/PlayerDiseaseValueHolder.java
View File

@@ -20,15 +20,15 @@
*/ */
package net.server; package net.server;
import client.MapleDisease; import client.Disease;
public class PlayerDiseaseValueHolder {//Thanks Celino public class PlayerDiseaseValueHolder {//Thanks Celino
public long startTime; public long startTime;
public long length; public long length;
public MapleDisease disease; public Disease disease;
public PlayerDiseaseValueHolder(final MapleDisease disease, final long startTime, final long length) { public PlayerDiseaseValueHolder(final Disease disease, final long startTime, final long length) {
this.disease = disease; this.disease = disease;
this.startTime = startTime; this.startTime = startTime;
this.length = length; this.length = length;

10
src/main/java/net/server/channel/handlers/CancelDebuffHandler.java
View File

@@ -29,16 +29,16 @@ public final class CancelDebuffHandler extends AbstractPacketHandler {//TIP: BAD
@Override @Override
public final void handlePacket(InPacket p, Client c) { public final void handlePacket(InPacket p, Client c) {
/*List<MapleDisease> diseases = c.getPlayer().getDiseases(); /*List<Disease> diseases = c.getPlayer().getDiseases();
List<MapleDisease> diseases_ = new ArrayList<MapleDisease>(); List<Disease> diseases_ = new ArrayList<Disease>();
for (MapleDisease disease : diseases) { for (Disease disease : diseases) {
List<MapleDisease> disease_ = new ArrayList<MapleDisease>(); List<Disease> disease_ = new ArrayList<Disease>();
disease_.add(disease); disease_.add(disease);
diseases_.add(disease); diseases_.add(disease);
c.sendPacket(PacketCreator.cancelDebuff(disease_)); c.sendPacket(PacketCreator.cancelDebuff(disease_));
c.getPlayer().getMap().broadcastMessage(c.getPlayer(), PacketCreator.cancelForeignDebuff(c.getPlayer().getId(), disease_), false); c.getPlayer().getMap().broadcastMessage(c.getPlayer(), PacketCreator.cancelForeignDebuff(c.getPlayer().getId(), disease_), false);
} }
for (MapleDisease disease : diseases_) { for (Disease disease : diseases_) {
c.getPlayer().removeDisease(disease); c.getPlayer().removeDisease(disease);
}*/ }*/
} }

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

@@ -23,7 +23,7 @@ package net.server.channel.handlers;
import client.Character; import client.Character;
import client.Client; import client.Client;
import client.MapleDisease; import client.Disease;
import net.AbstractPacketHandler; import net.AbstractPacketHandler;
import net.packet.InPacket; import net.packet.InPacket;
import net.server.world.MapleParty; import net.server.world.MapleParty;
@@ -99,7 +99,7 @@ public final class MonsterCarnivalHandler extends AbstractPacketHandler {
c.sendPacket(PacketCreator.enableActions()); c.sendPacket(PacketCreator.enableActions());
return; return;
} }
final MapleDisease dis = skill.getDisease(); final Disease dis = skill.getDisease();
MapleParty enemies = c.getPlayer().getParty().getEnemy(); MapleParty enemies = c.getPlayer().getParty().getEnemy();
if (skill.targetsAll) { if (skill.targetsAll) {
int hitChance = 0; int hitChance = 0;

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

@@ -210,7 +210,7 @@ public final class PlayerLoggedinHandler extends AbstractPacketHandler {
player.silentGiveBuffs(timedBuffs); player.silentGiveBuffs(timedBuffs);
} }
Map<MapleDisease, Pair<Long, MobSkill>> diseases = server.getPlayerBuffStorage().getDiseasesFromStorage(cid); Map<Disease, Pair<Long, MobSkill>> diseases = server.getPlayerBuffStorage().getDiseasesFromStorage(cid);
if (diseases != null) { if (diseases != null) {
player.silentApplyDiseases(diseases); player.silentApplyDiseases(diseases);
} }
@@ -362,8 +362,8 @@ public final class PlayerLoggedinHandler extends AbstractPacketHandler {
} }
if (diseases != null) { if (diseases != null) {
for (Entry<MapleDisease, Pair<Long, MobSkill>> e : diseases.entrySet()) { for (Entry<Disease, Pair<Long, MobSkill>> e : diseases.entrySet()) {
final List<Pair<MapleDisease, Integer>> debuff = Collections.singletonList(new Pair<>(e.getKey(), e.getValue().getRight().getX())); final List<Pair<Disease, Integer>> debuff = Collections.singletonList(new Pair<>(e.getKey(), e.getValue().getRight().getX()));
c.sendPacket(PacketCreator.giveDebuff(debuff, e.getValue().getRight())); c.sendPacket(PacketCreator.giveDebuff(debuff, e.getValue().getRight()));
} }
} }

12
src/main/java/net/server/channel/handlers/UseItemHandler.java
View File

@@ -23,7 +23,7 @@ package net.server.channel.handlers;
import client.Character; import client.Character;
import client.Client; import client.Client;
import client.MapleDisease; import client.Disease;
import client.inventory.InventoryType; import client.inventory.InventoryType;
import client.inventory.Item; import client.inventory.Item;
import client.inventory.manipulator.InventoryManipulator; import client.inventory.manipulator.InventoryManipulator;
@@ -58,17 +58,17 @@ public final class UseItemHandler extends AbstractPacketHandler {
remove(c, slot); remove(c, slot);
return; return;
} else if (itemId == 2050001) { } else if (itemId == 2050001) {
chr.dispelDebuff(MapleDisease.DARKNESS); chr.dispelDebuff(Disease.DARKNESS);
remove(c, slot); remove(c, slot);
return; return;
} else if (itemId == 2050002) { } else if (itemId == 2050002) {
chr.dispelDebuff(MapleDisease.WEAKEN); chr.dispelDebuff(Disease.WEAKEN);
chr.dispelDebuff(MapleDisease.SLOW); chr.dispelDebuff(Disease.SLOW);
remove(c, slot); remove(c, slot);
return; return;
} else if (itemId == 2050003) { } else if (itemId == 2050003) {
chr.dispelDebuff(MapleDisease.SEAL); chr.dispelDebuff(Disease.SEAL);
chr.dispelDebuff(MapleDisease.CURSE); chr.dispelDebuff(Disease.CURSE);
remove(c, slot); remove(c, slot);
return; return;
} else if (ItemConstants.isTownScroll(itemId)) { } else if (ItemConstants.isTownScroll(itemId)) {

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

@@ -70,7 +70,7 @@ public class MapleStatEffect {
private int sourceid; private int sourceid;
private int moveTo; private int moveTo;
private int cp, nuffSkill; private int cp, nuffSkill;
private List<MapleDisease> cureDebuffs; private List<Disease> cureDebuffs;
private boolean skill; private boolean skill;
private List<Pair<BuffStat, Integer>> statups; private List<Pair<BuffStat, Integer>> statups;
private Map<MonsterStatus, Integer> monsterStatus; private Map<MonsterStatus, Integer> monsterStatus;
@@ -183,22 +183,22 @@ public class MapleStatEffect {
ret.prop = iprop / 100.0; ret.prop = iprop / 100.0;
ret.cp = MapleDataTool.getInt("cp", source, 0); ret.cp = MapleDataTool.getInt("cp", source, 0);
List<MapleDisease> cure = new ArrayList<>(5); List<Disease> cure = new ArrayList<>(5);
if (MapleDataTool.getInt("poison", source, 0) > 0) { if (MapleDataTool.getInt("poison", source, 0) > 0) {
cure.add(MapleDisease.POISON); cure.add(Disease.POISON);
} }
if (MapleDataTool.getInt("seal", source, 0) > 0) { if (MapleDataTool.getInt("seal", source, 0) > 0) {
cure.add(MapleDisease.SEAL); cure.add(Disease.SEAL);
} }
if (MapleDataTool.getInt("darkness", source, 0) > 0) { if (MapleDataTool.getInt("darkness", source, 0) > 0) {
cure.add(MapleDisease.DARKNESS); cure.add(Disease.DARKNESS);
} }
if (MapleDataTool.getInt("weakness", source, 0) > 0) { if (MapleDataTool.getInt("weakness", source, 0) > 0) {
cure.add(MapleDisease.WEAKEN); cure.add(Disease.WEAKEN);
cure.add(MapleDisease.SLOW); cure.add(Disease.SLOW);
} }
if (MapleDataTool.getInt("curse", source, 0) > 0) { if (MapleDataTool.getInt("curse", source, 0) > 0) {
cure.add(MapleDisease.CURSE); cure.add(Disease.CURSE);
} }
ret.cureDebuffs = cure; ret.cureDebuffs = cure;
ret.nuffSkill = MapleDataTool.getInt("nuffSkill", source, 0); ret.nuffSkill = MapleDataTool.getInt("nuffSkill", source, 0);
@@ -1038,7 +1038,7 @@ public class MapleStatEffect {
} else if (nuffSkill != 0 && applyto.getParty() != null && applyto.getMap().isCPQMap()) { // added by Drago (Dragohe4rt) } else if (nuffSkill != 0 && applyto.getParty() != null && applyto.getMap().isCPQMap()) { // added by Drago (Dragohe4rt)
final MCSkill skill = MapleCarnivalFactory.getInstance().getSkill(nuffSkill); final MCSkill skill = MapleCarnivalFactory.getInstance().getSkill(nuffSkill);
if (skill != null) { if (skill != null) {
final MapleDisease dis = skill.getDisease(); final Disease dis = skill.getDisease();
MapleParty opposition = applyfrom.getParty().getEnemy(); MapleParty opposition = applyfrom.getParty().getEnemy();
if (skill.targetsAll) { if (skill.targetsAll) {
for (MaplePartyCharacter enemyChrs : opposition.getPartyMembers()) { for (MaplePartyCharacter enemyChrs : opposition.getPartyMembers()) {
@@ -1065,12 +1065,12 @@ public class MapleStatEffect {
} }
} }
} else if (cureDebuffs.size() > 0) { // added by Drago (Dragohe4rt) } else if (cureDebuffs.size() > 0) { // added by Drago (Dragohe4rt)
for (final MapleDisease debuff : cureDebuffs) { for (final Disease debuff : cureDebuffs) {
applyfrom.dispelDebuff(debuff); applyfrom.dispelDebuff(debuff);
} }
} else if (mobSkill > 0 && mobSkillLevel > 0) { } else if (mobSkill > 0 && mobSkillLevel > 0) {
MobSkill ms = MobSkillFactory.getMobSkill(mobSkill, mobSkillLevel); MobSkill ms = MobSkillFactory.getMobSkill(mobSkill, mobSkillLevel);
MapleDisease dis = MapleDisease.getBySkill(mobSkill); Disease dis = Disease.getBySkill(mobSkill);
if (target > 0) { if (target > 0) {
for (Character chr : applyto.getMap().getAllPlayers()) { for (Character chr : applyto.getMap().getAllPlayers()) {
@@ -1347,20 +1347,20 @@ public class MapleStatEffect {
} else { } else {
hpchange += hp; hpchange += hp;
} }
if (applyfrom.hasDisease(MapleDisease.ZOMBIFY)) { if (applyfrom.hasDisease(Disease.ZOMBIFY)) {
hpchange /= 2; hpchange /= 2;
} }
} else { // assumption: this is heal } else { // assumption: this is heal
float hpHeal = (applyfrom.getCurrentMaxHp() * (float) hp / (100.0f * affectedPlayers)); float hpHeal = (applyfrom.getCurrentMaxHp() * (float) hp / (100.0f * affectedPlayers));
hpchange += hpHeal; hpchange += hpHeal;
if (applyfrom.hasDisease(MapleDisease.ZOMBIFY)) { if (applyfrom.hasDisease(Disease.ZOMBIFY)) {
hpchange = -hpchange; hpchange = -hpchange;
hpCon = 0; hpCon = 0;
} }
} }
} }
if (hpR != 0) { if (hpR != 0) {
hpchange += (int) (applyfrom.getCurrentMaxHp() * hpR) / (applyfrom.hasDisease(MapleDisease.ZOMBIFY) ? 2 : 1); hpchange += (int) (applyfrom.getCurrentMaxHp() * hpR) / (applyfrom.hasDisease(Disease.ZOMBIFY) ? 2 : 1);
} }
if (primary) { if (primary) {
if (hpCon != 0) { if (hpCon != 0) {

28
src/main/java/server/life/MobSkill.java
View File

@@ -22,7 +22,7 @@
package server.life; package server.life;
import client.Character; import client.Character;
import client.MapleDisease; import client.Disease;
import client.status.MonsterStatus; import client.status.MonsterStatus;
import constants.game.GameConstants; import constants.game.GameConstants;
import net.server.services.task.channel.OverallService; import net.server.services.task.channel.OverallService;
@@ -118,7 +118,7 @@ public class MobSkill {
} }
public void applyEffect(Character player, MapleMonster monster, boolean skill, List<Character> banishPlayers) { public void applyEffect(Character player, MapleMonster monster, boolean skill, List<Character> banishPlayers) {
MapleDisease disease = null; Disease disease = null;
Map<MonsterStatus, Integer> stats = new ArrayMap<>(); Map<MonsterStatus, Integer> stats = new ArrayMap<>();
List<Integer> reflection = new LinkedList<>(); List<Integer> reflection = new LinkedList<>();
switch (skillId) { switch (skillId) {
@@ -154,25 +154,25 @@ public class MobSkill {
} }
break; break;
case 120: case 120:
disease = MapleDisease.SEAL; disease = Disease.SEAL;
break; break;
case 121: case 121:
disease = MapleDisease.DARKNESS; disease = Disease.DARKNESS;
break; break;
case 122: case 122:
disease = MapleDisease.WEAKEN; disease = Disease.WEAKEN;
break; break;
case 123: case 123:
disease = MapleDisease.STUN; disease = Disease.STUN;
break; break;
case 124: case 124:
disease = MapleDisease.CURSE; disease = Disease.CURSE;
break; break;
case 125: case 125:
disease = MapleDisease.POISON; disease = Disease.POISON;
break; break;
case 126: // Slow case 126: // Slow
disease = MapleDisease.SLOW; disease = Disease.SLOW;
break; break;
case 127: case 127:
if (lt != null && rb != null && skill) { if (lt != null && rb != null && skill) {
@@ -184,7 +184,7 @@ public class MobSkill {
} }
break; break;
case 128: // Seduce case 128: // Seduce
disease = MapleDisease.SEDUCE; disease = Disease.SEDUCE;
break; break;
case 129: // Banish case 129: // Banish
if (lt != null && rb != null && skill) { if (lt != null && rb != null && skill) {
@@ -197,10 +197,10 @@ public class MobSkill {
monster.getMap().spawnMist(new MapleMist(calculateBoundingBox(monster.getPosition()), monster, this), x * 100, false, false, false); monster.getMap().spawnMist(new MapleMist(calculateBoundingBox(monster.getPosition()), monster, this), x * 100, false, false, false);
break; break;
case 132: case 132:
disease = MapleDisease.CONFUSE; disease = Disease.CONFUSE;
break; break;
case 133: // zombify case 133: // zombify
disease = MapleDisease.ZOMBIFY; disease = Disease.ZOMBIFY;
break; break;
case 140: case 140:
if (makeChanceResult() && !monster.isBuffed(MonsterStatus.MAGIC_IMMUNITY)) { if (makeChanceResult() && !monster.isBuffed(MonsterStatus.MAGIC_IMMUNITY)) {
@@ -329,9 +329,9 @@ public class MobSkill {
int i = 0; int i = 0;
for (Character character : getPlayersInRange(monster)) { for (Character character : getPlayersInRange(monster)) {
if (!character.hasActiveBuff(2321005)) { // holy shield if (!character.hasActiveBuff(2321005)) { // holy shield
if (disease.equals(MapleDisease.SEDUCE)) { if (disease.equals(Disease.SEDUCE)) {
if (i < count) { if (i < count) {
character.giveDebuff(MapleDisease.SEDUCE, this); character.giveDebuff(Disease.SEDUCE, this);
i++; i++;
} }
} else { } else {

6
src/main/java/server/partyquest/MapleCarnivalFactory.java
View File

@@ -1,6 +1,6 @@
package server.partyquest; package server.partyquest;
import client.MapleDisease; import client.Disease;
import provider.MapleData; import provider.MapleData;
import provider.MapleDataProvider; import provider.MapleDataProvider;
import provider.MapleDataProviderFactory; import provider.MapleDataProviderFactory;
@@ -97,8 +97,8 @@ public class MapleCarnivalFactory {
return MobSkillFactory.getMobSkill(skillid, level); return MobSkillFactory.getMobSkill(skillid, level);
} }
public MapleDisease getDisease() { public Disease getDisease() {
return MapleDisease.getBySkill(skillid); return Disease.getBySkill(skillid);
} }
} }
} }

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

@@ -2895,10 +2895,10 @@ public class PacketCreator {
return p; return p;
} }
private static void writeLongMaskD(final OutPacket p, List<Pair<MapleDisease, Integer>> statups) { private static void writeLongMaskD(final OutPacket p, List<Pair<Disease, Integer>> statups) {
long firstmask = 0; long firstmask = 0;
long secondmask = 0; long secondmask = 0;
for (Pair<MapleDisease, Integer> statup : statups) { for (Pair<Disease, Integer> statup : statups) {
if (statup.getLeft().isFirst()) { if (statup.getLeft().isFirst()) {
firstmask |= statup.getLeft().getValue(); firstmask |= statup.getLeft().getValue();
} else { } else {
@@ -2909,10 +2909,10 @@ public class PacketCreator {
p.writeLong(secondmask); p.writeLong(secondmask);
} }
public static Packet giveDebuff(List<Pair<MapleDisease, Integer>> statups, MobSkill skill) { public static Packet giveDebuff(List<Pair<Disease, Integer>> statups, MobSkill skill) {
final OutPacket p = OutPacket.create(SendOpcode.GIVE_BUFF); final OutPacket p = OutPacket.create(SendOpcode.GIVE_BUFF);
writeLongMaskD(p, statups); writeLongMaskD(p, statups);
for (Pair<MapleDisease, Integer> statup : statups) { for (Pair<Disease, Integer> statup : statups) {
p.writeShort(statup.getRight().shortValue()); p.writeShort(statup.getRight().shortValue());
p.writeShort(skill.getSkillId()); p.writeShort(skill.getSkillId());
p.writeShort(skill.getSkillLevel()); p.writeShort(skill.getSkillLevel());
@@ -2924,13 +2924,13 @@ public class PacketCreator {
return p; return p;
} }
public static Packet giveForeignDebuff(int chrId, List<Pair<MapleDisease, Integer>> statups, MobSkill skill) { public static Packet giveForeignDebuff(int chrId, List<Pair<Disease, Integer>> statups, MobSkill skill) {
// Poison damage visibility and missing diseases status visibility, extended through map transitions thanks to Ronan // Poison damage visibility and missing diseases status visibility, extended through map transitions thanks to Ronan
OutPacket p = OutPacket.create(SendOpcode.GIVE_FOREIGN_BUFF); OutPacket p = OutPacket.create(SendOpcode.GIVE_FOREIGN_BUFF);
p.writeInt(chrId); p.writeInt(chrId);
writeLongMaskD(p, statups); writeLongMaskD(p, statups);
for (Pair<MapleDisease, Integer> statup : statups) { for (Pair<Disease, Integer> statup : statups) {
if (statup.getLeft() == MapleDisease.POISON) { if (statup.getLeft() == Disease.POISON) {
p.writeShort(statup.getRight().shortValue()); p.writeShort(statup.getRight().shortValue());
} }
p.writeShort(skill.getSkillId()); p.writeShort(skill.getSkillId());
@@ -3040,12 +3040,12 @@ public class PacketCreator {
p.writeLong(0); p.writeLong(0);
} }
public static Packet giveForeignSlowDebuff(int chrId, List<Pair<MapleDisease, Integer>> statups, MobSkill skill) { public static Packet giveForeignSlowDebuff(int chrId, List<Pair<Disease, Integer>> statups, MobSkill skill) {
OutPacket p = OutPacket.create(SendOpcode.GIVE_FOREIGN_BUFF); OutPacket p = OutPacket.create(SendOpcode.GIVE_FOREIGN_BUFF);
p.writeInt(chrId); p.writeInt(chrId);
writeLongMaskSlowD(p); writeLongMaskSlowD(p);
for (Pair<MapleDisease, Integer> statup : statups) { for (Pair<Disease, Integer> statup : statups) {
if (statup.getLeft() == MapleDisease.POISON) { if (statup.getLeft() == Disease.POISON) {
p.writeShort(statup.getRight().shortValue()); p.writeShort(statup.getRight().shortValue());
} }
p.writeShort(skill.getSkillId()); p.writeShort(skill.getSkillId());