Experienced Elementalist
- Joined
- Aug 27, 2008
- Messages
- 256
- Reaction score
- 81
Damage Record system specifically for MapleWorld V75.
Replace Your MapleCharacter.java with this:
Replace Your MapleMonster.java with this:
Screen Shots:
You could also add meso gain, or gaining items for setting certain records. Your choice.
All the things you need to add:
In MapleCharacter.java
Add
Under
Add
under
Add
under
add
under
add
under
add
After
add
after
dont forget to add one of these in values
add
after
Now on to MapleMonster.java
Add
Under
note: Make sure its inside the last bracket
SQL:
Replace Your MapleCharacter.java with this:
Code:
package client;
import client.anticheat.CheatTracker;
import constants.ExpTable;
import constants.ServerConstants;
import constants.skills.Bishop;
import constants.skills.BlazeWizard;
import constants.skills.Corsair;
import constants.skills.Crusader;
import constants.skills.DarkKnight;
import constants.skills.DawnWarrior;
import constants.skills.FPArchMage;
import constants.skills.GM;
import constants.skills.Hermit;
import constants.skills.ILArchMage;
import constants.skills.Magician;
import constants.skills.Marauder;
import constants.skills.Priest;
import constants.skills.Ranger;
import constants.skills.Sniper;
import constants.skills.Spearman;
import constants.skills.SuperGM;
import constants.skills.Swordsman;
import constants.skills.ThunderBreaker;
import java.awt.Point;
import java.lang.ref.WeakReference;
import java.rmi.RemoteException;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.text.DecimalFormat;
import java.text.NumberFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Collection;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TimeZone;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.regex.Pattern;
import net.MaplePacket;
import net.ServerMode;
import net.ServerMode.Mode;
import net.channel.ChannelServer;
import net.world.MapleMessenger;
import net.world.MapleMessengerCharacter;
import net.world.MapleParty;
import net.world.MaplePartyCharacter;
import net.world.PartyOperation;
import net.world.PlayerBuffValueHolder;
import net.world.PlayerCoolDownValueHolder;
import net.world.guild.MapleGuild;
import net.world.guild.MapleGuildCharacter;
import net.world.remote.WorldChannelInterface;
import scripting.event.EventInstanceManager;
import server.MapleInventoryManipulator;
import server.MapleItemInformationProvider;
import server.MapleMiniGame;
import server.MaplePlayerShop;
import server.MaplePortal;
import server.MapleShop;
import server.MapleStatEffect;
import server.MapleStorage;
import server.MapleTrade;
import server.TimerManager;
import server.life.MapleMonster;
import server.life.MobSkill;
import server.maps.AbstractAnimatedMapleMapObject;
import server.maps.HiredMerchant;
import server.maps.MapleDoor;
import server.maps.MapleMap;
import server.maps.MapleMapEffect;
import server.maps.MapleMapFactory;
import server.maps.MapleMapObject;
import server.MapleAchievements;
import server.events.MapleFitness;
import server.events.MapleOla;
import server.maps.MapleMapObjectType;
import server.maps.MapleSummon;
import server.maps.PlayerNPCs;
import server.maps.SavedLocation;
import server.maps.SavedLocationType;
import server.quest.MapleQuest;
import tools.DatabaseConnection;
import tools.MaplePacketCreator;
import tools.Pair;
import server.maps.FakeCharacter;
public class MapleCharacter extends AbstractAnimatedMapleMapObject {
private int world;
private int accountid;
private int rank;
private int rankMove;
private int state;
private int jobRank;
private int jobRankMove;
private int id;
private int level;
private int equipslots;
private int useslots;
private int setupslots;
private int etcslots;
private int str;
private int dex;
private int luk;
private int int_;
private int hp;
private int maxhp;
private int mp;
private int maxmp;
private int hpMpApUsed;
private int hair;
private int face;
private int remainingAp;
private int remainingSp;
private int fame;
private int initialSpawnPoint;
private int mapid;
private int team = 0;
private MapleFitness fitness;
private MapleOla ola;
private int gender;
private int currentPage;
private int currentType = 0;
private int currentTab = 1;
private int chair;
private int itemEffect;
private double sword;
private double blunt;
private double axe;
private double spear;
private double polearm;
private double claw;
private double dagger;
private double staffwand = 0.1;
private double crossbow;
private double bow;
private int skill = 0;
private ISkill skil;
private int maxDis;
private int pvpDeaths = 1;
private int pvpKills = 0;
private int paypalnx;
private int maplepoints;
private int cardnx;
private int guildid;
private int guildrank;
private int allianceRank;
private int messengerposition = 4;
private int slots = 0;
private int energybar;
private int gmLevel;
private int ci = 0;
private int expMod = 1;
private int familyId;
private int bookCover;
private int cygnusLinkId = 0;
private int linkedLevel = 0;
private int markedMonster = 0;
private int battleshipHp = 0;
private int mesosTraded = 0;
private int possibleReports = 10;
private int dojoPoints;
private int vanquisherStage;
private int dojoStage;
private int expRate = 1;
private int mesoRate = 1;
private int dropRate = 1;
private int dojoEnergy;
private int vanquisherKills;
private int warpToId;
private int muteLevel;
private int omokwins;
private int omokties;
private int omoklosses;
private int matchcardwins;
private int matchcardties;
private int matchcardlosses;
private int married;
private int votingpoints;
private long dojoFinish;
private long lastfametime;
private long lastUsedCashItem;
private long lastHealed;
private transient int localmaxhp;
private transient int localmaxmp;
private transient int localstr;
private transient int localdex;
private transient int localluk;
private transient int localint_;
private transient int magic;
private transient int watk;
private transient int wdef, mdef;
private boolean hidden;
private boolean canDoor = true;
private boolean incs;
private boolean inmts;
private boolean whitechat = true;
private boolean Berserk;
private boolean hasMerchant;
private int reborns;
private int damagerecord;
private int creborns;
private boolean watchedCygnusIntro;
private boolean finishedDojoTutorial;
private boolean dojoParty;
private String name;
private String chalktext;
private String search = null;
private AtomicInteger exp = new AtomicInteger();
private AtomicInteger meso = new AtomicInteger();
private BuddyList buddylist;
private EventInstanceManager eventInstance = null;
private HiredMerchant hiredMerchant = null;
private MapleClient client;
private MapleGuildCharacter mgc = null;
private MapleInventory[] inventory;
private MapleOccupations occupation = MapleOccupations.HOBO;
private List<Integer> finishedAchievements = new ArrayList<Integer>();
private transient int localmaxbasedamage;
private MapleJob job = MapleJob.BEGINNER;
private MapleMap map;
private MapleMap dojoMap;
private MapleMessenger messenger = null;
private MapleMiniGame miniGame;
private MapleMount maplemount;
private MapleParty party;
private MaplePet[] pets = new MaplePet[3];
private MaplePlayerShop playerShop = null;
private MapleShop shop = null;
private MapleSkinColor skinColor = MapleSkinColor.NORMAL;
private MapleStorage storage = null;
private MapleTrade trade = null;
private SavedLocation savedLocations[];
private SkillMacro[] skillMacros = new SkillMacro[5];
private List<Integer> lastmonthfameids;
private Map<MapleQuest, MapleQuestStatus> quests;
// anticheat related information
private CheatTracker anticheat;
private Set<MapleMonster> controlled = new LinkedHashSet<MapleMonster>();
private Map<Integer, String> entered = new LinkedHashMap<Integer, String>();
private Set<MapleMapObject> visibleMapObjects = new LinkedHashSet<MapleMapObject>();
private Map<ISkill, SkillEntry> skills = new LinkedHashMap<ISkill, SkillEntry>();
private Map<MapleBuffStat, MapleBuffStatValueHolder> effects = Collections.synchronizedMap(new LinkedHashMap<MapleBuffStat, MapleBuffStatValueHolder>());
private Map<Integer, MapleKeyBinding> keymap = new LinkedHashMap<Integer, MapleKeyBinding>();
private Map<Integer, MapleSummon> summons = new LinkedHashMap<Integer, MapleSummon>();
private Map<Integer, MapleCoolDownValueHolder> coolDowns = new LinkedHashMap<Integer, MapleCoolDownValueHolder>();
private List<MapleDisease> diseases = new ArrayList<MapleDisease>();
private List<MapleDoor> doors = new ArrayList<MapleDoor>();
private ScheduledFuture<?> dragonBloodSchedule;
private ScheduledFuture<?> mapTimeLimitTask = null;
private ScheduledFuture<?> fullnessSchedule;
private ScheduledFuture<?> fullnessSchedule_1;
private ScheduledFuture<?> fullnessSchedule_2;
private ScheduledFuture<?> hpDecreaseTask;
private ScheduledFuture<?> beholderHealingSchedule;
private ScheduledFuture<?> beholderBuffSchedule;
private ScheduledFuture<?> BerserkSchedule;
private NumberFormat nf = new DecimalFormat("#,###,###,###");
private static List<Pair<Byte, Integer>> inventorySlots = new ArrayList<Pair<Byte, Integer>>();
private ArrayList<String> commands = new ArrayList<String>();
private ArrayList<Integer> excluded = new ArrayList<Integer>();
private MonsterBook monsterbook;
private List<Integer> wishList = new ArrayList<Integer>();
private List<MapleRing> crushRings = new ArrayList<MapleRing>();
private List<MapleRing> friendshipRings = new ArrayList<MapleRing>();
private List<MapleRing> marriageRings = new ArrayList<MapleRing>();
private static String[] ariantroomleader = new String[3];
private static int[] ariantroomslot = new int[3];
private boolean isFake = false;
private List<FakeCharacter> fakes = new ArrayList<FakeCharacter>();
private long lastGMMessage = 0;
private long useTime = 0;
public boolean warned = false;
public boolean warned2 = false;
public boolean warned3 = false;
public boolean warned4 = false;
public boolean warned6 = false;
public boolean warned9 = false;
public boolean[] warning = new boolean[25];
public boolean warned10 = false;
public MapleCharacter() {
setStance(0);
inventory = new MapleInventory[MapleInventoryType.values().length];
savedLocations = new SavedLocation[SavedLocationType.values().length];
for (MapleInventoryType type : MapleInventoryType.values()) {
inventory[type.ordinal()] = new MapleInventory(type);
}
for (int i = 0; i < SavedLocationType.values().length; i++) {
savedLocations[i] = null;
}
quests = new LinkedHashMap<MapleQuest, MapleQuestStatus>();
anticheat = new CheatTracker(this);
setPosition(new Point(0, 0));
}
public static MapleCharacter getDefault(MapleClient c) {
MapleCharacter ret = new MapleCharacter();
ret.client = c;
ret.gmLevel = c.gmLevel();
ret.hp = 50;
ret.maxhp = 50;
ret.mp = 5;
ret.maxmp = 5;
ret.str = 4;
ret.dex = 4;
ret.int_ = 4;
ret.luk = 4;
ret.remainingAp = 9;
ret.equipslots = 96;
ret.useslots = 96;
ret.setupslots = 96;
ret.etcslots = 96;
ret.map = null;
ret.job = MapleJob.BEGINNER;
ret.occupation = MapleOccupations.HOBO;
ret.level = 1;
ret.reborns = 0;
ret.damagerecord = 0;
ret.creborns = 0;
ret.muteLevel = -1;
ret.accountid = c.getAccID();
ret.buddylist = new BuddyList(100);
try {
PreparedStatement ps = DatabaseConnection.getConnection().prepareStatement("SELECT name, paypalNX, mPoints, cardNX FROM accounts WHERE id = ?");
ps.setInt(1, ret.accountid);
ResultSet rs = ps.executeQuery();
if (rs.next()) {
ret.client.setAccountName(rs.getString("name"));
ret.paypalnx = rs.getInt("paypalNX");
ret.maplepoints = rs.getInt("mPoints");
ret.cardnx = rs.getInt("cardNX");
}
rs.close();
ps.close();
} catch (Exception e) {
}
ret.maplemount = null;
int[] key = {18, 65, 2, 23, 3, 4, 5, 6, 16, 17, 19, 25, 26, 27, 31, 34, 35, 37, 38, 40, 43, 44, 45, 46, 50, 56, 59, 60, 61, 62, 63, 64, 57, 48, 29, 7, 24, 33, 41};
int[] type = {4, 6, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 4, 4, 5, 6, 6, 6, 6, 6, 6, 5, 4, 5, 4, 4, 4, 4};
int[] action = {0, 106, 10, 1, 12, 13, 18, 24, 8, 5, 4, 19, 14, 15, 2, 17, 11, 3, 20, 16, 9, 50, 51, 6, 7, 53, 100, 101, 102, 103, 104, 105, 54, 22, 52, 21, 25, 26, 23};
for (int i = 0; i < key.length; i++) {
ret.keymap.put(key[i], new MapleKeyBinding(type[i], action[i]));
}
return ret;
}
public void addCooldown(int skillId, long startTime, long length, ScheduledFuture<?> timer) {
if (this.coolDowns.containsKey(Integer.valueOf(skillId))) {
this.coolDowns.remove(skillId);
}
this.coolDowns.put(Integer.valueOf(skillId), new MapleCoolDownValueHolder(skillId, startTime, length, timer));
}
public void addCommandToList(String command) {
commands.add(command);
}
public void addCrushRing(MapleRing r) {
crushRings.add(r);
}
public int addDojoPointsByMap() {
int pts = 0;
if (dojoPoints < 17000) {
pts = 1 + ((getMap().getId() - 1) / 100 % 100) / 6;
if (!dojoParty) {
pts++;
}
this.dojoPoints += pts;
}
return pts;
}
public void addDoor(MapleDoor door) {
doors.add(door);
}
public void addExcluded(int x) {
excluded.add(x);
}
public void addFame(int famechange) {
this.fame += famechange;
}
public void addFriendshipRing(MapleRing r) {
friendshipRings.add(r);
}
public void addHP(int delta) {
setHp(hp + delta);
updateSingleStat(MapleStat.HP, hp);
}
public CheatTracker getCheatTracker() {
return anticheat;
}
public void addMarriageRing(MapleRing r) {
marriageRings.add(r);
}
public void addMesosTraded(int gain) {
this.mesosTraded += gain;
}
public void addMP(int delta) {
setMp(mp + delta);
updateSingleStat(MapleStat.MP, mp);
}
public void addMPHP(int hpDiff, int mpDiff) {
setHp(hp + hpDiff);
setMp(mp + mpDiff);
updateSingleStat(MapleStat.HP, getHp());
updateSingleStat(MapleStat.MP, getMp());
}
public void addPet(MaplePet pet) {
for (int i = 0; i < 3; i++) {
if (pets[i] == null) {
pets[i] = pet;
return;
}
}
}
public void addStat(int type, int up) {
if (type == 1) {
this.str += up;
updateSingleStat(MapleStat.STR, str);
} else if (type == 2) {
this.dex += up;
updateSingleStat(MapleStat.DEX, dex);
} else if (type == 3) {
this.int_ += up;
updateSingleStat(MapleStat.INT, int_);
} else if (type == 4) {
this.luk += up;
updateSingleStat(MapleStat.LUK, luk);
}
}
public void addSummon(int id, MapleSummon summon) {
summons.put(id, summon);
}
public void addToWishList(int sn) {
wishList.add(sn);
}
public void addVisibleMapObject(MapleMapObject mo) {
visibleMapObjects.add(mo);
}
public void ban(String reason, boolean dc) {
if (!client.isGuest()) {
try {
client.banMacs();
Connection con = DatabaseConnection.getConnection();
PreparedStatement ps = con.prepareStatement("UPDATE accounts SET banned = 1, banreason = ? WHERE id = ?");
ps.setString(1, reason);
ps.setInt(2, accountid);
ps.executeUpdate();
ps.close();
ps = con.prepareStatement("INSERT INTO ipbans VALUES (DEFAULT, ?)");
ps.setString(1, client.getSession().getRemoteAddress().toString().split(":")[0]);
ps.executeUpdate();
ps.close();
} catch (Exception e) {
}
client.disconnect();
}
}
public static boolean unban(String name) {
try {
int accountid = -1;
Connection con = DatabaseConnection.getConnection();
PreparedStatement ps = con.prepareStatement("SELECT accountid FROM characters WHERE name = ?");
ps.setString(1, name);
ResultSet rs = ps.executeQuery();
if (rs.next()) {
accountid = rs.getInt("accountid");
}
ps.close();
rs.close();
if (accountid == -1) {
return false;
}
ps = con.prepareStatement("UPDATE accounts SET banned = -1 WHERE id = ?");
ps.setInt(1, accountid);
ps.executeUpdate();
ps.close();
} catch (SQLException e) {
return false;
}
return true;
}
public static boolean ban(String id, String reason, boolean accountId) {
PreparedStatement ps = null;
try {
Connection con = DatabaseConnection.getConnection();
if (id.matches("/[0-9]{1,3}\\..*")) {
ps = con.prepareStatement("INSERT INTO ipbans VALUES (DEFAULT, ?)");
ps.setString(1, id);
ps.executeUpdate();
ps.close();
return true;
}
if (accountId) {
ps = con.prepareStatement("SELECT id FROM accounts WHERE name = ?");
} else {
ps = con.prepareStatement("SELECT accountid FROM characters WHERE name = ?");
}
boolean ret = false;
ps.setString(1, id);
ResultSet rs = ps.executeQuery();
if (rs.next()) {
PreparedStatement psb = DatabaseConnection.getConnection().prepareStatement("UPDATE accounts SET banned = 1, banreason = ? WHERE id = ?");
psb.setString(1, reason);
psb.setInt(2, rs.getInt(1));
psb.executeUpdate();
psb.close();
ret = true;
}
rs.close();
ps.close();
return ret;
} catch (SQLException ex) {
} finally {
try {
if (ps != null && !ps.isClosed()) {
ps.close();
}
} catch (SQLException e) {
}
}
return false;
}
public int calculateMaxBaseDamage(int watk) {
int maxbasedamage;
if (watk == 0) {
maxbasedamage = 1;
} else {
IItem weapon_item = getInventory(MapleInventoryType.EQUIPPED).getItem((byte) -11);
if (weapon_item != null) {
MapleWeaponType weapon = MapleItemInformationProvider.getInstance().getWeaponType(weapon_item.getItemId());
int mainstat;
int secondarystat;
if (weapon == MapleWeaponType.BOW || weapon == MapleWeaponType.CROSSBOW) {
mainstat = localdex;
secondarystat = localstr;
} else if ((getJob().isA(MapleJob.THIEF) || getJob().isA(MapleJob.NIGHTWALKER1)) && (weapon == MapleWeaponType.CLAW || weapon == MapleWeaponType.DAGGER)) {
mainstat = localluk;
secondarystat = localdex + localstr;
} else {
mainstat = localstr;
secondarystat = localdex;
}
maxbasedamage = (int) (((weapon.getMaxDamageMultiplier() * mainstat + secondarystat) / 100.0) * watk) + 10;
} else {
maxbasedamage = 0;
}
}
return maxbasedamage;
}
public void cancelAllBuffs() {
for (MapleBuffStatValueHolder mbsvh : new ArrayList<MapleBuffStatValueHolder>(effects.values())) {
cancelEffect(mbsvh.effect, false, mbsvh.startTime);
}
}
public void cancelBuffStats(MapleBuffStat stat) {
List<MapleBuffStat> buffStatList = Arrays.asList(stat);
deregisterBuffStats(buffStatList);
cancelPlayerBuffs(buffStatList);
}
public int getExpMod() {
return expMod;
}
public int getReborns() {
return reborns;
}
public int getDamageRecord() {
return damagerecord;
}
public void setReborns(int amt) {
reborns = amt;
}
public void setDamageRecord(int amt) {
damagerecord = amt;
}
public void setCReborns(int amt) {
creborns = amt;
}
public int getCReborns() {
return creborns;
}
public ChannelServer cserv;
public void doCReborn() {
int Reborns = getReborns();
int CReborns = getCReborns() + 1;
int TotalReborns = Reborns + CReborns;
int Ap = Reborns * 250;
int CAp = CReborns * 100;
int TotalAp = Ap + CAp;
int Hp = Reborns * 1000;
int Mp = Reborns * 1000;
int MaxHp = Reborns * 1000;
int MaxMp = Reborns * 1000;
setCReborns(getCReborns() + 1);
setLevel(1);
setExp(0);
setHp(Hp);
setMp(Mp);
setMaxHp(MaxHp);
setMaxMp(MaxMp);
setStr(4);
setDex(4);
setInt(4);
setLuk(4);
setRemainingAp(TotalAp);
setRemainingSp(0);
setJob(MapleJob.NOBLESSE);
updateSingleStat(MapleStat.LEVEL, 1);
updateSingleStat(MapleStat.EXP, 0);
updateSingleStat(MapleStat.HP, Hp);
updateSingleStat(MapleStat.MP, Mp);
updateSingleStat(MapleStat.MAXHP, MaxHp);
updateSingleStat(MapleStat.MAXMP, MaxMp);
updateSingleStat(MapleStat.STR, 4);
updateSingleStat(MapleStat.DEX, 4);
updateSingleStat(MapleStat.INT, 4);
updateSingleStat(MapleStat.LUK, 4);
updateSingleStat(MapleStat.AVAILABLEAP, TotalAp);
updateSingleStat(MapleStat.AVAILABLESP, 0);
updateSingleStat(MapleStat.JOB, 0);
dropMessage("Congratulations! now you have " + TotalAp + " extra stats to raise, and " + Hp + " Hp/Mp!");
MaplePacket packet = MaplePacketCreator.serverNotice(6, "congratulations to " + getName() + " on his " + TotalReborns + " Reborn!");
try {
getClient().getChannelServer().getWorldInterface().broadcastMessage(getName(), packet.getBytes());
} catch (RemoteException e) {
getClient().getChannelServer().reconnectWorld();
}
}
public void doReborn() {
int Reborns = getReborns() + 1;
int CReborns = getCReborns();
int TotalReborns = Reborns + CReborns;
int Ap = Reborns * 250;
int CAp = CReborns * 100;
int TotalAp = Ap + CAp;
int Hp = TotalReborns * 1000;
int Mp = TotalReborns * 1000;
int MaxHp = TotalReborns * 1000;
int MaxMp = TotalReborns * 1000;
setReborns(getReborns() + 1);
setLevel(1);
setExp(0);
setHp(Hp);
setMp(Mp);
setMaxHp(MaxHp);
setMaxMp(MaxMp);
setStr(4);
setDex(4);
setInt(4);
setLuk(4);
setRemainingAp(TotalAp);
setRemainingSp(0);
setJob(MapleJob.BEGINNER);
updateSingleStat(MapleStat.LEVEL, 1);
updateSingleStat(MapleStat.EXP, 0);
updateSingleStat(MapleStat.HP, Hp);
updateSingleStat(MapleStat.MP, Mp);
updateSingleStat(MapleStat.MAXHP, MaxHp);
updateSingleStat(MapleStat.MAXMP, MaxMp);
updateSingleStat(MapleStat.STR, 4);
updateSingleStat(MapleStat.DEX, 4);
updateSingleStat(MapleStat.INT, 4);
updateSingleStat(MapleStat.LUK, 4);
updateSingleStat(MapleStat.AVAILABLEAP, TotalAp);
updateSingleStat(MapleStat.AVAILABLESP, 0);
updateSingleStat(MapleStat.JOB, 0);
dropMessage("Congratulations! now you have " + TotalAp + " extra stats to raise, and " + Hp + " Hp/Mp!");
MaplePacket packet = MaplePacketCreator.serverNotice(6, "congratulations to " + getName() + " on his " + TotalReborns + " Reborn!");
try {
getClient().getChannelServer().getWorldInterface().broadcastMessage(getName(), packet.getBytes());
} catch (RemoteException e) {
getClient().getChannelServer().reconnectWorld();
}
}
public int getGMLevel() {
return gmLevel;
}
public boolean hasGmLevel(int level) {
return gmLevel >= level;
}
public long getLastGMMessage() {
return lastGMMessage;
}
public void setLastGMMessage(long newtime) {
this.lastGMMessage = newtime;
}
public long getUseTime() {
return useTime;
}
public void setUseTime(long lolnewtime) {
this.useTime = lolnewtime;
}
public boolean isFake() {
return isFake;
}
public void setIsFake(boolean newvalue) {
this.isFake = newvalue;
}
public void gainMeso(int gain, boolean show, boolean enableActions) {
gainMeso(gain, show, enableActions, false);
}
public void handleOrbgain() {
MapleStatEffect ceffect = null;
int advComboSkillLevel = getSkillLevel(SkillFactory.getSkill(1120003));
if (advComboSkillLevel > 0) {
ceffect = SkillFactory.getSkill(1120003).getEffect(advComboSkillLevel);
} else {
ceffect = SkillFactory.getSkill(1111002).getEffect(getSkillLevel(SkillFactory.getSkill(1111002)));
}
if (getBuffedValue(MapleBuffStat.COMBO) < ceffect.getX() + 1) {
int neworbcount = getBuffedValue(MapleBuffStat.COMBO) + 1;
if (advComboSkillLevel > 0 && ceffect.makeChanceResult()) {
if (neworbcount < ceffect.getX() + 1) {
neworbcount++;
}
}
List<Pair<MapleBuffStat, Integer>> stat = Collections.singletonList(new Pair<MapleBuffStat, Integer>(MapleBuffStat.COMBO, neworbcount));
setBuffedValue(MapleBuffStat.COMBO, neworbcount);
int duration = ceffect.getDuration();
duration += (int) ((getBuffedStarttime(MapleBuffStat.COMBO) - System.currentTimeMillis()));
getClient().getSession().write(MaplePacketCreator.giveBuff(1111002, duration, stat));
getMap().broadcastMessage(this, MaplePacketCreator.giveForeignBuff(getId(), stat, ceffect), false);
}
}
public boolean isDead() {
return this.hp <= 0;
}
public void clearSavedLocation(SavedLocationType type) {
savedLocations[type.ordinal()] = null;
}
public void unstuck() {
client.getSession().close(true);
try {
Connection con = DatabaseConnection.getConnection();
PreparedStatement ps = con.prepareStatement("UPDATE accounts SET loggedin = ? WHERE id = ?");
ps.setInt(1, 0);
ps.setInt(2, id);
ps.executeUpdate();
ps.close();
} catch (SQLException ex) {
return;
}
}
public void changeMap(int map) {
changeMap(map, 0);
}
public void changeMap(int map, int portal) {
MapleMap warpMap = client.getChannelServer().getMapFactory().getMap(map);
changeMap(warpMap, warpMap.getPortal(portal));
}
public static class CancelCooldownAction implements Runnable {
private int skillId;
private WeakReference<MapleCharacter> target;
public CancelCooldownAction(MapleCharacter target, int skillId) {
this.target = new WeakReference<MapleCharacter>(target);
this.skillId = skillId;
}
@Override
public void run() {
MapleCharacter realTarget = target.get();
if (realTarget != null) {
realTarget.removeCooldown(skillId);
realTarget.client.getSession().write(MaplePacketCreator.skillCooldown(skillId, 0));
}
}
}
public void setID(int id) {
this.id = id;
}
public void setJob(int job) {
this.job = MapleJob.getById(job);
}
public void setInventory(MapleInventoryType type, MapleInventory inv) {
inventory[type.ordinal()] = inv;
}
public boolean hasFakeChar() {
for (FakeCharacter ch : fakes) {
if (ch != null) {
return true;
}
}
return false;
}
public List<FakeCharacter> getFakeChars() {
return fakes;
}
public void addFakeChar(FakeCharacter f) {
fakes.add(f);
}
public void cancelEffect(MapleStatEffect effect, boolean overwrite, long startTime) {
List<MapleBuffStat> buffstats;
if (!overwrite) {
buffstats = getBuffStats(effect, startTime);
} else {
List<Pair<MapleBuffStat, Integer>> statups = effect.getStatups();
buffstats = new ArrayList<MapleBuffStat>(statups.size());
for (Pair<MapleBuffStat, Integer> statup : statups) {
buffstats.add(statup.getLeft());
}
}
deregisterBuffStats(buffstats);
if (effect.isMagicDoor()) {
if (!getDoors().isEmpty()) {
MapleDoor door = getDoors().iterator().next();
for (MapleCharacter chr : door.getTarget().getCharacters()) {
door.sendDestroyData(chr.client);
}
for (MapleCharacter chr : door.getTown().getCharacters()) {
door.sendDestroyData(chr.client);
}
for (MapleDoor destroyDoor : getDoors()) {
door.getTarget().removeMapObject(destroyDoor);
door.getTown().removeMapObject(destroyDoor);
}
clearDoors();
silentPartyUpdate();
}
}
if (effect.getSourceId() == Spearman.HYPER_BODY || effect.getSourceId() == GM.HYPER_BODY || effect.getSourceId() == SuperGM.HYPER_BODY) {
List<Pair<MapleStat, Integer>> statup = new ArrayList<Pair<MapleStat, Integer>>(4);
statup.add(new Pair<MapleStat, Integer>(MapleStat.HP, Math.min(hp, maxhp)));
statup.add(new Pair<MapleStat, Integer>(MapleStat.MP, Math.min(mp, maxhp)));
statup.add(new Pair<MapleStat, Integer>(MapleStat.MAXHP, maxhp));
statup.add(new Pair<MapleStat, Integer>(MapleStat.MAXMP, maxmp));
client.getSession().write(MaplePacketCreator.updatePlayerStats(statup));
}
if (effect.isMonsterRiding()) {
if (effect.getSourceId() != Corsair.BATTLE_SHIP) {
this.getMount().cancelSchedule();
this.getMount().setActive(false);
}
}
if (!overwrite) {
cancelPlayerBuffs(buffstats);
if (effect.isHide() && (MapleCharacter) getMap().getMapObject(getObjectId()) != null) {
this.hidden = false;
getMap().broadcastNONGMMessage(this, MaplePacketCreator.spawnPlayerMapobject(this), false);
for (int i = 0; i < 3; i++) {
if (pets[i] != null) {
getMap().broadcastNONGMMessage(this, MaplePacketCreator.showPet(this, pets[i], false, false), false);
} else {
break;
}
}
}
}
}
public int getTeam() {
return team;
}
public void setTeam(int team) {
this.team = team;
}
public MapleOla getOla() {
return ola;
}
public void setOla(MapleOla ola) {
this.ola = ola;
}
public MapleFitness getFitness() {
return fitness;
}
public void setFitness(MapleFitness fit) {
this.fitness = fit;
}
public void cancelEffectFromBuffStat(MapleBuffStat stat) {
cancelEffect(effects.get(stat).effect, false, -1);
}
private void cancelFullnessSchedule(int petSlot) {
switch (petSlot) {
case 0:
if (fullnessSchedule != null) {
fullnessSchedule.cancel(false);
}
break;
case 1:
if (fullnessSchedule_1 != null) {
fullnessSchedule_1.cancel(false);
}
break;
case 2:
if (fullnessSchedule_2 != null) {
fullnessSchedule_2.cancel(false);
}
break;
}
}
public void cancelMagicDoor() {
for (MapleBuffStatValueHolder mbsvh : new ArrayList<MapleBuffStatValueHolder>(effects.values())) {
if (mbsvh.effect.isMagicDoor()) {
cancelEffect(mbsvh.effect, false, mbsvh.startTime);
}
}
}
public void cancelMapTimeLimitTask() {
if (mapTimeLimitTask != null) {
mapTimeLimitTask.cancel(false);
}
}
private void cancelPlayerBuffs(List<MapleBuffStat> buffstats) {
if (client.getChannelServer().getPlayerStorage().getCharacterById(getId()) != null) {
recalcLocalStats();
enforceMaxHpMp();
client.getSession().write(MaplePacketCreator.cancelBuff(buffstats));
getMap().broadcastMessage(this, MaplePacketCreator.cancelForeignBuff(getId(), buffstats), false);
}
}
public static boolean canCreateChar(String name) {
if (name.length() < 4 || name.length() > 12) {
return false;
}
return getIdByName(name) < 0 && !name.toLowerCase().contains("gm") && Pattern.compile("[a-zA-Z0-9_-]{3,12}").matcher(name).matches();
}
public boolean canDoor() {
return canDoor;
}
public FameStatus canGiveFame(MapleCharacter from) {
if (gmLevel > 1) {
return FameStatus.OK;
} else if (lastfametime >= System.currentTimeMillis() - 3600000 * 24) {
return FameStatus.NOT_TODAY;
} else if (lastmonthfameids.contains(Integer.valueOf(from.getId()))) {
return FameStatus.NOT_THIS_MONTH;
} else {
return FameStatus.OK;
}
}
public void changeCI(int type) {
this.ci = type;
}
public void changeJob(MapleJob newJob) {
this.job = newJob;
this.remainingSp++;
if (newJob.getId() % 10 == 2) {
this.remainingSp += 2;
}
if (newJob.getId() % 10 > 1) {
this.remainingAp += 5;
}
int job_ = job.getId() % 1000; // lame temp "fix"
if (job_ == 100) {
maxhp += rand(200, 250);
} else if (job_ == 200) {
maxmp += rand(100, 150);
} else if (job_ % 100 == 0) {
maxhp += rand(100, 150);
maxhp += rand(25, 50);
} else if (job_ > 0 && job_ < 200) {
maxhp += rand(300, 350);
} else if (job_ < 300) {
maxmp += rand(450, 500);
} //handle KoC here (undone)
else if (job_ > 0 && job_ != 1000) {
maxhp += rand(300, 350);
maxmp += rand(150, 200);
}
if (maxhp >= 30000) {
maxhp = 30000;
}
if (maxmp >= 30000) {
maxmp = 30000;
}
if (!isGM()) {
MapleInventory inv;
for (byte i = 1; i < 5; i++) {
inv = getInventory(MapleInventoryType.getByType(i));
if (rand(1, 2) < 2 && inv.getSlotLimit() < 96) {
inv.increaseSlotLimit((byte) 4);
}
}
}
List<Pair<MapleStat, Integer>> statup = new ArrayList<Pair<MapleStat, Integer>>(5);
statup.add(new Pair<MapleStat, Integer>(MapleStat.MAXHP, Integer.valueOf(maxhp)));
statup.add(new Pair<MapleStat, Integer>(MapleStat.MAXMP, Integer.valueOf(maxmp)));
statup.add(new Pair<MapleStat, Integer>(MapleStat.AVAILABLEAP, remainingAp));
statup.add(new Pair<MapleStat, Integer>(MapleStat.AVAILABLESP, remainingSp));
statup.add(new Pair<MapleStat, Integer>(MapleStat.JOB, Integer.valueOf(job.getId())));
recalcLocalStats();
client.getSession().write(MaplePacketCreator.updatePlayerStats(statup));
silentPartyUpdate();
guildUpdate();
getMap().broadcastMessage(this, MaplePacketCreator.showForeignEffect(getId(), 8), false);
}
public void changeKeybinding(int key, MapleKeyBinding keybinding) {
if (keybinding.getType() != 0) {
keymap.put(Integer.valueOf(key), keybinding);
} else {
keymap.remove(Integer.valueOf(key));
}
}
public void changeMap(MapleMap to) {
changeMap(to, to.getPortal(0));
}
public void changeMap(final MapleMap to, final MaplePortal pto) {
if (to.getId() == 100000200 || to.getId() == 211000100 || to.getId() == 220000300) {
changeMapInternal(to, pto.getPosition(), MaplePacketCreator.getWarpToMap(to, pto.getId() - 2, this));
} else {
changeMapInternal(to, pto.getPosition(), MaplePacketCreator.getWarpToMap(to, pto.getId(), this));
}
}
public void changeMap(final MapleMap to, final Point pos) {
changeMapInternal(to, pos, MaplePacketCreator.getWarpToMap(to, 0x80, this));
}
public void changeMapBanish(int mapid, String portal, String msg) {
dropMessage(5, msg);
MapleMap map_ = ChannelServer.getInstance(client.getChannel()).getMapFactory().getMap(mapid);
changeMap(map_, map_.getPortal(portal));
}
private void changeMapInternal(final MapleMap to, final Point pos, MaplePacket warpPacket) {
warpPacket.setOnSend(new Runnable() {
@Override
public void run() {
map.removePlayer(MapleCharacter.this);
if (client.getChannelServer().getPlayerStorage().getCharacterById(getId()) != null) {
map = to;
setPosition(pos);
map.addPlayer(MapleCharacter.this);
if (party != null) {
silentPartyUpdate();
client.getSession().write(MaplePacketCreator.updateParty(client.getChannel(), party, PartyOperation.SILENT_UPDATE, null));
updatePartyMemberHP();
}
if (getMap().getHPDec() > 0) {
hpDecreaseTask = TimerManager.getInstance().schedule(new Runnable() {
@Override
public void run() {
doHurtHp();
}
}, 10000);
}
}
}
});
if (hasFakeChar()) {
for (FakeCharacter ch : getFakeChars()) {
ch.getFakeChar().getMap().removePlayer(ch.getFakeChar());
}
}
client.getSession().write(warpPacket);
}
public void changePage(int page) {
this.currentPage = page;
}
public void changeSkillLevel(ISkill skill, int newLevel, int newMasterlevel) {
skills.put(skill, new SkillEntry(newLevel, newMasterlevel));
this.client.getSession().write(MaplePacketCreator.updateSkill(skill.getId(), newLevel, newMasterlevel));
}
public void changeTab(int tab) {
this.currentTab = tab;
}
public void changeType(int type) {
this.currentType = type;
}
public void checkBerserk() {
if (BerserkSchedule != null) {
BerserkSchedule.cancel(false);
}
final MapleCharacter chr = this;
if (job.equals(MapleJob.DARKKNIGHT)) {
ISkill BerserkX = SkillFactory.getSkill(DarkKnight.BERSERK);
final int skilllevel = getSkillLevel(BerserkX);
if (skilllevel > 0) {
Berserk = chr.getHp() * 100 / chr.getMaxHp() < BerserkX.getEffect(skilllevel).getX();
BerserkSchedule = TimerManager.getInstance().register(new Runnable() {
@Override
public void run() {
client.getSession().write(MaplePacketCreator.showOwnBerserk(skilllevel, Berserk));
getMap().broadcastMessage(MapleCharacter.this, MaplePacketCreator.showBerserk(getId(), skilllevel, Berserk), false);
}
}, 5000, 3000);
}
}
}
public void checkMessenger() {
if (messenger != null && messengerposition < 4 && messengerposition > -1) {
try {
WorldChannelInterface wci = ChannelServer.getInstance(client.getChannel()).getWorldInterface();
wci.silentJoinMessenger(messenger.getId(), new MapleMessengerCharacter(this, messengerposition), messengerposition);
wci.updateMessenger(getMessenger().getId(), name, client.getChannel());
} catch (Exception e) {
client.getChannelServer().reconnectWorld();
}
}
}
public void checkMonsterAggro(MapleMonster monster) {
if (!monster.isControllerHasAggro()) {
if (monster.getController() == this) {
monster.setControllerHasAggro(true);
} else {
monster.switchController(this, true);
}
}
}
public void clearDoors() {
doors.clear();
}
public void clearWishList() {
wishList.clear();
}
public void controlMonster(MapleMonster monster, boolean aggro) {
monster.setController(this);
controlled.add(monster);
client.getSession().write(MaplePacketCreator.controlMonster(monster, false, aggro));
}
public int countItem(int itemid) {
return inventory[MapleItemInformationProvider.getInstance().getInventoryType(itemid).ordinal()].countById(itemid);
}
public void decreaseBattleshipHp(int decrease) {
this.battleshipHp -= decrease;
if (battleshipHp <= 0) {
this.battleshipHp = 0;
ISkill battleship = SkillFactory.getSkill(Corsair.BATTLE_SHIP);
int cooldown = battleship.getEffect(getSkillLevel(battleship)).getCooldown();
getClient().getSession().write(MaplePacketCreator.skillCooldown(Corsair.BATTLE_SHIP, cooldown));
addCooldown(Corsair.BATTLE_SHIP, System.currentTimeMillis(), cooldown * 1000, TimerManager.getInstance().schedule(new CancelCooldownAction(this, Corsair.BATTLE_SHIP), cooldown * 1000));
cancelEffectFromBuffStat(MapleBuffStat.MONSTER_RIDING);
resetBattleshipHp();
}
}
public void decreaseReports() {
this.possibleReports--;
}
public void deleteGuild(int guildId) {
try {
Connection con = DatabaseConnection.getConnection();
PreparedStatement ps = con.prepareStatement("UPDATE characters SET guildid = 0, guildrank = 5 WHERE guildid = ?");
ps.setInt(1, guildId);
ps.execute();
ps.close();
ps = con.prepareStatement("DELETE FROM guilds WHERE guildid = ?");
ps.setInt(1, id);
ps.execute();
ps.close();
} catch (SQLException ex) {
System.out.print("Error deleting guild: " + ex);
}
}
private void deleteWhereCharacterId(Connection con, String sql) throws SQLException {
PreparedStatement ps = con.prepareStatement(sql);
ps.setInt(1, id);
ps.executeUpdate();
ps.close();
}
private void deregisterBuffStats(List<MapleBuffStat> stats) {
synchronized (stats) {
List<MapleBuffStatValueHolder> effectsToCancel = new ArrayList<MapleBuffStatValueHolder>(stats.size());
for (MapleBuffStat stat : stats) {
MapleBuffStatValueHolder mbsvh = effects.get(stat);
if (mbsvh != null) {
effects.remove(stat);
boolean addMbsvh = true;
for (MapleBuffStatValueHolder contained : effectsToCancel) {
if (mbsvh.startTime == contained.startTime && contained.effect == mbsvh.effect) {
addMbsvh = false;
}
}
if (addMbsvh) {
effectsToCancel.add(mbsvh);
}
if (stat == MapleBuffStat.SUMMON || stat == MapleBuffStat.PUPPET) {
int summonId = mbsvh.effect.getSourceId();
MapleSummon summon = summons.get(summonId);
if (summon != null) {
getMap().broadcastMessage(MaplePacketCreator.removeSpecialMapObject(summon, true), summon.getPosition());
getMap().removeMapObject(summon);
removeVisibleMapObject(summon);
summons.remove(summonId);
}
if (summon.getSkill() == DarkKnight.BEHOLDER) {
if (beholderHealingSchedule != null) {
beholderHealingSchedule.cancel(false);
beholderHealingSchedule = null;
}
if (beholderBuffSchedule != null) {
beholderBuffSchedule.cancel(false);
beholderBuffSchedule = null;
}
}
} else if (stat == MapleBuffStat.DRAGONBLOOD) {
dragonBloodSchedule.cancel(false);
dragonBloodSchedule = null;
}
}
}
for (MapleBuffStatValueHolder cancelEffectCancelTasks : effectsToCancel) {
if (getBuffStats(cancelEffectCancelTasks.effect, cancelEffectCancelTasks.startTime).size() == 0) {
cancelEffectCancelTasks.schedule.cancel(false);
}
}
}
}
public void disableDoor() {
canDoor = false;
TimerManager.getInstance().schedule(new Runnable() {
@Override
public void run() {
canDoor = true;
}
}, 5000);
}
public void disbandGuild() {
if (guildid < 1 || guildrank != 1) {
return;
}
try {
client.getChannelServer().getWorldInterface().disbandGuild(guildid);
} catch (Exception e) {
}
}
public void dispel() {
for (MapleBuffStatValueHolder mbsvh : new ArrayList<MapleBuffStatValueHolder>(effects.values())) {
if (mbsvh.effect.isSkill()) {
cancelEffect(mbsvh.effect, false, mbsvh.startTime);
}
}
}
public void dispelDebuffs() {
List<MapleDisease> disease_ = new ArrayList<MapleDisease>();
for (MapleDisease disease : diseases) {
if (disease != null) {
disease_.add(disease);
client.getSession().write(MaplePacketCreator.cancelDebuff(disease_));
getMap().broadcastMessage(this, MaplePacketCreator.cancelForeignDebuff(this.id, disease_), false);
disease_.clear();
} else {
return;
}
}
this.diseases.clear();
}
public void dispelSeduce() {
List<MapleDisease> disease_ = new ArrayList<MapleDisease>();
for (MapleDisease disease : diseases) {
if (disease == MapleDisease.SEDUCE) {
disease_.add(disease);
client.getSession().write(MaplePacketCreator.cancelDebuff(disease_));
getMap().broadcastMessage(this, MaplePacketCreator.cancelForeignDebuff(this.id, disease_), false);
disease_.clear();
}
}
this.diseases.clear();
}
public void dispelSkill(int skillid) {
LinkedList<MapleBuffStatValueHolder> allBuffs = new LinkedList<MapleBuffStatValueHolder>(effects.values());
for (MapleBuffStatValueHolder mbsvh : allBuffs) {
if (skillid == 0) {
if (mbsvh.effect.isSkill() && (mbsvh.effect.getSourceId() % 10000000 == 1004 || dispelSkills(mbsvh.effect.getSourceId()))) {
cancelEffect(mbsvh.effect, false, mbsvh.startTime);
}
} else if (mbsvh.effect.isSkill() && mbsvh.effect.getSourceId() == skillid) {
cancelEffect(mbsvh.effect, false, mbsvh.startTime);
}
}
}
private boolean dispelSkills(int skillid) {
switch (skillid) {
case DarkKnight.BEHOLDER:
case FPArchMage.ELQUINES:
case ILArchMage.IFRIT:
case Priest.SUMMON_DRAGON:
case Bishop.BAHAMUT:
case Ranger.PUPPET:
case Ranger.SILVER_HAWK:
case Sniper.PUPPET:
case Sniper.GOLDEN_EAGLE:
case Hermit.SHADOW_PARTNER:
return true;
default:
return false;
}
}
public void dispelSeal() {
List<MapleDisease> disease_ = new ArrayList<MapleDisease>();
for (MapleDisease disease : diseases) {
if (disease == MapleDisease.SEAL) {
disease_.add(disease);
client.getSession().write(MaplePacketCreator.cancelDebuff(disease_));
getMap().broadcastMessage(this, MaplePacketCreator.cancelForeignDebuff(this.id, disease_), false);
disease_.clear();
}
}
this.diseases.clear();
}
public void doHurtHp() {
if (this.getInventory(MapleInventoryType.EQUIPPED).findById(getMap().getHPDecProtect()) != null) {
return;
}
addHP(-getMap().getHPDec());
hpDecreaseTask = TimerManager.getInstance().schedule(new Runnable() {
@Override
public void run() {
doHurtHp();
}
}, 10000);
}
public void dropMessage(String message) {
dropMessage(6, message);
}
public void dropMessage(int type, String message) {
client.getSession().write(MaplePacketCreator.serverNotice(type, message));
}
public String emblemCost() {
return nf.format(MapleGuild.CHANGE_EMBLEM_COST);
}
private void enforceMaxHpMp() {
List<Pair<MapleStat, Integer>> stats = new ArrayList<Pair<MapleStat, Integer>>(2);
if (getMp() > getCurrentMaxMp()) {
setMp(getMp());
stats.add(new Pair<MapleStat, Integer>(MapleStat.MP, Integer.valueOf(getMp())));
}
if (getHp() > getCurrentMaxHp()) {
setHp(getHp());
stats.add(new Pair<MapleStat, Integer>(MapleStat.HP, Integer.valueOf(getHp())));
}
if (stats.size() > 0) {
client.getSession().write(MaplePacketCreator.updatePlayerStats(stats));
}
}
public void enteredScript(String script, int mapid) {
if (!entered.containsKey(mapid)) {
entered.put(mapid, script);
}
}
public void equipChanged() {
getMap().broadcastMessage(this, MaplePacketCreator.updateCharLook(this), false);
recalcLocalStats();
enforceMaxHpMp();
if (getMessenger() != null) {
WorldChannelInterface wci = client.getChannelServer().getWorldInterface();
try {
wci.updateMessenger(getMessenger().getId(), getName(), client.getChannel());
} catch (Exception e) {
client.getChannelServer().reconnectWorld();
}
}
}
public void expirationTask() {
long expiration, currenttime = System.currentTimeMillis();
List<IItem> toberemove = new ArrayList<IItem>(); // This is here to prevent deadlock.
for (MapleInventory inv : inventory) {
for (IItem item : inv.list()) {
expiration = item.getExpiration();
if (expiration != -1) {
if (currenttime < expiration) {
client.getSession().write(MaplePacketCreator.itemExpired(item.getItemId()));
toberemove.add(item);
}
}
}
for (IItem item : toberemove) {
MapleInventoryManipulator.removeFromSlot(client, inv.getType(), item.getPosition(), item.getQuantity(), true);
}
toberemove.clear();
}
}
public enum FameStatus {
OK, NOT_TODAY, NOT_THIS_MONTH
}
public void forceUpdateItem(MapleInventoryType type, IItem item) {
client.getSession().write(MaplePacketCreator.clearInventoryItem(type, item.getPosition(), false));
client.getSession().write(MaplePacketCreator.addInventorySlot(type, item, false));
}
public void gainExp(int gain, boolean show, boolean inChat) {
gainExp(gain, show, inChat, true);
}
public void gainExp(int gain, boolean show, boolean inChat, boolean white) {
gainExp(gain, show, inChat, white, true);
}
public void gainExp(int gain, boolean show, boolean inChat, boolean white, boolean etcLose) {
if (!etcLose && gain < 0) {
gain += Integer.MAX_VALUE;
if (getLevel() < getMaxLevel()) {
levelUp(true);
}
while (gain > 0) {
gain -= (ExpTable.getExpNeededForLevel(level) - this.exp.get());
if (getLevel() < getMaxLevel()) {
levelUp(true);
}
}
setExp(0);
updateSingleStat(MapleStat.EXP, exp.get());
client.getSession().write(MaplePacketCreator.getShowExpGain(Integer.MAX_VALUE, inChat, white));
return;
}
if (ChannelServer.getInstance(getClient().getChannel()).president.equalsIgnoreCase(getName())) {
gain *= 2;
if (warning[5] == false) {
dropMessage("You are gaining 2X more EXP because you are the President of Channel " + getClient().getChannel() + "!");
warning[5] = true;
}
}
if (getLevel() < getMaxLevel()) {
if ((long) this.exp.get() + (long) gain > (long) Integer.MAX_VALUE) {
int gainFirst = ExpTable.getExpNeededForLevel(level) - this.exp.get();
gain -= gainFirst + 1;
this.gainExp(gainFirst + 1, false, inChat, white);
}
updateSingleStat(MapleStat.EXP, this.exp.addAndGet(gain));
} else {
return;
}
if (show && gain != 0) {
client.getSession().write(MaplePacketCreator.getShowExpGain(gain, inChat, white));
}
if (exp.get() >= ExpTable.getExpNeededForLevel(level) && level < getMaxLevel()) {
if (ChannelServer.EnableMultiLevel()) {
while (level < getMaxLevel() && exp.get() >= ExpTable.getExpNeededForLevel(level)) {
levelUp(true);
}
} else {
levelUp(true);
int need = ExpTable.getExpNeededForLevel(level);
if (exp.get() >= need) {
setExp(need - 1);
updateSingleStat(MapleStat.EXP, exp.get());
}
}
}
}
public void gainFame(int delta) {
this.addFame(delta);
this.updateSingleStat(MapleStat.FAME, this.fame);
}
public void gainMeso(int gain, boolean show) {
gainMeso(gain, show, false, false);
}
public void gainMeso(int gain, boolean show, boolean enableActions, boolean inChat) {
if (meso.get() + gain < 0) {
client.getSession().write(MaplePacketCreator.enableActions());
return;
}
int newVal = meso.addAndGet(gain);
updateSingleStat(MapleStat.MESO, newVal, enableActions);
if (newVal >= 2147483646) {
this.finishAchievement(8);
}
if (show) {
client.getSession().write(MaplePacketCreator.getShowMesoGain(gain, inChat));
}
}
public void clearSlots() {
inventorySlots.clear();
}
public void genericGuildMessage(int code) {
this.client.getSession().write(MaplePacketCreator.genericGuildMessage((byte) code));
}
public int getAccountID() {
return accountid;
}
public List<PlayerBuffValueHolder> getAllBuffs() {
List<PlayerBuffValueHolder> ret = new ArrayList<PlayerBuffValueHolder>();
for (MapleBuffStatValueHolder mbsvh : effects.values()) {
ret.add(new PlayerBuffValueHolder(mbsvh.startTime, mbsvh.effect));
}
return ret;
}
public List<PlayerCoolDownValueHolder> getAllCooldowns() {
List<PlayerCoolDownValueHolder> ret = new ArrayList<PlayerCoolDownValueHolder>();
for (MapleCoolDownValueHolder mcdvh : coolDowns.values()) {
ret.add(new PlayerCoolDownValueHolder(mcdvh.skillId, mcdvh.startTime, mcdvh.length));
}
return ret;
}
public int getAllianceRank() {
return this.allianceRank;
}
public int getAllowWarpToId() {
return warpToId;
}
public static String getAriantRoomLeaderName(int room) {
return ariantroomleader[room];
}
public static int getAriantSlotsRoom(int room) {
return ariantroomslot[room];
}
public int getBattleshipHp() {
return battleshipHp;
}
public BuddyList getBuddylist() {
return buddylist;
}
public Long getBuffedStarttime(MapleBuffStat effect) {
MapleBuffStatValueHolder mbsvh = effects.get(effect);
if (mbsvh == null) {
return null;
}
return Long.valueOf(mbsvh.startTime);
}
public Integer getBuffedValue(MapleBuffStat effect) {
MapleBuffStatValueHolder mbsvh = effects.get(effect);
if (mbsvh == null) {
return null;
}
return Integer.valueOf(mbsvh.value);
}
public int getBuffSource(MapleBuffStat stat) {
MapleBuffStatValueHolder mbsvh = effects.get(stat);
if (mbsvh == null) {
return -1;
}
return mbsvh.effect.getSourceId();
}
private List<MapleBuffStat> getBuffStats(MapleStatEffect effect, long startTime) {
List<MapleBuffStat> stats = new ArrayList<MapleBuffStat>();
for (Entry<MapleBuffStat, MapleBuffStatValueHolder> stateffect : effects.entrySet()) {
if (stateffect.getValue().effect.sameSource(effect) && (startTime == -1 || startTime == stateffect.getValue().startTime)) {
stats.add(stateffect.getKey());
}
}
return stats;
}
public int getChair() {
return chair;
}
public String getChalkboard() {
return this.chalktext;
}
public MapleClient getClient() {
return client;
}
public final List<MapleQuestStatus> getCompletedQuests() {
List<MapleQuestStatus> ret = new LinkedList<MapleQuestStatus>();
for (MapleQuestStatus q : quests.values()) {
if (q.getStatus().equals(MapleQuestStatus.Status.COMPLETED)) {
ret.add(q);
}
}
return Collections.unmodifiableList(ret);
}
public Collection<MapleMonster> getControlledMonsters() {
return Collections.unmodifiableCollection(controlled);
}
public List<MapleRing> getCrushRings() {
Collections.sort(crushRings);
return crushRings;
}
public int getCSPoints(int type) {
switch (type) {
case 1:
return paypalnx;
case 2:
return maplepoints;
default:
return cardnx;
}
}
public int getCurrentCI() {
return ci;
}
public int getCurrentPage() {
return currentPage;
}
public int getCurrentMaxHp() {
return localmaxhp;
}
public int getCurrentMaxMp() {
return localmaxmp;
}
public int getCurrentTab() {
return currentTab;
}
public int getCurrentType() {
return currentType;
}
public int getCygnusLinkId() {
return cygnusLinkId;
}
public int getDex() {
return dex;
}
public List<MapleDisease> getDiseases() {
synchronized (diseases) {
return Collections.unmodifiableList(diseases);
}
}
public int getDojoEnergy() {
return dojoEnergy;
}
public boolean getDojoParty() {
return dojoParty;
}
public int getDojoPoints() {
return dojoPoints;
}
public int getDojoStage() {
return dojoStage;
}
public List<MapleDoor> getDoors() {
return new ArrayList<MapleDoor>(doors);
}
public int getEnergyBar() {
return energybar;
}
public EventInstanceManager getEventInstance() {
return eventInstance;
}
public ArrayList<Integer> getExcluded() {
return excluded;
}
public int getExp() {
return exp.get();
}
public int getFace() {
return face;
}
public int getFame() {
return fame;
}
public MapleFamilyEntry getFamily() {
return MapleFamily.getMapleFamily(this);
}
public int getFamilyId() {
return familyId;
}
public boolean getFinishedDojoTutorial() {
return finishedDojoTutorial;
}
public List<MapleRing> getFriendshipRings() {
Collections.sort(friendshipRings);
return friendshipRings;
}
public int getGender() {
return gender;
}
public boolean getGMChat() {
return whitechat;
}
public MapleGuild getGuild() {
try {
return client.getChannelServer().getWorldInterface().getGuild(getGuildId(), null);
} catch (Exception ex) {
return null;
}
}
public int getGuildId() {
return guildid;
}
public int getGuildRank() {
return guildrank;
}
public int getHair() {
return hair;
}
public HiredMerchant getHiredMerchant() {
return hiredMerchant;
}
public int getHp() {
return hp;
}
public int getHpMpApUsed() {
return hpMpApUsed;
}
public int getId() {
return id;
}
public static int getIdByName(String name) {
try {
PreparedStatement ps = DatabaseConnection.getConnection().prepareStatement("SELECT id FROM characters WHERE name = ?");
ps.setString(1, name);
ResultSet rs = ps.executeQuery();
if (!rs.next()) {
rs.close();
ps.close();
return -1;
}
int id = rs.getInt("id");
rs.close();
ps.close();
return id;
} catch (Exception e) {
}
return -1;
}
public int getInitialSpawnpoint() {
return initialSpawnPoint;
}
public int getInt() {
return int_;
}
public MapleInventory getInventory(MapleInventoryType type) {
return inventory[type.ordinal()];
}
public int getItemEffect() {
return itemEffect;
}
public int getItemQuantity(int itemid, boolean checkEquipped) {
int possesed = inventory[MapleItemInformationProvider.getInstance().getInventoryType(itemid).ordinal()].countById(itemid);
if (checkEquipped) {
possesed += inventory[MapleInventoryType.EQUIPPED.ordinal()].countById(itemid);
}
return possesed;
}
public MapleJob getJob() {
return job;
}
public int getJobRank() {
return jobRank;
}
public int getJobRankMove() {
return jobRankMove;
}
public int getJobType() {
return job.getId() / 1000;
}
public Map<Integer, MapleKeyBinding> getKeymap() {
return keymap;
}
public long getLastHealed() {
return lastHealed;
}
public long getLastUsedCashItem() {
return lastUsedCashItem;
}
public int getLevel() {
return level;
}
public int getLinkedLevel() {
return linkedLevel;
}
public int getLuk() {
return luk;
}
public MapleMap getMap() {
return map;
}
public int getMapId() {
if (map != null) {
return map.getId();
}
return mapid;
}
public int getMarkedMonster() {
return markedMonster;
}
public List<MapleRing> getMarriageRings() {
Collections.sort(marriageRings);
return marriageRings;
}
public int getMarried() {
return married;
}
public int getMasterLevel(ISkill skill) {
if (skills.get(skill) == null) {
return 0;
}
return skills.get(skill).masterlevel;
}
public int getMaxHp() {
return maxhp;
}
public int getMaxLevel() {
return isCygnus() ? ChannelServer.CygnusLevelCap() : ChannelServer.LevelCap();
}
public int getMaxMp() {
return maxmp;
}
public int getMeso() {
return meso.get();
}
public int getMesosTraded() {
return mesosTraded;
}
public int getMessengerPosition() {
return messengerposition;
}
public MapleGuildCharacter getMGC() {
return mgc;
}
public MapleMiniGame getMiniGame() {
return miniGame;
}
public int getMiniGamePoints(String type, boolean omok) {
if (omok) {
if (type.equals("wins")) {
return omokwins;
} else if (type.equals("losses")) {
return omoklosses;
} else {
return omokties;
}
} else {
if (type.equals("wins")) {
return matchcardwins;
} else if (type.equals("losses")) {
return matchcardlosses;
} else {
return matchcardties;
}
}
}
public MonsterBook getMonsterBook() {
return monsterbook;
}
public int getMonsterBookCover() {
return bookCover;
}
public MapleMount getMount() {
return maplemount;
}
public int getMp() {
return mp;
}
public MapleMessenger getMessenger() {
return messenger;
}
public String getName() {
return name;
}
public int getNextEmptyPetIndex() {
for (int i = 0; i < 3; i++) {
if (pets[i] == null) {
return i;
}
}
return 3;
}
public int getNoPets() {
int ret = 0;
for (int i = 0; i < 3; i++) {
if (pets[i] != null) {
ret++;
}
}
return ret;
}
public int getNumControlledMonsters() {
return controlled.size();
}
public MapleParty getParty() {
return party;
}
public int getPartyId() {
return (party != null ? party.getId() : -1);
}
public MaplePet getPet(int index) {
return pets[index];
}
public int getPetIndex(int petId) {
for (int i = 0; i < 3; i++) {
if (pets[i] != null) {
if (pets[i].getUniqueId() == petId) {
return i;
}
}
}
return -1;
}
public int getPetIndex(MaplePet pet) {
for (int i = 0; i < 3; i++) {
if (pets[i] != null) {
if (pets[i].getUniqueId() == pet.getUniqueId()) {
return i;
}
}
}
return -1;
}
public MaplePlayerShop getPlayerShop() {
return playerShop;
}
public MaplePet[] getPets() {
return pets;
}
public int getPossibleReports() {
return possibleReports;
}
public MapleQuestStatus getQuest(MapleQuest quest) {
if (!quests.containsKey(quest)) {
return new MapleQuestStatus(quest, MapleQuestStatus.Status.NOT_STARTED);
}
return quests.get(quest);
}
public int getRank() {
return rank;
}
public int getRankMove() {
return rankMove;
}
public int getRemainingAp() {
return remainingAp;
}
public int getRemainingSp() {
return remainingSp;
}
public int getSavedLocation(String type) {
int m = savedLocations[SavedLocationType.fromString(type).ordinal()].getMapId();
if (!SavedLocationType.fromString(type).equals(SavedLocationType.WORLDTOUR)) {
clearSavedLocation(SavedLocationType.fromString(type));
}
return m;
}
public String getSearch() {
return search;
}
public void changeOccupation(MapleOccupations newoccupation) {
this.occupation = newoccupation;
}
public MapleOccupations getOccupation() {
return occupation;
}
public MapleShop getShop() {
return shop;
}
public Map<ISkill, SkillEntry> getSkills() {
return Collections.unmodifiableMap(skills);
}
public int getSkillLevel(int skill) {
SkillEntry ret = skills.get(SkillFactory.getSkill(skill));
if (ret == null) {
return 0;
}
return ret.skillevel;
}
public int getSkillLevel(ISkill skill) {
if (skills.get(skill) == null) {
return 0;
}
return skills.get(skill).skillevel;
}
public MapleSkinColor getSkinColor() {
return skinColor;
}
public int getSlot() {
return slots;
}
public final List<MapleQuestStatus> getStartedQuests() {
List<MapleQuestStatus> ret = new LinkedList<MapleQuestStatus>();
for (MapleQuestStatus q : quests.values()) {
if (q.getStatus().equals(MapleQuestStatus.Status.STARTED)) {
ret.add(q);
}
}
return Collections.unmodifiableList(ret);
}
public MapleStatEffect getStatForBuff(MapleBuffStat effect) {
MapleBuffStatValueHolder mbsvh = effects.get(effect);
if (mbsvh == null) {
return null;
}
return mbsvh.effect;
}
public MapleStorage getStorage() {
return storage;
}
public int getStr() {
return str;
}
public Map<Integer, MapleSummon> getSummons() {
return summons;
}
public int getTotalLuk() {
return localluk;
}
public int getTotalMagic() {
return magic;
}
public int getTotalWatk() {
return watk;
}
public MapleTrade getTrade() {
return trade;
}
public int getVanquisherKills() {
return vanquisherKills;
}
public int getVanquisherStage() {
return vanquisherStage;
}
public Collection<MapleMapObject> getVisibleMapObjects() {
return Collections.unmodifiableCollection(visibleMapObjects);
}
public List<Integer> getWishList() {
return wishList;
}
public int getWorld() {
return world;
}
public void giveCoolDowns(final int skillid, long starttime, long length) {
int time = (int) ((length + starttime) - System.currentTimeMillis());
addCooldown(skillid, System.currentTimeMillis(), time, TimerManager.getInstance().schedule(new CancelCooldownAction(this, skillid), time));
}
public void giveDebuff(MapleDisease disease, MobSkill skill) {
if (this.isAlive() && diseases.size() < 2) {
List<Pair<MapleDisease, Integer>> disease_ = new ArrayList<Pair<MapleDisease, Integer>>();
disease_.add(new Pair<MapleDisease, Integer>(disease, Integer.valueOf(skill.getX())));
this.diseases.add(disease);
client.getSession().write(MaplePacketCreator.giveDebuff(disease_, skill));
getMap().broadcastMessage(this, MaplePacketCreator.giveForeignDebuff(this.id, disease_, skill), false);
}
}
public int gmLevel() {
return gmLevel;
}
public String guildCost() {
return nf.format(MapleGuild.CREATE_GUILD_COST);
}
private void guildUpdate() {
if (this.guildid < 1) {
return;
}
mgc.setLevel(level);
mgc.setJobId(job.getId());
try {
this.client.getChannelServer().getWorldInterface().memberLevelJobUpdate(this.mgc);
int allianceId = getGuild().getAllianceId();
if (allianceId > 0) {
client.getChannelServer().getWorldInterface().allianceMessage(allianceId, MaplePacketCreator.updateAllianceJobLevel(this), getId(), -1);
}
} catch (RemoteException e) {
e.printStackTrace();
}
}
public void handleEnergyChargeGain() { // to get here energychargelevel has to be > 0
ISkill energycharge = isCygnus() ? SkillFactory.getSkill(ThunderBreaker.ENERGY_CHARGE) : SkillFactory.getSkill(Marauder.ENERGY_CHARGE);
MapleStatEffect ceffect = null;
ceffect = energycharge.getEffect(getSkillLevel(energycharge));
TimerManager tMan = TimerManager.getInstance();
if (energybar < 10000) {
energybar += 102;
if (energybar > 10000) {
energybar = 10000;
}
client.getSession().write(MaplePacketCreator.giveEnergyCharge(energybar));
client.getSession().write(MaplePacketCreator.showOwnBuffEffect(energycharge.getId(), 2));
getMap().broadcastMessage(this, MaplePacketCreator.showBuffeffect(id, energycharge.getId(), 2));
if (energybar == 10000) {
getMap().broadcastMessage(this, MaplePacketCreator.giveForeignEnergyCharge(id, energybar));
}
}
if (energybar >= 10000 && energybar < 11000) {
energybar = 15000;
final MapleCharacter chr = this;
tMan.schedule(new Runnable() {
@Override
public void run() {
client.getSession().write(MaplePacketCreator.giveEnergyCharge(0));
getMap().broadcastMessage(chr, MaplePacketCreator.giveForeignEnergyCharge(id, energybar));
energybar = 0;
}
}, ceffect.getDuration());
}
}
public void handleOrbconsume() {
int skillid = isCygnus() ? DawnWarrior.COMBO : Crusader.COMBO;
ISkill combo = SkillFactory.getSkill(skillid);
List<Pair<MapleBuffStat, Integer>> stat = Collections.singletonList(new Pair<MapleBuffStat, Integer>(MapleBuffStat.COMBO, 1));
setBuffedValue(MapleBuffStat.COMBO, 1);
client.getSession().write(MaplePacketCreator.giveBuff(skillid, combo.getEffect(getSkillLevel(combo)).getDuration() + (int) ((getBuffedStarttime(MapleBuffStat.COMBO) - System.currentTimeMillis())), stat, false, false, getMount()));
getMap().broadcastMessage(this, MaplePacketCreator.giveForeignBuff(getId(), stat, false), false);
}
public boolean hasEntered(String script) {
for (int mapId : entered.keySet()) {
if (entered.get(mapId).equals(script)) {
return true;
}
}
return false;
}
public boolean hasEntered(String script, int mapId) {
if (entered.containsKey(mapId)) {
if (entered.get(mapId).equals(script)) {
return true;
}
}
return false;
}
public void hasGivenFame(MapleCharacter to) {
lastfametime = System.currentTimeMillis();
lastmonthfameids.add(Integer.valueOf(to.getId()));
try {
PreparedStatement ps = DatabaseConnection.getConnection().prepareStatement("INSERT INTO famelog (characterid, characterid_to) VALUES (?, ?)");
ps.setInt(1, getId());
ps.setInt(2, to.getId());
ps.executeUpdate();
ps.close();
} catch (SQLException e) {
}
}
public boolean hasMerchant() {
return hasMerchant;
}
public boolean hasWatchedCygnusIntro() {
return watchedCygnusIntro;
}
public boolean haveItem(int itemid) {
return getItemQuantity(itemid, false) > 0;
}
public boolean haveItemEquipped(int itemid) {
if (getInventory(MapleInventoryType.EQUIPPED).findById(itemid) != null) {
return true;
}
return false;
}
public void increaseGuildCapacity() { //hopefully nothing is null
if (getMeso() < getGuild().getIncreaseGuildCost(getGuild().getCapacity())) {
dropMessage(1, "You don't have enough mesos.");
return;
}
try {
client.getChannelServer().getWorldInterface().increaseGuildCapacity(guildid);
} catch (RemoteException e) {
client.getChannelServer().reconnectWorld();
return;
}
gainMeso(-getGuild().getIncreaseGuildCost(getGuild().getCapacity()), true, false, false);
}
public boolean inCS() {
return incs;
}
public boolean inMTS() {
return inmts;
}
public boolean isActiveBuffedValue(int skillid) {
LinkedList<MapleBuffStatValueHolder> allBuffs = new LinkedList<MapleBuffStatValueHolder>(effects.values());
for (MapleBuffStatValueHolder mbsvh : allBuffs) {
if (mbsvh.effect.isSkill() && mbsvh.effect.getSourceId() == skillid) {
return true;
}
}
return false;
}
public boolean isAlive() {
return hp > 0;
}
public boolean isBuffFrom(MapleBuffStat stat, ISkill skill) {
MapleBuffStatValueHolder mbsvh = effects.get(stat);
if (mbsvh == null) {
return false;
}
return mbsvh.effect.isSkill() && mbsvh.effect.getSourceId() == skill.getId();
}
public int getState() {
return state;
}
public void setState(int s) {
state = s;
}
public boolean isCygnus() {
return getJobType() == 1;
}
public boolean isGM() {
return gmLevel > 1;
}
public boolean isAdmin() {
return gmLevel > 2;
}
public boolean isHidden() {
return hidden;
}
public boolean isLinked() {
PreparedStatement ps = null;
boolean isLinked = false;
try {
ps = DatabaseConnection.getConnection().prepareStatement("SELECT knightId from koccharacters WHERE linkedId = ?");
ps.setInt(1, id);
ResultSet rs = ps.executeQuery();
isLinked = rs.last();
ps.close();
rs.close();
} catch (SQLException e) {
return false;
} finally {
try {
if (ps != null) {
ps.close();
}
} catch (SQLException sql) {
}
}
return isLinked;
}
public boolean isMapObjectVisible(MapleMapObject mo) {
return visibleMapObjects.contains(mo);
}
public boolean isPartyLeader() {
return party.getLeader() == party.getMemberById(getId());
}
public void leaveMap() {
controlled.clear();
visibleMapObjects.clear();
if (chair != 0) {
chair = 0;
}
if (hpDecreaseTask != null) {
hpDecreaseTask.cancel(false);
}
}
public void levelUp(boolean takeexp) {
ISkill improvingMaxHP = null;
ISkill improvingMaxMP = null;
int improvingMaxHPLevel = 0;
int improvingMaxMPLevel = 0;
if (isCygnus() && level < 70) {
remainingAp++;
}
if (getOccupation().isA(MapleOccupations.Monk)) {
remainingAp++;
}
if (level == 200 && !isGM()) {
exp.set(0);
MaplePacket packet = MaplePacketCreator.serverNotice(6, "[Congratulations] " + getName() + " has reached Level 200! Congratulate " + getName() + " on such an amazing achievement!");
try {
getClient().getChannelServer().getWorldInterface().broadcastMessage(getName(), packet.getBytes());
} catch (RemoteException e) {
getClient().getChannelServer().reconnectWorld();
}
}
if (level >= 70) {
finishAchievement(4);
}
if (level >= 120) {
finishAchievement(5);
}
if (level == 200) {
finishAchievement(22);
}
remainingAp += 5;
if (job == MapleJob.BEGINNER || job == MapleJob.NOBLESSE) {
maxhp += rand(12, 16);
maxmp += rand(10, 12);
} else if (job.isA(MapleJob.WARRIOR) || job.isA(MapleJob.DAWNWARRIOR1)) {
improvingMaxHP = isCygnus() ? SkillFactory.getSkill(DawnWarrior.MAX_HP_INCREASE) : SkillFactory.getSkill(Swordsman.IMPROVED_MAX_HP_INCREASE);
if (job.isA(MapleJob.CRUSADER)) {
improvingMaxMP = SkillFactory.getSkill(1210000);
} else if (job.isA(MapleJob.DAWNWARRIOR2)) {
improvingMaxMP = SkillFactory.getSkill(11110000);
}
improvingMaxHPLevel = getSkillLevel(improvingMaxHP);
maxhp += rand(24, 28);
maxmp += rand(4, 6);
} else if (job.isA(MapleJob.MAGICIAN) || job.isA(MapleJob.BLAZEWIZARD1)) {
improvingMaxMP = isCygnus() ? SkillFactory.getSkill(BlazeWizard.INCREASING_MAX_MP) : SkillFactory.getSkill(Magician.IMPROVED_MAX_MP_INCREASE);
improvingMaxMPLevel = getSkillLevel(improvingMaxMP);
maxhp += rand(10, 14);
maxmp += rand(22, 24);
} else if (job.isA(MapleJob.BOWMAN) || job.isA(MapleJob.THIEF) || (job.getId() > 1299 && job.getId() < 1500)) {
maxhp += rand(20, 24);
maxmp += rand(14, 16);
} else if (job.isA(MapleJob.GM)) {
maxhp = 30000;
maxmp = 30000;
} else if (job.isA(MapleJob.PIRATE) || job.isA(MapleJob.THUNDERBREAKER1)) {
improvingMaxHP = isCygnus() ? SkillFactory.getSkill(ThunderBreaker.IMPROVE_MAX_HP) : SkillFactory.getSkill(5100000);
improvingMaxHPLevel = getSkillLevel(improvingMaxHP);
maxhp += rand(22, 28);
maxmp += rand(18, 23);
}
if (improvingMaxHPLevel > 0 && (job.isA(MapleJob.WARRIOR) || job.isA(MapleJob.PIRATE) || job.isA(MapleJob.DAWNWARRIOR1))) {
maxhp += improvingMaxHP.getEffect(improvingMaxHPLevel).getX();
}
if (improvingMaxMPLevel > 0 && (job.isA(MapleJob.MAGICIAN) || job.isA(MapleJob.CRUSADER) || job.isA(MapleJob.BLAZEWIZARD1))) {
maxmp += improvingMaxMP.getEffect(improvingMaxMPLevel).getX();
}
maxmp += localint_ / 10;
if (takeexp) {
exp.addAndGet(-ExpTable.getExpNeededForLevel(level));
if (exp.get() < 0) {
exp.set(0);
}
}
level++;
if (level >= getMaxLevel()) {
exp.set(0);
}
maxhp = Math.min(30000, maxhp);
maxmp = Math.min(30000, maxmp);
if (level == 200) {
exp.set(0);
}
hp = maxhp;
mp = maxmp;
recalcLocalStats();
List<Pair<MapleStat, Integer>> statup = new ArrayList<Pair<MapleStat, Integer>>(8);
statup.add(new Pair<MapleStat, Integer>(MapleStat.AVAILABLEAP, remainingAp));
statup.add(new Pair<MapleStat, Integer>(MapleStat.HP, localmaxhp));
statup.add(new Pair<MapleStat, Integer>(MapleStat.MP, localmaxmp));
statup.add(new Pair<MapleStat, Integer>(MapleStat.EXP, exp.get()));
statup.add(new Pair<MapleStat, Integer>(MapleStat.LEVEL, level));
statup.add(new Pair<MapleStat, Integer>(MapleStat.MAXHP, maxhp));
statup.add(new Pair<MapleStat, Integer>(MapleStat.MAXMP, maxmp));
if (job.getId() % 1000 > 0) {
remainingSp += 3;
statup.add(new Pair<MapleStat, Integer>(MapleStat.AVAILABLESP, remainingSp));
}
client.getSession().write(MaplePacketCreator.updatePlayerStats(statup));
getMap().broadcastMessage(this, MaplePacketCreator.showForeignEffect(getId(), 0), false);
recalcLocalStats();
silentPartyUpdate();
guildUpdate();
}
public void setAchievementFinished(int id) {
finishedAchievements.add(id);
}
public boolean achievementFinished(int achievementid) {
return finishedAchievements.contains(achievementid);
}
public void finishAchievement(int id) {
if (!achievementFinished(id)) {
if (isAlive()) {
MapleAchievements.getInstance().getById(id).finishAchievement(this);
}
}
}
public List<Integer> getFinishedAchievements() {
return finishedAchievements;
}
public static MapleCharacter loadCharFromDB(int charid, MapleClient client, boolean channelserver) throws SQLException {
try {
MapleCharacter ret = new MapleCharacter();
ret.client = client;
ret.id = charid;
Connection con = DatabaseConnection.getConnection();
PreparedStatement ps = con.prepareStatement("SELECT * FROM characters WHERE id = ?");
ps.setInt(1, charid);
ResultSet rs = ps.executeQuery();
if (!rs.next()) {
rs.close();
ps.close();
throw new RuntimeException("Loading char failed (not found)");
}
ret.name = rs.getString("name");
ret.muteLevel = rs.getInt("muteLevel");
ret.level = rs.getInt("level");
ret.reborns = rs.getInt("reborns");
ret.damagerecord = rs.getInt("damagerecord");
ret.creborns = rs.getInt("creborns");
ret.fame = rs.getInt("fame");
ret.str = rs.getInt("str");
ret.dex = rs.getInt("dex");
ret.int_ = rs.getInt("int");
ret.luk = rs.getInt("luk");
ret.exp.set(rs.getInt("exp"));
ret.hp = rs.getInt("hp");
ret.maxhp = rs.getInt("maxhp");
ret.mp = rs.getInt("mp");
ret.maxmp = rs.getInt("maxmp");
ret.hpMpApUsed = rs.getInt("hpMpUsed");
ret.hasMerchant = rs.getInt("HasMerchant") == 1;
ret.remainingSp = rs.getInt("sp");
ret.remainingAp = rs.getInt("ap");
ret.meso.set(rs.getInt("meso"));
ret.gmLevel = rs.getInt("gm");
ret.skinColor = MapleSkinColor.getById(rs.getInt("skincolor"));
ret.gender = rs.getInt("gender");
ret.job = MapleJob.getById(rs.getInt("job"));
ret.occupation = MapleOccupations.getById(rs.getInt("occupation"));
ret.finishedDojoTutorial = rs.getInt("finishedDojoTutorial") == 1;
ret.vanquisherKills = rs.getInt("vanquisherKills");
ret.omokwins = rs.getInt("omokwins");
ret.omoklosses = rs.getInt("omoklosses");
ret.omokties = rs.getInt("omokties");
ret.matchcardwins = rs.getInt("matchcardwins");
ret.matchcardlosses = rs.getInt("matchcardlosses");
ret.matchcardties = rs.getInt("matchcardties");
if (ret.gmLevel < 2) {
PreparedStatement pss = con.prepareStatement("SELECT linkedId FROM koccharacters WHERE knightId = ?");
pss.setInt(1, charid);
ResultSet rss = pss.executeQuery();
int linkedChar = -1;
if (rss.next()) {
linkedChar = rss.getInt("linkedId");
}
rss.close();
pss.close();
pss = con.prepareStatement("SELECT level FROM characters WHERE id = ?");
pss.setInt(1, linkedChar);
rss = pss.executeQuery();
ret.linkedLevel = rss.next() ? rss.getInt("level") : 1;
rss.close();
pss.close();
} else {
ret.linkedLevel = 200;
}
ret.hair = rs.getInt("hair");
ret.face = rs.getInt("face");
ret.accountid = rs.getInt("accountid");
ret.mapid = rs.getInt("map");
ret.initialSpawnPoint = rs.getInt("spawnpoint");
ret.world = rs.getInt("world");
ret.rank = rs.getInt("rank");
ret.rankMove = rs.getInt("rankMove");
ret.jobRank = rs.getInt("jobRank");
ret.jobRankMove = rs.getInt("jobRankMove");
int mountexp = rs.getInt("mountexp");
int mountlevel = rs.getInt("mountlevel");
int mounttiredness = rs.getInt("mounttiredness");
ret.guildid = rs.getInt("guildid");
ret.guildrank = rs.getInt("guildrank");
ret.allianceRank = rs.getInt("allianceRank");
ret.familyId = rs.getInt("familyId");
ret.bookCover = rs.getInt("monsterbookcover");
ret.monsterbook = new MonsterBook();
ret.monsterbook.loadCards(charid);
ret.cygnusLinkId = rs.getInt("cygnuslink");
ret.watchedCygnusIntro = rs.getInt("watchedcygnusintro") == 1;
ret.vanquisherStage = rs.getInt("vanquisherStage");
ret.dojoPoints = rs.getInt("dojoPoints");
ret.dojoStage = rs.getInt("lastDojoStage");
ret.whitechat = ret.gmLevel > 1;
if (ret.guildid > 0) {
ret.mgc = new MapleGuildCharacter(ret);
}
int buddyCapacity = rs.getInt("buddyCapacity");
ret.buddylist = new BuddyList(buddyCapacity);
if (ServerMode.getServerMode().equals(Mode.LOGIN)) {
ret.getInventory(MapleInventoryType.EQUIPPED).loadInventory(ret);
} else {
for (MapleInventory inv : ret.inventory) {
if (!inv.isExtendableInventory()) {
inv.loadInventory(ret);
} else {
inv.loadInventory(ret, (byte) rs.getInt(inv.getType().name().toLowerCase() + "slots"));
}
}
}
if (channelserver) {
MapleMapFactory mapFactory = client.getChannelServer().getMapFactory();
ret.map = mapFactory.getMap(ret.mapid);
if (ret.map == null) {
ret.map = mapFactory.getMap(100000000);
}
MaplePortal portal = ret.map.getPortal(ret.initialSpawnPoint);
if (portal == null) {
portal = ret.map.getPortal(0);
ret.initialSpawnPoint = 0;
}
ret.setPosition(portal.getPosition());
int partyid = rs.getInt("party");
try {
MapleParty party = client.getChannelServer().getWorldInterface().getParty(partyid);
if (party != null) {
ret.party = party;
}
} catch (RemoteException ex) {
client.getChannelServer().reconnectWorld();
}
int messengerid = rs.getInt("messengerid");
int position = rs.getInt("messengerposition");
if (messengerid > 0 && position < 4 && position > -1) {
try {
WorldChannelInterface wci = client.getChannelServer().getWorldInterface();
MapleMessenger messenger = wci.getMessenger(messengerid);
if (messenger != null) {
ret.messenger = messenger;
ret.messengerposition = position;
}
} catch (RemoteException ez) {
client.getChannelServer().reconnectWorld();
}
}
}
rs.close();
ps.close();
ps = con.prepareStatement("SELECT name, paypalNX, mPoints, cardNX FROM accounts WHERE id = ?");
ps.setInt(1, ret.accountid);
rs = ps.executeQuery();
if (rs.next()) {
ret.client.setAccountName(rs.getString("name"));
ret.paypalnx = rs.getInt("paypalNX");
ret.maplepoints = rs.getInt("mPoints");
ret.cardnx = rs.getInt("cardNX");
}
rs.close();
ps.close();
if (channelserver) {
ps = con.prepareStatement("SELECT * FROM queststatus WHERE characterid = ?");
ps.setInt(1, charid);
rs = ps.executeQuery();
PreparedStatement pse = con.prepareStatement("SELECT * FROM queststatusmobs WHERE queststatusid = ?");
while (rs.next()) {
MapleQuest q = MapleQuest.getInstance(rs.getInt("quest"));
MapleQuestStatus status = new MapleQuestStatus(q, MapleQuestStatus.Status.getById(rs.getInt("status")));
long cTime = rs.getLong("time");
if (cTime > -1) {
status.setCompletionTime(cTime * 1000);
}
status.setForfeited(rs.getInt("forfeited"));
ret.quests.put(q, status);
pse.setInt(1, rs.getInt("queststatusid"));
ResultSet rsMobs = pse.executeQuery();
while (rsMobs.next()) {
status.setMobKills(rsMobs.getInt("mob"), rsMobs.getInt("count"));
}
rsMobs.close();
}
rs.close();
ps.close();
pse.close();
ps = con.prepareStatement("SELECT skillid,skilllevel,masterlevel FROM skills WHERE characterid = ?");
ps.setInt(1, charid);
rs = ps.executeQuery();
while (rs.next()) {
ret.skills.put(SkillFactory.getSkill(rs.getInt("skillid")), new SkillEntry(rs.getInt("skilllevel"), rs.getInt("masterlevel")));
}
rs.close();
ps.close();
ps = con.prepareStatement("SELECT * FROM skillmacros WHERE characterid = ?");
ps.setInt(1, charid);
rs = ps.executeQuery();
while (rs.next()) {
int position = rs.getInt("position");
SkillMacro macro = new SkillMacro(rs.getInt("skill1"), rs.getInt("skill2"), rs.getInt("skill3"), rs.getString("name"), rs.getInt("shout"), position);
ret.skillMacros[position] = macro;
}
rs.close();
ps.close();
ps = con.prepareStatement("SELECT `key`,`type`,`action` FROM keymap WHERE characterid = ?");
ps.setInt(1, charid);
rs = ps.executeQuery();
while (rs.next()) {
int key = rs.getInt("key");
int type = rs.getInt("type");
int action = rs.getInt("action");
ret.keymap.put(Integer.valueOf(key), new MapleKeyBinding(type, action));
}
rs.close();
ps.close();
ps = con.prepareStatement("SELECT `locationtype`,`map`,`portal` FROM savedlocations WHERE characterid = ?");
ps.setInt(1, charid);
rs = ps.executeQuery();
while (rs.next()) {
ret.savedLocations[SavedLocationType.valueOf(rs.getString("locationtype")).ordinal()] = new SavedLocation(rs.getInt("map"), rs.getInt("portal"));
}
rs.close();
ps.close();
ps = con.prepareStatement("SELECT `characterid_to`,`when` FROM famelog WHERE characterid = ? AND DATEDIFF(NOW(),`when`) < 30");
ps.setInt(1, charid);
rs = ps.executeQuery();
ret.lastfametime = 0;
ret.lastmonthfameids = new ArrayList<Integer>(31);
while (rs.next()) {
ret.lastfametime = Math.max(ret.lastfametime, rs.getTimestamp("when").getTime());
ret.lastmonthfameids.add(Integer.valueOf(rs.getInt("characterid_to")));
}
rs.close();
ps.close();
ps = con.prepareStatement("SELECT `sn` FROM wishlist WHERE `charid` = ?");
ps.setInt(1, ret.id);
rs = ps.executeQuery();
while (rs.next()) {
ret.wishList.add(rs.getInt("sn"));
}
rs.close();
ps.close();
ret.buddylist.loadFromDb(charid);
ret.storage = MapleStorage.loadOrCreateFromDB(ret.accountid);
}
String achsql = "SELECT * FROM achievements WHERE accountid = ?";
ps = con.prepareStatement(achsql);
ps.setInt(1, ret.accountid);
rs = ps.executeQuery();
while (rs.next()) {
ret.finishedAchievements.add(rs.getInt("achievementid"));
}
ret.recalcLocalStats();
ret.resetBattleshipHp();
ret.silentEnforceMaxHpMp();
int mountid = ret.getJobType() * 10000000 + 1004;
if (ret.getInventory(MapleInventoryType.EQUIPPED).getItem((byte) -18) != null) {
ret.maplemount = new MapleMount(ret, ret.getInventory(MapleInventoryType.EQUIPPED).getItem((byte) -18).getItemId(), mountid);
} else {
ret.maplemount = new MapleMount(ret, 0, mountid);
}
ret.maplemount.setExp(mountexp);
ret.maplemount.setLevel(mountlevel);
ret.maplemount.setTiredness(mounttiredness);
ret.maplemount.setActive(false);
return ret;
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
public static String makeMapleReadable(String in) {
String i = in.replace('I', 'i');
i = i.replace('l', 'L');
i = i.replace("rn", "Rn");
i = i.replace("vv", "Vv");
i = i.replace("VV", "Vv");
return i;
}
private static class MapleBuffStatValueHolder {
public MapleStatEffect effect;
public long startTime;
public int value;
public ScheduledFuture<?> schedule;
public MapleBuffStatValueHolder(MapleStatEffect effect, long startTime, ScheduledFuture<?> schedule, int value) {
super();
this.effect = effect;
this.startTime = startTime;
this.schedule = schedule;
this.value = value;
}
}
public static class MapleCoolDownValueHolder {
public int skillId;
public long startTime, length;
public ScheduledFuture<?> timer;
public MapleCoolDownValueHolder(int skillId, long startTime, long length, ScheduledFuture<?> timer) {
super();
this.skillId = skillId;
this.startTime = startTime;
this.length = length;
this.timer = timer;
}
}
public void message(String m) {
dropMessage(5, m);
}
public void mobKilled(int id) {
for (MapleQuestStatus q : quests.values()) {
if (q.getStatus() == MapleQuestStatus.Status.COMPLETED || q.getQuest().canComplete(this, null)) {
continue;
}
if (q.mobKilled(id)) {
client.getSession().write(MaplePacketCreator.updateQuestMobKills(q));
if (q.getQuest().canComplete(this, null)) {
client.getSession().write(MaplePacketCreator.getShowQuestCompletion(q.getQuest().getId()));
}
}
}
}
public void modifyCSPoints(int type, int dx) {
if (type == 1) {
this.paypalnx += dx;
} else if (type == 2) {
this.maplepoints += dx;
} else if (type == 4) {
this.cardnx += dx;
}
}
public void mount(int id, int skillid) {
maplemount = new MapleMount(this, id, skillid);
}
public void playerNPC(MapleCharacter v, int scriptId) {
int npcId;
try {
Connection con = DatabaseConnection.getConnection();
PreparedStatement ps = con.prepareStatement("SELECT id FROM playernpcs WHERE ScriptId = ?");
ps.setInt(1, scriptId);
ResultSet rs = ps.executeQuery();
if (!rs.next()) {
rs.close();
ps = con.prepareStatement("INSERT INTO playernpcs (name, hair, face, skin, x, cy, map, ScriptId, Foothold, rx0, rx1) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)");
ps.setString(1, v.getName());
ps.setInt(2, v.getHair());
ps.setInt(3, v.getFace());
ps.setInt(4, v.getSkinColor().getId());
ps.setInt(5, getPosition().x);
ps.setInt(6, getPosition().y);
ps.setInt(7, getMapId());
ps.setInt(8, scriptId);
ps.setInt(9, getMap().getFootholds().findBelow(getPosition()).getId());
ps.setInt(10, getPosition().x + 50);
ps.setInt(11, getPosition().x - 50);
ps.executeUpdate();
rs = ps.getGeneratedKeys();
rs.next();
npcId = rs.getInt(1);
ps.close();
ps = con.prepareStatement("INSERT INTO playernpcs_equip (NpcId, equipid, equippos) VALUES (?, ?, ?)");
ps.setInt(1, npcId);
for (IItem equip : getInventory(MapleInventoryType.EQUIPPED)) {
int position = Math.abs(equip.getPosition());
if ((position < 12 && position > 0) || (position > 100 && position < 112)) {
ps.setInt(2, equip.getItemId());
ps.setInt(3, equip.getPosition());
ps.addBatch();
}
}
ps.executeBatch();
ps.close();
rs.close();
ps = con.prepareStatement("SELECT * FROM playernpcs WHERE ScriptId = ?");
ps.setInt(1, scriptId);
rs = ps.executeQuery();
rs.next();
PlayerNPCs pn = new PlayerNPCs(rs);
for (ChannelServer channel : ChannelServer.getAllInstances()) {
MapleMap m = channel.getMapFactory().getMap(getMapId());
m.broadcastMessage(MaplePacketCreator.spawnPlayerNPC(pn));
m.broadcastMessage(MaplePacketCreator.getPlayerNPC(pn));
m.addMapObject(pn);
}
}
ps.close();
rs.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
private void playerDead() {
cancelAllBuffs();
dispelDebuffs();
if (getEventInstance() != null) {
getEventInstance().playerKilled(this);
}
if (mapid > 925020000 && mapid < 925030000) {
this.dojoStage = 0;
}
if (getBuffedValue(MapleBuffStat.MORPH) != null) {
cancelEffectFromBuffStat(MapleBuffStat.MORPH);
}
if (getBuffedValue(MapleBuffStat.MONSTER_RIDING) != null) {
cancelEffectFromBuffStat(MapleBuffStat.MONSTER_RIDING);
}
if (getChair() == -1) {
setChair(0);
client.getSession().write(MaplePacketCreator.cancelChair(-1));
getMap().broadcastMessage(this, MaplePacketCreator.showChair(getId(), 0), false);
}
client.getSession().write(MaplePacketCreator.enableActions());
}
private void prepareDragonBlood(final MapleStatEffect bloodEffect) {
if (dragonBloodSchedule != null) {
dragonBloodSchedule.cancel(false);
}
dragonBloodSchedule = TimerManager.getInstance().register(new Runnable() {
@Override
public void run() {
addHP(-bloodEffect.getX());
client.getSession().write(MaplePacketCreator.showOwnBuffEffect(bloodEffect.getSourceId(), 5));
getMap().broadcastMessage(MapleCharacter.this, MaplePacketCreator.showBuffeffect(getId(), bloodEffect.getSourceId(), 5), false);
checkBerserk();
}
}, 4000, 4000);
}
public static int rand(int l, int u) {
return (int) ((Math.random() * (u - l + 1)) + l);
}
public int getMaxDis(MapleCharacter player) {
IItem weapon_item = player.getInventory(MapleInventoryType.EQUIPPED).getItem((byte) -11);
if (weapon_item != null) {
MapleWeaponType weapon = MapleItemInformationProvider.getInstance().getWeaponType(weapon_item.getItemId());
if (weapon == MapleWeaponType.SPEAR || weapon == MapleWeaponType.POLE_ARM) {
maxDis = 106;
}
if (weapon == MapleWeaponType.DAGGER || weapon == MapleWeaponType.SWORD1H || weapon == MapleWeaponType.AXE1H || weapon == MapleWeaponType.BLUNT1H) {
maxDis = 63;
}
if (weapon == MapleWeaponType.SWORD2H || weapon == MapleWeaponType.AXE1H || weapon == MapleWeaponType.BLUNT1H) {
maxDis = 73;
}
if (weapon == MapleWeaponType.STAFF || weapon == MapleWeaponType.WAND) {
maxDis = 51;
}
if (weapon == MapleWeaponType.CLAW) {
skil = SkillFactory.getSkill(4000001);
skill = player.getSkillLevel(skil);
if (skill > 0) {
maxDis = (skil.getEffect(player.getSkillLevel(skil)).getRange()) + 205;
} else {
maxDis = 205;
}
}
if (weapon == MapleWeaponType.BOW || weapon == MapleWeaponType.CROSSBOW) {
skil = SkillFactory.getSkill(3000002);
skill = player.getSkillLevel(skil);
if (skill > 0) {
maxDis = (skil.getEffect(player.getSkillLevel(skil)).getRange()) + 270;
} else {
maxDis = 270;
}
}
}
return maxDis;
}
public int calculateMinBaseDamage(MapleCharacter player) {
int minbasedamage = 0;
int atk = player.getTotalWatk();
if (atk == 0) {
minbasedamage = 1;
} else {
IItem weapon_item = getInventory(MapleInventoryType.EQUIPPED).getItem((byte) - 11);
if (weapon_item != null) {
MapleWeaponType weapon = MapleItemInformationProvider.getInstance().getWeaponType(weapon_item.getItemId());
if (player.getJob().isA(MapleJob.FIGHTER)) {
skil = SkillFactory.getSkill(1100000);
skill = player.getSkillLevel(skil);
if (skill > 0) {
sword = ((skil.getEffect(player.getSkillLevel(skil)).getMastery() * 5 + 10) / 100);
} else {
sword = 0.1;
}
} else {
skil = SkillFactory.getSkill(1200000);
skill = player.getSkillLevel(skil);
if (skill > 0) {
sword = ((skil.getEffect(player.getSkillLevel(skil)).getMastery() * 5 + 10) / 100);
} else {
sword = 0.1;
}
}
skil = SkillFactory.getSkill(1100001);
skill = player.getSkillLevel(skil);
if (skill > 0) {
axe = ((skil.getEffect(player.getSkillLevel(skil)).getMastery() * 5 + 10) / 100);
} else {
axe = 0.1;
}
skil = SkillFactory.getSkill(1200001);
skill = player.getSkillLevel(skil);
if (skill > 0) {
blunt = ((skil.getEffect(player.getSkillLevel(skil)).getMastery() * 5 + 10) / 100);
} else {
blunt = 0.1;
}
skil = SkillFactory.getSkill(1300000);
skill = player.getSkillLevel(skil);
if (skill > 0) {
spear = ((skil.getEffect(player.getSkillLevel(skil)).getMastery() * 5 + 10) / 100);
} else {
spear = 0.1;
}
skil = SkillFactory.getSkill(1300001);
skill = player.getSkillLevel(skil);
if (skill > 0) {
polearm = ((skil.getEffect(player.getSkillLevel(skil)).getMastery() * 5 + 10) / 100);
} else {
polearm = 0.1;
}
skil = SkillFactory.getSkill(3200000);
skill = player.getSkillLevel(skil);
if (skill > 0) {
crossbow = ((skil.getEffect(player.getSkillLevel(skil)).getMastery() * 5 + 10) / 100);
} else {
crossbow = 0.1;
}
skil = SkillFactory.getSkill(3100000);
skill = player.getSkillLevel(skil);
if (skill > 0) {
bow = ((skil.getEffect(player.getSkillLevel(skil)).getMastery() * 5 + 10) / 100);
} else {
bow = 0.1;
}
if (weapon == MapleWeaponType.CROSSBOW) {
minbasedamage = (int) (localdex * 0.9 * 3.6 * crossbow + localstr) / 100 * (atk + 15);
}
if (weapon == MapleWeaponType.BOW) {
minbasedamage = (int) (localdex * 0.9 * 3.4 * bow + localstr) / 100 * (atk + 15);
}
if (getJob().isA(MapleJob.THIEF) && (weapon == MapleWeaponType.DAGGER)) {
minbasedamage = (int) (localluk * 0.9 * 3.6 * dagger + localstr + localdex) / 100 * atk;
}
if (!getJob().isA(MapleJob.THIEF) && (weapon == MapleWeaponType.DAGGER)) {
minbasedamage = (int) (localstr * 0.9 * 4.0 * dagger + localdex) / 100 * atk;
}
if (getJob().isA(MapleJob.THIEF) && (weapon == MapleWeaponType.CLAW)) {
minbasedamage = (int) (localluk * 0.9 * 3.6 * claw + localstr + localdex) / 100 * (atk + 15);
}
if (weapon == MapleWeaponType.SPEAR) {
minbasedamage = (int) (localstr * 0.9 * 3.0 * spear + localdex) / 100 * atk;
}
if (weapon == MapleWeaponType.POLE_ARM) {
minbasedamage = (int) (localstr * 0.9 * 3.0 * polearm + localdex) / 100 * atk;
}
if (weapon == MapleWeaponType.SWORD1H) {
minbasedamage = (int) (localstr * 0.9 * 4.0 * sword + localdex) / 100 * atk;
}
if (weapon == MapleWeaponType.SWORD2H) {
minbasedamage = (int) (localstr * 0.9 * 4.6 * sword + localdex) / 100 * atk;
}
if (weapon == MapleWeaponType.AXE1H) {
minbasedamage = (int) (localstr * 0.9 * 3.2 * axe + localdex) / 100 * atk;
}
if (weapon == MapleWeaponType.BLUNT1H) {
minbasedamage = (int) (localstr * 0.9 * 3.2 * blunt + localdex) / 100 * atk;
}
if (weapon == MapleWeaponType.AXE2H) {
minbasedamage = (int) (localstr * 0.9 * 3.4 * axe + localdex) / 100 * atk;
}
if (weapon == MapleWeaponType.BLUNT2H) {
minbasedamage = (int) (localstr * 0.9 * 3.4 * blunt + localdex) / 100 * atk;
}
if (weapon == MapleWeaponType.STAFF || weapon == MapleWeaponType.WAND) {
minbasedamage = (int) (localstr * 0.9 * 3.0 * staffwand + localdex) / 100 * atk;
}
}
}
return minbasedamage;
}
public int getRandomage(MapleCharacter player) {
int maxdamage = player.getCurrentMaxBaseDamage();
int mindamage = player.calculateMinBaseDamage(player);
return MapleCharacter.rand(mindamage, maxdamage);
}
public int getCurrentMaxBaseDamage() {
return localmaxbasedamage;
}
private void recalcLocalStats() {
int oldmaxhp = localmaxhp;
localmaxhp = getMaxHp();
localmaxmp = getMaxMp();
localdex = getDex();
localint_ = getInt();
localstr = getStr();
localluk = getLuk();
int speed = 100, jump = 100;
magic = localint_;
watk = 0;
wdef = 0;
mdef = 0;
for (IItem item : getInventory(MapleInventoryType.EQUIPPED)) {
IEquip equip = (IEquip) item;
localmaxhp += equip.getHp();
localmaxmp += equip.getMp();
localdex += equip.getDex();
localint_ += equip.getInt();
localstr += equip.getStr();
localluk += equip.getLuk();
magic += equip.getMatk() + equip.getInt();
watk += equip.getWatk();
wdef += equip.getWdef();
mdef += equip.getMdef();
speed += equip.getSpeed();
jump += equip.getJump();
}
magic = Math.min(magic, 2000);
Integer hbhp = getBuffedValue(MapleBuffStat.HYPERBODYHP);
if (hbhp != null) {
localmaxhp += (hbhp.doubleValue() / 100) * localmaxhp;
}
Integer hbmp = getBuffedValue(MapleBuffStat.HYPERBODYMP);
if (hbmp != null) {
localmaxmp += (hbmp.doubleValue() / 100) * localmaxmp;
}
localmaxhp = Math.min(30000, localmaxhp);
localmaxmp = Math.min(30000, localmaxmp);
Integer watkbuff = getBuffedValue(MapleBuffStat.WATK);
if (watkbuff != null) {
watk += watkbuff.intValue();
}
if (job.isA(MapleJob.BOWMAN)) {
ISkill expert = null;
if (job.isA(MapleJob.MARKSMAN)) {
expert = SkillFactory.getSkill(3220004);
} else if (job.isA(MapleJob.BOWMASTER)) {
expert = SkillFactory.getSkill(3120005);
}
if (expert != null) {
int boostLevel = getSkillLevel(expert);
if (boostLevel > 0) {
watk += expert.getEffect(boostLevel).getX();
}
}
}
Integer matkbuff = getBuffedValue(MapleBuffStat.MATK);
if (matkbuff != null) {
magic += matkbuff.intValue();
}
Integer speedbuff = getBuffedValue(MapleBuffStat.SPEED);
if (speedbuff != null) {
speed += speedbuff.intValue();
}
Integer jumpbuff = getBuffedValue(MapleBuffStat.JUMP);
if (jumpbuff != null) {
jump += jumpbuff.intValue();
}
if (speed > 140) {
speed = 140;
}
if (jump > 123) {
jump = 123;
}
if (oldmaxhp != 0 && oldmaxhp != localmaxhp) {
updatePartyMemberHP();
}
}
public void receivePartyMemberHP() {
if (party != null) {
int channel = client.getChannel();
for (MaplePartyCharacter partychar : party.getMembers()) {
if (partychar.getMapid() == getMapId() && partychar.getChannel() == channel) {
MapleCharacter other = ChannelServer.getInstance(channel).getPlayerStorage().getCharacterByName(partychar.getName());
if (other != null) {
client.getSession().write(MaplePacketCreator.updatePartyMemberHP(other.getId(), other.getHp(), other.getCurrentMaxHp()));
}
}
}
}
}
public void registerEffect(MapleStatEffect effect, long starttime, ScheduledFuture<?> schedule) {
if (effect.isHide() && gmLevel > 1) {
this.hidden = true;
getMap().broadcastNONGMMessage(this, MaplePacketCreator.removePlayerFromMap(getId()), false);
} else if (effect.isDragonBlood()) {
prepareDragonBlood(effect);
} else if (effect.isBerserk()) {
checkBerserk();
} else if (effect.isBeholder()) {
final int beholder = DarkKnight.BEHOLDER;
if (beholderHealingSchedule != null) {
beholderHealingSchedule.cancel(false);
}
if (beholderBuffSchedule != null) {
beholderBuffSchedule.cancel(false);
}
ISkill bHealing = SkillFactory.getSkill(DarkKnight.AURA_OF_BEHOLDER);
int bHealingLvl = getSkillLevel(bHealing);
if (bHealingLvl > 0) {
final MapleStatEffect healEffect = bHealing.getEffect(bHealingLvl);
int healInterval = healEffect.getX() * 1000;
beholderHealingSchedule = TimerManager.getInstance().register(new Runnable() {
@Override
public void run() {
addHP(healEffect.getHp());
client.getSession().write(MaplePacketCreator.showOwnBuffEffect(beholder, 2));
getMap().broadcastMessage(MapleCharacter.this, MaplePacketCreator.summonSkill(getId(), beholder, 5), true);
getMap().broadcastMessage(MapleCharacter.this, MaplePacketCreator.showOwnBuffEffect(beholder, 2), false);
}
}, healInterval, healInterval);
}
ISkill bBuff = SkillFactory.getSkill(DarkKnight.HEX_OF_BEHOLDER);
if (getSkillLevel(bBuff) > 0) {
final MapleStatEffect buffEffect = bBuff.getEffect(getSkillLevel(bBuff));
int buffInterval = buffEffect.getX() * 1000;
beholderBuffSchedule = TimerManager.getInstance().register(new Runnable() {
@Override
public void run() {
buffEffect.applyTo(MapleCharacter.this);
client.getSession().write(MaplePacketCreator.showOwnBuffEffect(beholder, 2));
getMap().broadcastMessage(MapleCharacter.this, MaplePacketCreator.summonSkill(getId(), beholder, (int) (Math.random() * 3) + 6), true);
getMap().broadcastMessage(MapleCharacter.this, MaplePacketCreator.showBuffeffect(getId(), beholder, 2), false);
}
}, buffInterval, buffInterval);
}
}
for (Pair<MapleBuffStat, Integer> statup : effect.getStatups()) {
effects.put(statup.getLeft(), new MapleBuffStatValueHolder(effect, starttime, schedule, statup.getRight().intValue()));
}
recalcLocalStats();
}
public void removeAllCooldownsExcept(int id) {
for (MapleCoolDownValueHolder mcvh : coolDowns.values()) {
if (mcvh.skillId != id) {
coolDowns.remove(mcvh.skillId);
}
}
}
public static void removeAriantRoom(int room) {
ariantroomleader[room] = "";
ariantroomslot[room] = 0;
}
public void removeBuffStat(MapleBuffStat effect) {
effects.remove(effect);
}
public void removeCooldown(int skillId) {
if (this.coolDowns.containsKey(skillId)) {
this.coolDowns.remove(skillId);
}
}
public void removeDisease(MapleDisease disease) {
synchronized (diseases) {
if (diseases.contains(disease)) {
diseases.remove(disease);
}
}
}
public void removeDiseases() {
diseases.clear();
}
public void removePet(MaplePet pet, boolean shift_left) {
int slot = -1;
for (int i = 0; i < 3; i++) {
if (pets[i] != null) {
if (pets[i].getUniqueId() == pet.getUniqueId()) {
pets[i] = null;
slot = i;
break;
}
}
}
if (shift_left) {
if (slot > -1) {
for (int i = slot; i < 3; i++) {
if (i != 2) {
pets[i] = pets[i + 1];
} else {
pets[i] = null;
}
}
}
}
}
public void removeVisibleMapObject(MapleMapObject mo) {
visibleMapObjects.remove(mo);
}
public void resetBattleshipHp() {
this.battleshipHp = 4000 * getSkillLevel(SkillFactory.getSkill(Corsair.BATTLE_SHIP)) + ((getLevel() - 120) * 2000);
}
public void resetEnteredScript() {
if (entered.containsKey(map.getId())) {
entered.remove(map.getId());
}
}
public void resetEnteredScript(int mapId) {
if (entered.containsKey(mapId)) {
entered.remove(mapId);
}
}
public void resetEnteredScript(String script) {
for (int mapId : entered.keySet()) {
if (entered.get(mapId).equals(script)) {
entered.remove(mapId);
}
}
}
public void resetMGC() {
this.mgc = null;
}
public void saveCooldowns() {
if (getAllCooldowns().size() > 0) {
try {
PreparedStatement ps = DatabaseConnection.getConnection().prepareStatement("INSERT INTO cooldowns (charid, SkillID, StartTime, length) VALUES (?, ?, ?, ?)");
ps.setInt(1, getId());
for (PlayerCoolDownValueHolder cooling : getAllCooldowns()) {
ps.setInt(2, cooling.skillId);
ps.setLong(3, cooling.startTime);
ps.setLong(4, cooling.length);
ps.addBatch();
}
ps.executeBatch();
ps.close();
} catch (SQLException se) {
}
}
}
public int getTotalMdef() {
return mdef;
}
public int getTotalWdef() {
return wdef;
}
public int getPvpKills() {
return pvpKills;
}
public int getPvpDeaths() {
return pvpDeaths;
}
public void gainPvpDeath() {
this.pvpDeaths += 1;
}
public void gainPvpKill() {
this.pvpKills += 1;
}
public void saveGuildStatus() {
try {
PreparedStatement ps = DatabaseConnection.getConnection().prepareStatement("UPDATE characters SET guildid = ?, guildrank = ?, allianceRank = ? WHERE id = ?");
ps.setInt(1, guildid);
ps.setInt(2, guildrank);
ps.setInt(3, allianceRank);
ps.setInt(4, id);
ps.execute();
ps.close();
} catch (SQLException se) {
}
}
public void saveLocation(String type) {
MaplePortal closest = map.findClosestPortal(getPosition());
savedLocations[SavedLocationType.fromString(type).ordinal()] = new SavedLocation(getMapId(), closest != null ? closest.getId() : 0);
}
public void saveToDB(boolean update) {
Connection con = DatabaseConnection.getConnection();
try {
con.setTransactionIsolation(Connection.TRANSACTION_READ_UNCOMMITTED);
con.setAutoCommit(false);
PreparedStatement ps;
if (update) {
ps = con.prepareStatement("UPDATE characters SET level = ?, fame = ?, str = ?, dex = ?, luk = ?, `int` = ?, exp = ?, hp = ?, mp = ?, maxhp = ?, maxmp = ?, sp = ?, ap = ?, gm = ?, skincolor = ?, gender = ?, job = ?, hair = ?, face = ?, map = ?, meso = ?, hpMpUsed = ?, spawnpoint = ?, party = ?, buddyCapacity = ?, messengerid = ?, messengerposition = ?, mountlevel = ?, mountexp = ?, mounttiredness= ?, equipslots = ?, useslots = ?, setupslots = ?, etcslots = ?, monsterbookcover = ?, cygnuslink = ?, watchedcygnusintro = ?, vanquisherStage = ?, dojoPoints = ?, lastDojoStage = ?, finishedDojoTutorial = ?, vanquisherKills = ?, matchcardwins = ?, matchcardlosses = ?, matchcardties = ?, muteLevel = ?, omokwins = ?, omoklosses = ?, omokties = ?, occupation = ?, reborns = ?, creborns = ?, damagerecord = ?, name = ? WHERE id = ?");
} else {
ps = con.prepareStatement("INSERT INTO characters (level, fame, str, dex, luk, `int`, exp, hp, mp, maxhp, maxmp, sp, ap, gm, skincolor, gender, job, hair, face, map, meso, hpMpUsed, spawnpoint, party, buddyCapacity, messengerid, messengerposition, mountlevel, mounttiredness, mountexp, equipslots, useslots, setupslots, etcslots, monsterbookcover, cygnuslink, watchedcygnusintro, vanquisherStage, dojopoints, lastDojoStage, finishedDojoTutorial, vanquisherKills, matchcardwins, matchcardlosses, matchcardties, muteLevel, omokwins, omoklosses, omokties, occupation, reborns, damagerecord, creborns, accountid, name, world) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)");
}
if (gmLevel < 2 && level > 199) { //I don't really get this...
ps.setInt(1, isCygnus() ? ChannelServer.CygnusLevelCap() : ChannelServer.LevelCap());
} else {
ps.setInt(1, level);
}
ps.setInt(2, fame);
ps.setInt(3, str);
ps.setInt(4, dex);
ps.setInt(5, luk);
ps.setInt(6, int_);
ps.setInt(7, Math.abs(exp.get()));
ps.setInt(8, hp);
ps.setInt(9, mp);
ps.setInt(10, maxhp);
ps.setInt(11, maxmp);
ps.setInt(12, remainingSp);
ps.setInt(13, remainingAp);
ps.setInt(14, gmLevel);
ps.setInt(15, skinColor.getId());
ps.setInt(16, gender);
ps.setInt(17, job.getId());
ps.setInt(18, hair);
ps.setInt(19, face);
if (map == null) {
ps.setInt(20, 0);
} else if (map.getForcedReturnId() != 999999999) {
ps.setInt(20, map.getForcedReturnId());
} else {
ps.setInt(20, map.getId());
}
ps.setInt(21, meso.get());
ps.setInt(22, hpMpApUsed);
if (map == null || map.getId() == 610020000 || map.getId() == 610020001) {
ps.setInt(23, 0);
} else {
MaplePortal closest = map.findClosestSpawnpoint(getPosition());
if (closest != null) {
ps.setInt(23, closest.getId());
} else {
ps.setInt(23, 0);
}
}
if (party != null) {
ps.setInt(24, party.getId());
} else {
ps.setInt(24, -1);
}
ps.setInt(25, buddylist.getCapacity());
if (messenger != null) {
ps.setInt(26, messenger.getId());
ps.setInt(27, messengerposition);
} else {
ps.setInt(26, 0);
ps.setInt(27, 4);
}
if (maplemount != null) {
ps.setInt(28, maplemount.getLevel());
ps.setInt(29, maplemount.getExp());
ps.setInt(30, maplemount.getTiredness());
} else {
ps.setInt(28, 1);
ps.setInt(29, 0);
ps.setInt(30, 0);
}
for (int i = 31; i < 35; i++) {
ps.setInt(i, getInventory(MapleInventoryType.getByType((byte) (i - 30))).getSlotLimit());
}
if (update) {
monsterbook.saveCards(getId());
}
ps.setInt(35, bookCover);
ps.setInt(36, cygnusLinkId);
ps.setInt(37, watchedCygnusIntro ? 1 : 0);
ps.setInt(38, vanquisherStage);
ps.setInt(39, dojoPoints);
ps.setInt(40, dojoStage);
ps.setInt(41, finishedDojoTutorial ? 1 : 0);
ps.setInt(42, vanquisherKills);
ps.setInt(43, matchcardwins);
ps.setInt(44, matchcardlosses);
ps.setInt(45, matchcardties);
ps.setInt(46, muteLevel);
ps.setInt(47, omokwins);
ps.setInt(48, omoklosses);
ps.setInt(49, omokties);
ps.setInt(50, occupation.getId());
ps.setInt(51, reborns);
ps.setInt(52, damagerecord);
ps.setInt(53, creborns);
if (update) {
ps.setString(54, name);
ps.setInt(55, id);
} else {
ps.setInt(54, accountid);
ps.setString(55, name);
ps.setInt(56, world);
}
int updateRows = ps.executeUpdate();
if (!update) {
ResultSet rs = ps.getGeneratedKeys();
if (rs.next()) {
this.id = rs.getInt(1);
} else {
throw new RuntimeException("Inserting char failed.");
}
} else if (updateRows < 1) {
throw new RuntimeException("Character not in database (" + id + ")");
}
for (int i = 0; i < 3; i++) {
if (pets[i] != null) {
pets[i].saveToDb();
}
}
deleteWhereCharacterId(con, "DELETE FROM keymap WHERE characterid = ?");
ps = con.prepareStatement("INSERT INTO keymap (characterid, `key`, `type`, `action`) VALUES (?, ?, ?, ?)");
ps.setInt(1, id);
for (Entry<Integer, MapleKeyBinding> keybinding : keymap.entrySet()) {
ps.setInt(2, keybinding.getKey().intValue());
ps.setInt(3, keybinding.getValue().getType());
ps.setInt(4, keybinding.getValue().getAction());
ps.addBatch();
}
ps.executeBatch();
deleteWhereCharacterId(con, "DELETE FROM skillmacros WHERE characterid = ?");
ps = con.prepareStatement("INSERT INTO skillmacros (characterid, skill1, skill2, skill3, name, shout, position) VALUES (?, ?, ?, ?, ?, ?, ?)");
ps.setInt(1, getId());
for (int i = 0; i < 5; i++) {
SkillMacro macro = skillMacros[i];
if (macro != null) {
ps.setInt(2, macro.getSkill1());
ps.setInt(3, macro.getSkill2());
ps.setInt(4, macro.getSkill3());
ps.setString(5, macro.getName());
ps.setInt(6, macro.getShout());
ps.setInt(7, i);
ps.addBatch();
}
}
ps.executeBatch();
deleteWhereCharacterId(con, "DELETE FROM inventoryitems WHERE characterid = ?");
ps = con.prepareStatement("INSERT INTO inventoryitems (characterid, itemid, inventorytype, position, quantity, owner, petid, expiredate) VALUES (?, ?, ?, ?, ?, ?, ?, ?)");
PreparedStatement pse = con.prepareStatement("INSERT INTO inventoryequipment VALUES (DEFAULT, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)");
for (MapleInventory iv : inventory) {
ps.setInt(3, iv.getType().getType());
for (IItem item : iv.list()) {
ps.setInt(1, id);
ps.setInt(2, item.getItemId());
ps.setInt(4, item.getPosition());
ps.setInt(5, item.getQuantity());
ps.setString(6, item.getOwner());
ps.setInt(7, item.getPetId());
ps.setLong(8, item.getExpiration());
ps.executeUpdate();
ResultSet rs = ps.getGeneratedKeys();
int itemid;
if (rs.next()) {
itemid = rs.getInt(1);
} else {
rs.close();
throw new RuntimeException("Inserting char failed.");
}
if (iv.getType().equals(MapleInventoryType.EQUIP) || iv.getType().equals(MapleInventoryType.EQUIPPED)) {
pse.setInt(1, itemid);
IEquip equip = (IEquip) item;
pse.setInt(2, equip.getUpgradeSlots());
pse.setInt(3, equip.getLevel());
pse.setInt(4, equip.getStr());
pse.setInt(5, equip.getDex());
pse.setInt(6, equip.getInt());
pse.setInt(7, equip.getLuk());
pse.setInt(8, equip.getHp());
pse.setInt(9, equip.getMp());
pse.setInt(10, equip.getWatk());
pse.setInt(11, equip.getMatk());
pse.setInt(12, equip.getWdef());
pse.setInt(13, equip.getMdef());
pse.setInt(14, equip.getAcc());
pse.setInt(15, equip.getAvoid());
pse.setInt(16, equip.getHands());
pse.setInt(17, equip.getSpeed());
pse.setInt(18, equip.getJump());
pse.setInt(19, equip.getRingId());
pse.setInt(20, 0);
pse.setInt(21, equip.getVicious());
pse.setInt(22, item.getFlag());
pse.setInt(23, equip.getItemExp());
pse.executeUpdate();
}
rs.close();
}
}
pse.close();
deleteWhereCharacterId(con, "DELETE FROM skills WHERE characterid = ?");
ps = con.prepareStatement("INSERT INTO skills (characterid, skillid, skilllevel, masterlevel) VALUES (?, ?, ?, ?)");
ps.setInt(1, id);
for (Entry<ISkill, SkillEntry> SKILLZ : skills.entrySet()) {
ps.setInt(2, SKILLZ.getKey().getId());
ps.setInt(3, SKILLZ.getValue().skillevel);
ps.setInt(4, SKILLZ.getValue().masterlevel);
ps.addBatch();
}
ps.executeBatch();
deleteWhereCharacterId(con, "DELETE FROM savedlocations WHERE characterid = ?");
ps = con.prepareStatement("INSERT INTO savedlocations (characterid, `locationtype`, `map`, `portal`) VALUES (?, ?, ?, ?)");
ps.setInt(1, id);
for (SavedLocationType savedLocationType : SavedLocationType.values()) {
if (savedLocations[savedLocationType.ordinal()] != null) {
ps.setString(2, savedLocationType.name());
ps.setInt(3, savedLocations[savedLocationType.ordinal()].getMapId());
ps.setInt(4, savedLocations[savedLocationType.ordinal()].getPortal());
ps.addBatch();
}
}
ps.executeBatch();
deleteWhereCharacterId(con, "DELETE FROM buddies WHERE characterid = ? AND pending = 0");
ps = con.prepareStatement("INSERT INTO buddies (characterid, `buddyid`, `pending`, `group`) VALUES (?, ?, 0, ?)");
ps.setInt(1, id);
for (BuddylistEntry entry : buddylist.getBuddies()) {
if (entry.isVisible()) {
ps.setInt(2, entry.getCharacterId());
ps.setString(3, entry.getGroup());
ps.addBatch();
}
}
ps.executeBatch();
deleteWhereCharacterId(con, "DELETE FROM queststatus WHERE characterid = ?");
ps = con.prepareStatement("INSERT INTO queststatus (`queststatusid`, `characterid`, `quest`, `status`, `time`, `forfeited`) VALUES (DEFAULT, ?, ?, ?, ?, ?)", Statement.RETURN_GENERATED_KEYS);
pse = con.prepareStatement("INSERT INTO queststatusmobs VALUES (DEFAULT, ?, ?, ?)");
ps.setInt(1, id);
for (MapleQuestStatus q : quests.values()) {
ps.setInt(2, q.getQuest().getId());
ps.setInt(3, q.getStatus().getId());
ps.setInt(4, (int) (q.getCompletionTime() / 1000));
ps.setInt(5, q.getForfeited());
ps.executeUpdate();
ResultSet rs = ps.getGeneratedKeys();
rs.next();
for (int mob : q.getMobKills().keySet()) {
pse.setInt(1, rs.getInt(1));
pse.setInt(2, mob);
pse.setInt(3, q.getMobKills(mob));
pse.addBatch();
}
pse.executeBatch();
rs.close();
}
pse.close();
ps = con.prepareStatement("UPDATE accounts SET `paypalNX` = ?, `votingpoints` = ?, `mPoints` = ?, `cardNX` = ?, gm = ? WHERE id = ?");
ps.setInt(1, paypalnx);
ps.setInt(2, votingpoints);
ps.setInt(3, maplepoints);
ps.setInt(4, cardnx);
ps.setInt(5, gmLevel);
ps.setInt(6, client.getAccID());
ps.executeUpdate();
if (storage != null) {
storage.saveToDB();
}
if (update) {
ps = con.prepareStatement("DELETE FROM achievements WHERE accountid = ?");
ps.setInt(1, accountid);
ps.executeUpdate();
ps.close();
for (Integer achid : finishedAchievements) {
ps = con.prepareStatement("INSERT INTO achievements(charid, achievementid, accountid) VALUES(?, ?, ?)");
ps.setInt(1, id);
ps.setInt(2, achid);
ps.setInt(3, accountid);
ps.executeUpdate();
ps.close();
}
}
ps = con.prepareStatement("DELETE FROM wishlist WHERE `charid` = ?");
ps.setInt(1, id);
ps.executeUpdate();
ps = con.prepareStatement("INSERT INTO wishlist(`sn`, `charid`) VALUES(?, ?)");
for (int sn : wishList) {
ps.setInt(1, sn);
ps.setInt(2, id);
ps.addBatch();
}
ps.executeBatch();
ps.close();
if (gmLevel > 1) {
ps = con.prepareStatement("INSERT INTO gmlog (`cid`, `command`) VALUES (?, ?)");
ps.setInt(1, id);
for (String com : commands) {
ps.setString(2, com);
ps.addBatch();
}
ps.executeBatch();
}
ps.close();
con.commit();
} catch (Exception e) {
e.printStackTrace();
try {
con.rollback();
} catch (SQLException se) {
}
} finally {
try {
con.setAutoCommit(true);
con.setTransactionIsolation(Connection.TRANSACTION_REPEATABLE_READ);
} catch (Exception e) {
}
}
}
public void sendKeymap() {
client.getSession().write(MaplePacketCreator.getKeymap(keymap));
}
public void sendMacros() {
boolean macros = false;
for (int i = 0; i < 5; i++) {
if (skillMacros[i] != null) {
macros = true;
}
}
if (macros) {
client.getSession().write(MaplePacketCreator.getMacros(skillMacros));
}
}
public void sendNote(String to, String msg) throws SQLException {
PreparedStatement ps = DatabaseConnection.getConnection().prepareStatement("INSERT INTO notes (`to`, `from`, `message`, `timestamp`) VALUES (?, ?, ?, ?)");
ps.setString(1, to);
ps.setString(2, this.getName());
ps.setString(3, msg);
ps.setLong(4, System.currentTimeMillis());
ps.executeUpdate();
ps.close();
}
public void setAllianceRank(int rank) {
allianceRank = rank;
if (mgc != null) {
mgc.setAllianceRank(rank);
}
}
public int getMuteLevel() {
return muteLevel;
}
public void setMuteLevel(int mlvl) {
this.muteLevel = mlvl;
}
public int[] getOccupationRates() { // Edit to your likings...
int exprate = 0;
int mesorate = 0;
int droprate = 0;
if (getOccupation().isA(MapleOccupations.Specialist)) {
exprate = (ChannelServer.loadExpFromProp() * 3);
mesorate = (ChannelServer.loadMesoFromProp() * 3);
droprate = (ChannelServer.loadDropFromProp() * 3);
} else if (getOccupation().isA(MapleOccupations.BlackOp)) {
exprate = ChannelServer.loadExpFromProp() * 4;
mesorate = ChannelServer.loadMesoFromProp() * 2;
droprate = ChannelServer.loadDropFromProp() * 2;
} else if (getOccupation().isA(MapleOccupations.Sinner)) {
exprate = ChannelServer.loadExpFromProp();
mesorate = ChannelServer.loadMesoFromProp() * 4;
droprate = ChannelServer.loadDropFromProp() * 5;
} else if (getOccupation().isA(MapleOccupations.Businessman)) {
exprate = ChannelServer.loadExpFromProp();
mesorate = ChannelServer.loadMesoFromProp() * 5;
droprate = ChannelServer.loadDropFromProp() * 4;
} else if (getOccupation().isA(MapleOccupations.GM)) {
if (isGM()) {
exprate = ChannelServer.loadExpFromProp() * 1337;
mesorate = ChannelServer.loadMesoFromProp() * 1337;
droprate = ChannelServer.loadDropFromProp() * 1337;
} else {
exprate = ChannelServer.loadExpFromProp() / 2;
mesorate = ChannelServer.loadMesoFromProp() / 2;
droprate = ChannelServer.loadDropFromProp() / 2;
}
} else if (getOccupation().isA(MapleOccupations.Sacrificer)) {
exprate = ChannelServer.loadExpFromProp() / 2;
mesorate = ChannelServer.loadMesoFromProp() * 6;
droprate = ChannelServer.loadDropFromProp() * 6;
} else if (getOccupation().isA(MapleOccupations.NOJOB)) {
exprate = ChannelServer.loadExpFromProp();
mesorate = ChannelServer.loadMesoFromProp();
droprate = ChannelServer.loadDropFromProp();
} else {
exprate = ChannelServer.loadExpFromProp();
mesorate = ChannelServer.loadMesoFromProp();
droprate = ChannelServer.loadDropFromProp();
}
return new int[]{exprate, mesorate, droprate};
}
public int getExpRate() {
return getOccupationRates()[0];
}
public int getMesoRate() {
return getOccupationRates()[1];
}
public int getDropRate() {
return getOccupationRates()[2];
}
public void setAllowWarpToId(int id) {
this.warpToId = id;
}
public static void setAriantRoomLeader(int room, String charname) {
ariantroomleader[room] = charname;
}
public static void setAriantSlotRoom(int room, int slot) {
ariantroomslot[room] = slot;
}
public void setBattleshipHp(int battleshipHp) {
this.battleshipHp = battleshipHp;
}
public void setBuddyCapacity(int capacity) {
buddylist.setCapacity(capacity);
client.getSession().write(MaplePacketCreator.updateBuddyCapacity(capacity));
}
public void setBuffedValue(MapleBuffStat effect, int value) {
MapleBuffStatValueHolder mbsvh = effects.get(effect);
if (mbsvh == null) {
return;
}
mbsvh.value = value;
}
public void setChair(int chair) {
this.chair = chair;
}
public void setChalkboard(String text) {
this.chalktext = text;
}
public void setCygnusLinkId(int id) {
this.cygnusLinkId = id;
}
public void setDex(int dex) {
this.dex = dex;
recalcLocalStats();
}
public void setDojoEnergy(int x) {
this.dojoEnergy = x;
}
public void setDojoParty(boolean b) {
this.dojoParty = b;
}
public void setDojoPoints(int x) {
this.dojoPoints = x;
}
public void setDojoStage(int x) {
this.dojoStage = x;
}
public void setDojoStart() {
this.dojoMap = map;
int stage = (map.getId() / 100) % 100;
this.dojoFinish = System.currentTimeMillis() + (stage > 36 ? 15 : stage / 6 + 5) * 60000;
}
public void setRates() {
Calendar cal = Calendar.getInstance();
cal.setTimeZone(TimeZone.getTimeZone("GMT-8"));
this.dropRate = ServerConstants.DROP_RATE;
this.mesoRate = ServerConstants.MESO_RATE;
this.expRate = ServerConstants.EXP_RATE;
}
public void setEnergyBar(int set) {
energybar = set;
}
public void setEventInstance(EventInstanceManager eventInstance) {
this.eventInstance = eventInstance;
}
public void setExp(int amount) {
this.exp.set(amount);
}
public void setFace(int face) {
this.face = face;
}
public void setFame(int fame) {
this.fame = fame;
}
public void setFamilyId(int familyId) {
this.familyId = familyId;
}
public void setFinishedDojoTutorial() {
this.finishedDojoTutorial = true;
}
public void setGender(int gender) {
this.gender = gender;
}
public void setGM(int level) {
this.gmLevel = level;
}
public void setGuildId(int _id) {
guildid = _id;
if (guildid > 0) {
if (mgc == null) {
mgc = new MapleGuildCharacter(this);
} else {
mgc.setGuildId(guildid);
}
} else {
mgc = null;
}
}
public void setGuildRank(int _rank) {
guildrank = _rank;
if (mgc != null) {
mgc.setGuildRank(_rank);
}
}
public void setHair(int hair) {
this.hair = hair;
}
public void setHasMerchant(boolean set) {
try {
PreparedStatement ps = DatabaseConnection.getConnection().prepareStatement("UPDATE characters SET HasMerchant = ? WHERE id = ?");
ps.setInt(1, set ? 1 : 0);
ps.setInt(2, id);
ps.executeUpdate();
ps.close();
} catch (SQLException e) {
return;
}
hasMerchant = set;
}
public void setHiredMerchant(HiredMerchant merchant) {
this.hiredMerchant = merchant;
}
public void setHp(int newhp) {
setHp(newhp, false);
}
public void setHp(int newhp, boolean silent) {
int oldHp = hp;
int thp = newhp;
if (thp < 0) {
thp = 0;
}
if (thp > localmaxhp) {
thp = localmaxhp;
}
this.hp = thp;
if (!silent) {
updatePartyMemberHP();
}
if (oldHp > hp && !isAlive()) {
playerDead();
}
}
public void setHpMpApUsed(int mpApUsed) {
this.hpMpApUsed = mpApUsed;
}
public void setHpMp(int x) {
setHp(x);
setMp(x);
updateSingleStat(MapleStat.HP, hp);
updateSingleStat(MapleStat.MP, mp);
}
public void setInCS(boolean b) {
this.incs = b;
}
public void setInMTS(boolean b) {
this.inmts = b;
}
public void setInt(int int_) {
this.int_ = int_;
recalcLocalStats();
}
public void setItemEffect(int itemEffect) {
this.itemEffect = itemEffect;
}
public void setJob(MapleJob job) {
this.job = job;
}
public void setLastHealed(long time) {
this.lastHealed = time;
}
public void setLastUsedCashItem(long time) {
this.lastUsedCashItem = time;
}
public void setLevel(int level) {
this.level = level;
}
public void setLuk(int luk) {
this.luk = luk;
recalcLocalStats();
}
public void setMap(int PmapId) {
this.mapid = PmapId;
}
public void setMap(MapleMap newmap) {
this.map = newmap;
}
public String getMapName(int mapId) {
return client.getChannelServer().getMapFactory().getMap(mapId).getMapName();
}
public void setMarkedMonster(int markedMonster) {
this.markedMonster = markedMonster;
}
public void setMaxHp(int hp) {
this.maxhp = hp;
recalcLocalStats();
}
public void setMaxMp(int mp) {
this.maxmp = mp;
recalcLocalStats();
}
public void setMessenger(MapleMessenger messenger) {
this.messenger = messenger;
}
public void setMessengerPosition(int position) {
this.messengerposition = position;
}
public void setMiniGame(MapleMiniGame miniGame) {
this.miniGame = miniGame;
}
public void setMiniGamePoints(MapleCharacter visitor, int winnerslot, boolean omok) {
if (omok) {
if (winnerslot == 1) {
this.omokwins++;
visitor.omoklosses++;
} else if (winnerslot == 2) {
visitor.omokwins++;
this.omoklosses++;
} else {
this.omokties++;
visitor.omokties++;
}
} else {
if (winnerslot == 1) {
this.matchcardwins++;
visitor.matchcardlosses++;
} else if (winnerslot == 2) {
visitor.matchcardwins++;
this.matchcardlosses++;
} else {
this.matchcardties++;
visitor.matchcardties++;
}
}
}
public void setMonsterBookCover(int bookCover) {
this.bookCover = bookCover;
}
public void setMp(int newmp) {
int tmp = newmp;
if (tmp < 0) {
tmp = 0;
}
if (tmp > localmaxmp) {
tmp = localmaxmp;
}
this.mp = tmp;
}
public void setName(String name) {
this.name = name;
}
public void setParty(MapleParty party) {
this.party = party;
}
public void setPlayerShop(MaplePlayerShop playerShop) {
this.playerShop = playerShop;
}
public void setRemainingAp(int remainingAp) {
this.remainingAp = remainingAp;
}
public void setRemainingSp(int remainingSp) {
this.remainingSp = remainingSp;
}
public void setSearch(String find) {
search = find;
}
public void setSkinColor(MapleSkinColor skinColor) {
this.skinColor = skinColor;
}
public void setShop(MapleShop shop) {
this.shop = shop;
}
public void setSlot(int slotid) {
slots = slotid;
}
public void setStr(int str) {
this.str = str;
recalcLocalStats();
}
public void setTrade(MapleTrade trade) {
this.trade = trade;
}
public void setVanquisherKills(int x) {
this.vanquisherKills = x;
}
public void setVanquisherStage(int x) {
this.vanquisherStage = x;
}
public void setWatchedCygnusIntro(boolean set) {
this.watchedCygnusIntro = set;
}
public void setWorld(int world) {
this.world = world;
}
public void shiftPetsRight() {
if (pets[2] == null) {
pets[2] = pets[1];
pets[1] = pets[0];
pets[0] = null;
}
}
public void showDojoClock() {
int stage = (map.getId() / 100) % 100;
long time;
if (stage % 6 == 1) {
time = (stage > 36 ? 15 : stage / 6 + 5) * 60;
} else {
time = (dojoFinish - System.currentTimeMillis()) / 1000;
}
if (stage % 6 > 0) {
client.getSession().write(MaplePacketCreator.getClock((int) time));
}
boolean rightmap = true;
int clockid = (dojoMap.getId() / 100) % 100;
if (map.getId() > clockid / 6 * 6 + 6 || map.getId() < clockid / 6 * 6) {
rightmap = false;
}
final boolean rightMap = rightmap; // lol
TimerManager.getInstance().schedule(new Runnable() {
@Override
public void run() {
if (rightMap) {
client.getPlayer().changeMap(client.getChannelServer().getMapFactory().getMap(925020000));
}
}
}, time * 1000 + 3000); // let the TIMES UP display for 3 seconds, then warp
}
public void showNote() {
try {
PreparedStatement ps = DatabaseConnection.getConnection().prepareStatement("SELECT * FROM notes WHERE `to`=?", ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE);
ps.setString(1, this.getName());
ResultSet rs = ps.executeQuery();
rs.last();
rs.first();
client.getSession().write(MaplePacketCreator.showNotes(rs, rs.getRow()));
rs.close();
ps.close();
} catch (SQLException e) {
}
}
private void silentEnforceMaxHpMp() {
setMp(getMp());
setHp(getHp(), true);
}
public void silentGiveBuffs(List<PlayerBuffValueHolder> buffs) {
for (PlayerBuffValueHolder mbsvh : buffs) {
mbsvh.effect.silentApplyBuff(this, mbsvh.startTime);
}
}
public void silentPartyUpdate() {
if (party != null) {
try {
client.getChannelServer().getWorldInterface().updateParty(party.getId(), PartyOperation.SILENT_UPDATE, new MaplePartyCharacter(this));
} catch (RemoteException e) {
e.printStackTrace();
client.getChannelServer().reconnectWorld();
}
}
}
public static class SkillEntry {
public int skillevel, masterlevel;
public SkillEntry(int skillevel, int masterlevel) {
this.skillevel = skillevel;
this.masterlevel = masterlevel;
}
@Override
public String toString() {
return skillevel + ":" + masterlevel;
}
}
public boolean skillisCooling(int skillId) {
return coolDowns.containsKey(Integer.valueOf(skillId));
}
public void startCygnusIntro() {
client.getSession().write(MaplePacketCreator.cygnusIntroDisableUI(true));
client.getSession().write(MaplePacketCreator.cygnusIntroLock(true));
saveLocation("CYGNUSINTRO");
MapleMap introMap = client.getChannelServer().getMapFactory().getMap(913040000);
changeMap(introMap, introMap.getPortal(0));
TimerManager.getInstance().schedule(new Runnable() {
@Override
public void run() {
client.getSession().write(MaplePacketCreator.cygnusIntroDisableUI(false));
client.getSession().write(MaplePacketCreator.cygnusIntroLock(false));
}
}, 54 * 1000);
savedLocations[SavedLocationType.CYGNUSINTRO.ordinal()] = null;
}
public void startFullnessSchedule(final int decrease, final MaplePet pet, int petSlot) {
ScheduledFuture<?> schedule = TimerManager.getInstance().register(new Runnable() {
@Override
public void run() {
int newFullness = pet.getFullness() - decrease;
if (newFullness <= 5) {
pet.setFullness(15);
pet.saveToDb();
unequipPet(pet, true, true);
} else {
pet.setFullness(newFullness);
client.getSession().write(MaplePacketCreator.updatePet(pet));
}
}
}, 180000, 18000);
switch (petSlot) {
case 0:
fullnessSchedule = schedule;
break;
case 1:
fullnessSchedule_1 = schedule;
break;
case 2:
fullnessSchedule_2 = schedule;
break;
}
}
public void startMapEffect(String msg, int itemId) {
startMapEffect(msg, itemId, 30000);
}
public void startMapEffect(String msg, int itemId, int duration) {
final MapleMapEffect mapEffect = new MapleMapEffect(msg, itemId);
getClient().getSession().write(mapEffect.makeStartData());
TimerManager.getInstance().schedule(new Runnable() {
@Override
public void run() {
getClient().getSession().write(mapEffect.makeDestroyData());
}
}, duration);
}
public void startMapTimeLimitTask(final MapleMap from, final MapleMap to) {
if (to.getTimeLimit() > 0 && from != null) {
final MapleCharacter chr = this;
mapTimeLimitTask = TimerManager.getInstance().register(new Runnable() {
@Override
public void run() {
MaplePortal pfrom = null;
int id = from.getId();
if (id == 100020000 || id == 105040304 || id == 105050100 || id == 221023400) {
pfrom = from.getPortal("MD00");
} else {
pfrom = from.getPortal(0);
}
if (pfrom != null) {
chr.changeMap(from, pfrom);
}
}
}, from.getTimeLimit() * 1000, from.getTimeLimit() * 1000);
}
}
public void stopControllingMonster(MapleMonster monster) {
controlled.remove(monster);
}
public void toggleGMChat() {
whitechat = !whitechat;
}
public void unequipAllPets() {
for (int i = 0; i < 3; i++) {
if (pets[i] != null) {
unequipPet(pets[i], true);
cancelFullnessSchedule(i);
} else {
break;
}
}
}
public void unequipPet(MaplePet pet, boolean shift_left) {
unequipPet(pet, shift_left, false);
}
public void unequipPet(MaplePet pet, boolean shift_left, boolean hunger) {
if (this.getPet(this.getPetIndex(pet)) != null) {
this.getPet(this.getPetIndex(pet)).saveToDb();
}
cancelFullnessSchedule(getPetIndex(pet));
getMap().broadcastMessage(this, MaplePacketCreator.showPet(this, pet, true, hunger), true);
List<Pair<MapleStat, Integer>> stats = new ArrayList<Pair<MapleStat, Integer>>();
stats.add(new Pair<MapleStat, Integer>(MapleStat.PET, Integer.valueOf(0)));
client.getSession().write(MaplePacketCreator.petStatUpdate(this));
client.getSession().write(MaplePacketCreator.enableActions());
removePet(pet, shift_left);
}
public void updateMacros(int position, SkillMacro updateMacro) {
skillMacros[position] = updateMacro;
}
public void updatePartyMemberHP() {
if (party != null) {
int channel = client.getChannel();
for (MaplePartyCharacter partychar : party.getMembers()) {
if (partychar.getMapid() == getMapId() && partychar.getChannel() == channel) {
MapleCharacter other = ChannelServer.getInstance(channel).getPlayerStorage().getCharacterByName(partychar.getName());
if (other != null) {
other.getClient().getSession().write(MaplePacketCreator.updatePartyMemberHP(getId(), this.hp, localmaxhp));
}
}
}
}
}
public void updateQuest(MapleQuestStatus quest) {
this.updateQuest(quest);
quests.put(quest.getQuest(), quest);
if (quest.getStatus().equals(MapleQuestStatus.Status.STARTED)) {
client.getSession().write(MaplePacketCreator.startQuest(this, (short) quest.getQuest().getId()));
client.getSession().write(MaplePacketCreator.updateQuestInfo(this, (short) quest.getQuest().getId(), quest.getNpc(), (byte) 8));
} else if (quest.getStatus().equals(MapleQuestStatus.Status.COMPLETED)) {
client.getSession().write(MaplePacketCreator.completeQuest(this, (short) quest.getQuest().getId()));
} else if (quest.getStatus().equals(MapleQuestStatus.Status.NOT_STARTED)) {
client.getSession().write(MaplePacketCreator.forfeitQuest(this, (short) quest.getQuest().getId()));
}
}
public void updateSingleStat(MapleStat stat, int newval) {
updateSingleStat(stat, newval, false);
}
private void updateSingleStat(MapleStat stat, int newval, boolean itemReaction) {
client.getSession().write(MaplePacketCreator.updatePlayerStats(Collections.singletonList(new Pair<MapleStat, Integer>(stat, Integer.valueOf(newval))), itemReaction));
}
@Override
public int getObjectId() {
return getId();
}
public MapleMapObjectType getType() {
return MapleMapObjectType.PLAYER;
}
public void sendDestroyData(MapleClient client) {
client.getSession().write(MaplePacketCreator.removePlayerFromMap(this.getObjectId()));
}
@Override
public void sendSpawnData(MapleClient client) {
if (!this.isHidden() || client.getPlayer().gmLevel() > 1) {
client.getSession().write(MaplePacketCreator.spawnPlayerMapobject(this));
for (int i = 0; pets[i] != null; i++) {
client.getSession().write(MaplePacketCreator.showPet(this, pets[i], false, false));
}
}
}
@Override
public void setObjectId(int id) {
return;
}
@Override
public String toString() {
return name;
}
private int givenRiceCakes;
private boolean gottenRiceHat;
public int getGivenRiceCakes() {
return givenRiceCakes;
}
public void increaseGivenRiceCakes(int amount) {
this.givenRiceCakes += amount;
}
public boolean getGottenRiceHat() {
return gottenRiceHat;
}
public static int getIdByName(String name, int world) {
Connection con = DatabaseConnection.getConnection();
PreparedStatement ps;
try {
ps = con.prepareStatement("SELECT id FROM characters WHERE name = ? AND world = ?");
ps.setString(1, name);
ps.setInt(2, world);
ResultSet rs = ps.executeQuery();
if (!rs.next()) {
rs.close();
ps.close();
return -1;
}
int id = rs.getInt("id");
rs.close();
ps.close();
return id;
} catch (SQLException e) {
}
return -1;
}
public void setGottenRiceHat(boolean b) {
this.gottenRiceHat = b;
}
}Replace Your MapleMonster.java with this:
Code:
package server.life;
import java.lang.ref.WeakReference;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import client.MapleBuffStat;
import client.MapleCharacter;
import client.MapleClient;
import client.MapleJob;
import client.SkillFactory;
import client.status.MonsterStatus;
import client.status.MonsterStatusEffect;
import java.util.Random;
import tools.Randomizer;
import net.MaplePacket;
import net.channel.ChannelServer;
import net.world.MapleParty;
import net.world.MaplePartyCharacter;
import scripting.event.EventInstanceManager;
import server.TimerManager;
import server.life.MapleLifeFactory.BanishInfo;
import server.life.MapleMonsterInformationProvider.DropEntry;
import server.maps.MapleMap;
import server.maps.MapleMapObject;
import server.maps.MapleMapObjectType;
import tools.ArrayMap;
import tools.MaplePacketCreator;
import tools.Pair;
public class MapleMonster extends AbstractLoadedMapleLife {
private MapleMonsterStats stats;
private int hp;
private int mp;
private WeakReference<MapleCharacter> controller = new WeakReference<MapleCharacter>(null);
private boolean controllerHasAggro, controllerKnowsAboutAggro;
private Collection<AttackerEntry> attackers = new LinkedList<AttackerEntry>();
private EventInstanceManager eventInstance = null;
private Collection<MonsterListener> listeners = new LinkedList<MonsterListener>();
private MapleCharacter highestDamageChar;
private Map<MonsterStatus, MonsterStatusEffect> stati = new LinkedHashMap<MonsterStatus, MonsterStatusEffect>();
private List<MonsterStatusEffect> activeEffects = new ArrayList<MonsterStatusEffect>();
private MapleMap map;
private int VenomMultiplier = 0;
private boolean fake = false;
private boolean dropsDisabled = false;
private List<Pair<Integer, Integer>> usedSkills = new ArrayList<Pair<Integer, Integer>>();
private Map<Pair<Integer, Integer>, Integer> skillsUsed = new HashMap<Pair<Integer, Integer>, Integer>();
private List<MonsterStatus> monsterBuffs = new ArrayList<MonsterStatus>();
private List<Integer> stolenItems = new ArrayList<Integer>();
private MapleMonsterStats overrideStats;
public MapleMonster(int id, MapleMonsterStats stats) {
super(id);
initWithStats(stats);
}
public MapleMonster(MapleMonster monster) {
super(monster);
initWithStats(monster.stats);
}
private void initWithStats(MapleMonsterStats stats) {
setStance(5);
this.stats = stats;
hp = stats.getHp();
mp = stats.getMp();
}
public void disableDrops() {
this.dropsDisabled = true;
}
public boolean dropsDisabled() {
return dropsDisabled;
}
public void setMap(MapleMap map) {
this.map = map;
}
public int getDrop() {
MapleMonsterInformationProvider mi = MapleMonsterInformationProvider.getInstance();
int lastAssigned = -1;
int minChance = 1;
List<DropEntry> dl = mi.retrieveDropChances(getId());
for (DropEntry d : dl) {
if (d.chance > minChance) {
minChance = d.chance;
}
}
for (DropEntry d : dl) {
d.assignedRangeStart = lastAssigned + 1;
d.assignedRangeLength = (int) Math.ceil(((double) 1 / (double) d.chance) * minChance);
lastAssigned += d.assignedRangeLength;
}
int c = Randomizer.getInstance().nextInt(minChance);
for (DropEntry d : dl) {
if (c >= d.assignedRangeStart && c < (d.assignedRangeStart + d.assignedRangeLength)) {
if (stolenItems.contains(d.itemId)) {
return -1;
}
return d.itemId;
}
}
return -1;
}
public int getHp() {
return hp;
}
public void setHp(int hp) {
this.hp = hp;
}
public int getMaxHp() {
return stats.getHp();
}
public int getMp() {
return mp;
}
public void setMp(int mp) {
if (mp < 0) {
mp = 0;
}
this.mp = mp;
}
public int getMaxMp() {
return stats.getMp();
}
public int getExp() {
return stats.getExp();
}
int getLevel() {
return stats.getLevel();
}
public int getVenomMulti() {
return this.VenomMultiplier;
}
public void setVenomMulti(int multiplier) {
this.VenomMultiplier = multiplier;
}
public boolean isBoss() {
return stats.isBoss() || isHT();
}
public int getAnimationTime(String name) {
return stats.getAnimationTime(name);
}
private List<Integer> getRevives() {
return stats.getRevives();
}
private byte getTagColor() {
return stats.getTagColor();
}
private byte getTagBgColor() {
return stats.getTagBgColor();
}
/**
*
* @param from the player that dealt the damage
* @param damage
*/
public void damage(MapleCharacter from, int damage, boolean updateAttackTime) {
AttackerEntry attacker = null;
if (from.getParty() != null) {
attacker = new PartyAttackerEntry(from.getParty().getId(), from.getClient().getChannelServer());
} else {
attacker = new SingleAttackerEntry(from, from.getClient().getChannelServer());
}
boolean replaced = false;
for (AttackerEntry aentry : attackers) {
if (aentry.equals(attacker)) {
attacker = aentry;
replaced = true;
break;
}
}
if (!replaced) {
attackers.add(attacker);
}
int rDamage = Math.max(0, Math.min(damage, this.hp));
attacker.addDamage(from, rDamage, updateAttackTime);
this.hp -= rDamage;
int remhppercentage = (int) Math.ceil((this.hp * 100.0) / getMaxHp());
if (remhppercentage < 1) {
remhppercentage = 1;
}
long okTime = System.currentTimeMillis() - 4000;
if (hasBossHPBar()) {
from.getMap().broadcastMessage(makeBossHPBarPacket(), getPosition());
} else if (!isBoss()) {
for (AttackerEntry mattacker : attackers) {
for (AttackingMapleCharacter cattacker : mattacker.getAttackers()) {
if (cattacker.getAttacker().getMap() == from.getMap()) {
if (cattacker.getLastAttackTime() >= okTime) {
cattacker.getAttacker().getClient().getSession().write(MaplePacketCreator.showMonsterHP(getObjectId(), remhppercentage));
}
}
}
}
}
}
public void heal(int hp, int mp) {
int hp2Heal = getHp() + hp;
int mp2Heal = getMp() + mp;
if (hp2Heal >= getMaxHp()) {
hp2Heal = getMaxHp();
}
if (mp2Heal >= getMaxMp()) {
mp2Heal = getMaxMp();
}
setHp(hp2Heal);
setMp(mp2Heal);
getMap().broadcastMessage(MaplePacketCreator.healMonster(getObjectId(), hp));
}
public boolean isAttackedBy(MapleCharacter chr) {
for (AttackerEntry aentry : attackers) {
if (aentry.contains(chr)) {
return true;
}
}
return false;
}
public void giveExpToCharacter(MapleCharacter attacker, int exp, boolean highestDamage, int numExpSharers) {
if (highestDamage) {
if (eventInstance != null) {
eventInstance.monsterKilled(attacker, this);
}
highestDamageChar = attacker;
}
if (attacker.getHp() > 0) {
int personalExp = exp;
if (exp > 0) {
Integer holySymbol = attacker.getBuffedValue(MapleBuffStat.HOLY_SYMBOL);
if (holySymbol != null) {
if (numExpSharers == 1) {
personalExp *= 1.0 + (holySymbol.doubleValue() / 500.0);
} else {
personalExp *= 1.0 + (holySymbol.doubleValue() / 100.0);
}
}
}
if (exp < 0) {
personalExp = Integer.MAX_VALUE;
}
attacker.gainExp(personalExp, true, false, highestDamage);
attacker.mobKilled(this.getId());
}
}
public MapleCharacter killBy(MapleCharacter killer) {
long totalBaseExpL = (this.getExp() * killer.getClient().getPlayer().getExpRate());
int totalBaseExp = (int) (Math.min(Integer.MAX_VALUE, totalBaseExpL));
AttackerEntry highest = null;
int highdamage = 0;
for (AttackerEntry attackEntry : attackers) {
if (attackEntry.getDamage() > highdamage) {
highest = attackEntry;
highdamage = attackEntry.getDamage();
}
}
for (AttackerEntry attackEntry : attackers) {
attackEntry.killedMob(killer.getMap(), (int) Math.ceil(totalBaseExp * ((double) attackEntry.getDamage() / getMaxHp())), attackEntry == highest);
}
if (this.getController() != null) { // this can/should only happen when a hidden gm attacks the monster
getController().getClient().getSession().write(MaplePacketCreator.stopControllingMonster(this.getObjectId()));
getController().stopControllingMonster(this);
}
int achievement = 0;
switch (getId()) {
case 100100:
achievement = 18;
break;
case 9400121:
achievement = 3;
break;
case 8500002:
achievement = 10;
break;
case 8800002:
if (getMap().getId() == 280030000) {
for (MapleCharacter ch : getMap().getCharacters()) {
ch.finishAchievement(16);
}
}
break;
case 8510000:
case 8520000:
achievement = 19;
break;
default:
break;
}
if (achievement != 0) {
if (killer.getParty() != null) {
for (MaplePartyCharacter mpc : killer.getParty().getMembers()) {
if (mpc.getMapid() == killer.getMapId()) {
mpc.getPlayer().finishAchievement(achievement);
}
}
} else {
killer.finishAchievement(achievement);
}
}
if (this.isBoss()) {
killer.finishAchievement(6);
}
final List<Integer> toSpawn = this.getRevives();
if (toSpawn != null) {
final MapleMap reviveMap = killer.getMap();
if (toSpawn.contains(9300216) && reviveMap.getId() > 925000000 && reviveMap.getId() < 926000000) {
reviveMap.broadcastMessage(MaplePacketCreator.playSound("Dojang/clear"));
reviveMap.broadcastMessage(MaplePacketCreator.showEffect("dojang/end/clear"));
}
TimerManager.getInstance().schedule(new Runnable() {
public void run() {
for (Integer mid : toSpawn) {
MapleMonster mob = MapleLifeFactory.getMonster(mid);
if (eventInstance != null) {
eventInstance.registerMonster(mob);
}
mob.setPosition(getPosition());
if (dropsDisabled()) {
mob.disableDrops();
}
reviveMap.spawnRevives(mob);
}
}
}, this.getAnimationTime("die1"));
}
if (eventInstance != null) {
eventInstance.unregisterMonster(this);
}
for (MonsterListener listener : listeners.toArray(new MonsterListener[listeners.size()])) {
listener.monsterKilled(this, highestDamageChar);
}
MapleCharacter ret = highestDamageChar;
highestDamageChar = null; // may not keep hard references to chars outside of PlayerStorage or MapleMap
return ret;
}
public boolean isAlive() {
return this.hp > 0;
}
public MapleCharacter getController() {
return controller.get();
}
public void setController(MapleCharacter controller) {
this.controller = new WeakReference<MapleCharacter>(controller);
}
public void switchController(MapleCharacter newController, boolean immediateAggro) {
MapleCharacter controllers = getController();
if (controllers == newController) {
return;
}
if (controllers != null) {
controllers.stopControllingMonster(this);
controllers.getClient().getSession().write(MaplePacketCreator.stopControllingMonster(getObjectId()));
}
newController.controlMonster(this, immediateAggro);
setController(newController);
if (immediateAggro) {
setControllerHasAggro(true);
}
setControllerKnowsAboutAggro(false);
}
public void addListener(MonsterListener listener) {
listeners.add(listener);
}
public boolean isControllerHasAggro() {
return fake ? false : controllerHasAggro;
}
public void setControllerHasAggro(boolean controllerHasAggro) {
if (fake) {
return;
}
this.controllerHasAggro = controllerHasAggro;
}
public boolean isControllerKnowsAboutAggro() {
return fake ? false : controllerKnowsAboutAggro;
}
public void setControllerKnowsAboutAggro(boolean controllerKnowsAboutAggro) {
if (fake) {
return;
}
this.controllerKnowsAboutAggro = controllerKnowsAboutAggro;
}
public MaplePacket makeBossHPBarPacket() {
return MaplePacketCreator.showBossHP(getId(), getHp(), getMaxHp(), getTagColor(), getTagBgColor());
}
public boolean hasBossHPBar() {
return (isBoss() && getTagColor() > 0) || isHT();
}
private boolean isHT() {
return getId() == 8810018 || getId() == 8810026;
}
@Override
public void sendSpawnData(MapleClient c) {
if (!isAlive() || c.getPlayer().isFake()) {
return;
}
if (isFake()) {
c.getSession().write(MaplePacketCreator.spawnFakeMonster(this, 0));
} else {
c.getSession().write(MaplePacketCreator.spawnMonster(this, false));
}
if (stati.size() > 0) {
for (MonsterStatusEffect mse : activeEffects) {
MaplePacket packet = MaplePacketCreator.applyMonsterStatus(getObjectId(), mse.getStati(), mse.getSkill().getId(), false, 0);
c.getSession().write(packet);
}
}
if (hasBossHPBar()) {
c.getSession().write(makeBossHPBarPacket());
}
}
@Override
public void sendDestroyData(MapleClient client) {
client.getSession().write(MaplePacketCreator.killMonster(getObjectId(), false));
}
@Override
public MapleMapObjectType getType() {
return MapleMapObjectType.MONSTER;
}
public void setEventInstance(EventInstanceManager eventInstance) {
this.eventInstance = eventInstance;
}
public boolean isMobile() {
return stats.isMobile();
}
public ElementalEffectiveness getEffectiveness(Element e) {
if (activeEffects.size() > 0 && stati.get(MonsterStatus.DOOM) != null) {
return ElementalEffectiveness.NORMAL;
}
return stats.getEffectiveness(e);
}
public boolean applyStatus(MapleCharacter from, final MonsterStatusEffect status, boolean poison, long duration) {
return applyStatus(from, status, poison, duration, false);
}
public boolean applyStatus(MapleCharacter from, final MonsterStatusEffect status, boolean poison, long duration, boolean venom) {
switch (stats.getEffectiveness(status.getSkill().getElement())) {
case IMMUNE:
case STRONG:
case NEUTRAL:
return false;
case NORMAL:
case WEAK:
break;
default: {
System.out.println("Unknown elemental effectiveness: " + stats.getEffectiveness(status.getSkill().getElement()));
return false;
}
}
if (status.getSkill().getId() == 2111006) { // fp compo
ElementalEffectiveness effectiveness = stats.getEffectiveness(Element.POISON);
if (effectiveness == ElementalEffectiveness.IMMUNE || effectiveness == ElementalEffectiveness.STRONG) {
return false;
}
} else if (status.getSkill().getId() == 2211006) { // il compo
ElementalEffectiveness effectiveness = stats.getEffectiveness(Element.ICE);
if (effectiveness == ElementalEffectiveness.IMMUNE || effectiveness == ElementalEffectiveness.STRONG) {
return false;
}
} else if (status.getSkill().getId() == 4120005 || status.getSkill().getId() == 4220005 || status.getSkill().getId() == 14110004) // venom
{
if (stats.getEffectiveness(Element.POISON) == ElementalEffectiveness.WEAK) {
return false;
}
}
if (poison && getHp() <= 1) {
return false;
}
if (isBoss() && !(status.getStati().containsKey(MonsterStatus.SPEED))) {
return false;
}
for (MonsterStatus stat : status.getStati().keySet()) {
MonsterStatusEffect oldEffect = stati.get(stat);
if (oldEffect != null) {
oldEffect.removeActiveStatus(stat);
if (oldEffect.getStati().size() == 0) {
oldEffect.getCancelTask().cancel(false);
oldEffect.cancelPoisonSchedule();
activeEffects.remove(oldEffect);
}
}
}
TimerManager timerManager = TimerManager.getInstance();
final Runnable cancelTask = new Runnable() {
@Override
public void run() {
if (isAlive()) {
MaplePacket packet = MaplePacketCreator.cancelMonsterStatus(getObjectId(), status.getStati());
map.broadcastMessage(packet, getPosition());
if (getController() != null && !getController().isMapObjectVisible(MapleMonster.this)) {
getController().getClient().getSession().write(packet);
}
}
activeEffects.remove(status);
for (MonsterStatus stat : status.getStati().keySet()) {
stati.remove(stat);
}
setVenomMulti(0);
status.cancelPoisonSchedule();
}
};
if (poison) {
int poisonLevel = from.getSkillLevel(status.getSkill());
int poisonDamage = Math.min(Short.MAX_VALUE, (int) (getMaxHp() / (70.0 - poisonLevel) + 0.999));
status.setValue(MonsterStatus.POISON, Integer.valueOf(poisonDamage));
status.setPoisonSchedule(timerManager.register(new PoisonTask(poisonDamage, from, status, cancelTask, false), 1000, 1000));
} else if (venom) {
if (from.getJob() == MapleJob.NIGHTLORD || from.getJob() == MapleJob.SHADOWER) {
int poisonLevel = 0;
int matk = 0;
if (from.getJob() == MapleJob.NIGHTLORD) {
poisonLevel = from.getSkillLevel(SkillFactory.getSkill(4120005));
if (poisonLevel <= 0) {
return false;
}
matk = SkillFactory.getSkill(4120005).getEffect(poisonLevel).getMatk();
} else if (from.getJob() == MapleJob.SHADOWER) {
poisonLevel = from.getSkillLevel(SkillFactory.getSkill(4220005));
if (poisonLevel <= 0) {
return false;
}
matk = SkillFactory.getSkill(4220005).getEffect(poisonLevel).getMatk();
} else {
return false;
}
Random r = new Random();
int luk = from.getLuk();
int maxDmg = (int) Math.ceil(Math.min(Short.MAX_VALUE, 0.2 * luk * matk));
int minDmg = (int) Math.ceil(Math.min(Short.MAX_VALUE, 0.1 * luk * matk));
int gap = maxDmg - minDmg;
if (gap == 0) {
gap = 1;
}
int poisonDamage = 0;
for (int i = 0; i < getVenomMulti(); i++) {
poisonDamage = poisonDamage + (r.nextInt(gap) + minDmg);
}
poisonDamage = Math.min(Short.MAX_VALUE, poisonDamage);
status.setValue(MonsterStatus.POISON, Integer.valueOf(poisonDamage));
status.setPoisonSchedule(timerManager.register(new PoisonTask(poisonDamage, from, status, cancelTask, false), 1000, 1000));
} else {
return false;
}
} else if (status.getSkill().getId() == 4111003 || status.getSkill().getId() == 14111001) // shadow web
{
status.setPoisonSchedule(timerManager.schedule(new PoisonTask((int) (getMaxHp() / 50.0 + 0.999), from, status, cancelTask, true), 3500));
}
for (MonsterStatus stat : status.getStati().keySet()) {
stati.put(stat, status);
}
activeEffects.add(status);
int animationTime = status.getSkill().getAnimationTime();
MaplePacket packet = MaplePacketCreator.applyMonsterStatus(getObjectId(), status.getStati(), status.getSkill().getId(), false, 0);
map.broadcastMessage(packet, getPosition());
if (getController() != null && !getController().isMapObjectVisible(this)) {
getController().getClient().getSession().write(packet);
}
status.setCancelTask(timerManager.schedule(cancelTask, duration + animationTime));
return true;
}
public void applyMonsterBuff(final MonsterStatus status, final int x, int skillId, long duration, MobSkill skill) {
TimerManager timerManager = TimerManager.getInstance();
final Runnable cancelTask = new Runnable() {
@Override
public void run() {
if (isAlive()) {
MaplePacket packet = MaplePacketCreator.cancelMonsterStatus(getObjectId(), Collections.singletonMap(status, Integer.valueOf(x)));
map.broadcastMessage(packet, getPosition());
if (getController() != null && !getController().isMapObjectVisible(MapleMonster.this)) {
getController().getClient().getSession().write(packet);
}
removeMonsterBuff(status);
}
}
};
MaplePacket packet = MaplePacketCreator.applyMonsterStatus(getObjectId(), Collections.singletonMap(status, x), skillId, true, 0, skill);
map.broadcastMessage(packet, getPosition());
if (getController() != null && !getController().isMapObjectVisible(this)) {
getController().getClient().getSession().write(packet);
}
timerManager.schedule(cancelTask, duration);
addMonsterBuff(status);
}
public void addMonsterBuff(MonsterStatus status) {
this.monsterBuffs.add(status);
}
public void removeMonsterBuff(MonsterStatus status) {
this.monsterBuffs.remove(status);
}
public boolean isBuffed(MonsterStatus status) {
return this.monsterBuffs.contains(status);
}
public void setFake(boolean fake) {
this.fake = fake;
}
public boolean isFake() {
return fake;
}
public MapleMap getMap() {
return map;
}
public List<Pair<Integer, Integer>> getSkills() {
return stats.getSkills();
}
public boolean hasSkill(int skillId, int level) {
return stats.hasSkill(skillId, level);
}
public boolean canUseSkill(MobSkill toUse) {
if (toUse == null) {
return false;
}
for (Pair<Integer, Integer> skill : usedSkills) {
if (skill.getLeft() == toUse.getSkillId() && skill.getRight() == toUse.getSkillLevel()) {
return false;
}
}
if (toUse.getLimit() > 0) {
if (this.skillsUsed.containsKey(new Pair<Integer, Integer>(toUse.getSkillId(), toUse.getSkillLevel()))) {
int times = this.skillsUsed.get(new Pair<Integer, Integer>(toUse.getSkillId(), toUse.getSkillLevel()));
if (times >= toUse.getLimit()) {
return false;
}
}
}
if (toUse.getSkillId() == 200) {
Collection<MapleMapObject> mmo = getMap().getMapObjects();
int i = 0;
for (MapleMapObject mo : mmo) {
if (mo.getType() == MapleMapObjectType.MONSTER) {
i++;
}
}
if (i > 100) {
return false;
}
}
return true;
}
public void usedSkill(final int skillId, final int level, long cooltime) {
this.usedSkills.add(new Pair<Integer, Integer>(skillId, level));
if (this.skillsUsed.containsKey(new Pair<Integer, Integer>(skillId, level))) {
int times = this.skillsUsed.get(new Pair<Integer, Integer>(skillId, level)) + 1;
this.skillsUsed.remove(new Pair<Integer, Integer>(skillId, level));
this.skillsUsed.put(new Pair<Integer, Integer>(skillId, level), times);
} else {
this.skillsUsed.put(new Pair<Integer, Integer>(skillId, level), 1);
}
final MapleMonster mons = this;
TimerManager tMan = TimerManager.getInstance();
tMan.schedule(
new Runnable() {
@Override
public void run() {
mons.clearSkill(skillId, level);
}
}, cooltime);
}
public void clearSkill(int skillId, int level) {
int index = -1;
for (Pair<Integer, Integer> skill : usedSkills) {
if (skill.getLeft() == skillId && skill.getRight() == level) {
index = usedSkills.indexOf(skill);
break;
}
}
if (index != -1) {
usedSkills.remove(index);
}
}
public int getNoSkills() {
return this.stats.getNoSkills();
}
public boolean isFirstAttack() {
return this.stats.isFirstAttack();
}
public int getBuffToGive() {
return this.stats.getBuffToGive();
}
public void setOverrideStats(MapleMonsterStats overrideStats) {
this.overrideStats = overrideStats;
}
private final class PoisonTask implements Runnable {
private final int poisonDamage;
private final MapleCharacter chr;
private final MonsterStatusEffect status;
private final Runnable cancelTask;
private final boolean shadowWeb;
private final MapleMap map;
private PoisonTask(int poisonDamage, MapleCharacter chr, MonsterStatusEffect status, Runnable cancelTask, boolean shadowWeb) {
this.poisonDamage = poisonDamage;
this.chr = chr;
this.status = status;
this.cancelTask = cancelTask;
this.shadowWeb = shadowWeb;
this.map = chr.getMap();
}
@Override
public void run() {
int damage = poisonDamage;
if (damage >= hp) {
damage = hp - 1;
if (!shadowWeb) {
cancelTask.run();
status.getCancelTask().cancel(false);
}
}
if (hp > 1 && damage > 0) {
damage(chr, damage, false);
if (shadowWeb) {
map.broadcastMessage(MaplePacketCreator.damageMonster(getObjectId(), damage), getPosition());
}
}
}
}
public String getName() {
return stats.getName();
}
private class AttackingMapleCharacter {
private MapleCharacter attacker;
private long lastAttackTime;
public AttackingMapleCharacter(MapleCharacter attacker, long lastAttackTime) {
super();
this.attacker = attacker;
this.lastAttackTime = lastAttackTime;
}
public long getLastAttackTime() {
return lastAttackTime;
}
public MapleCharacter getAttacker() {
return attacker;
}
}
private interface AttackerEntry {
List<AttackingMapleCharacter> getAttackers();
public void addDamage(MapleCharacter from, int damage, boolean updateAttackTime);
public int getDamage();
public boolean contains(MapleCharacter chr);
public void killedMob(MapleMap map, int baseExp, boolean mostDamage);
}
private class SingleAttackerEntry implements AttackerEntry {
private int damage;
private int chrid;
private long lastAttackTime;
private ChannelServer cserv;
public SingleAttackerEntry(MapleCharacter from, ChannelServer cserv) {
this.chrid = from.getId();
this.cserv = cserv;
}
@Override
public void addDamage(MapleCharacter from, int damage, boolean updateAttackTime) {
if (chrid == from.getId()) {
this.damage += damage;
} else {
throw new IllegalArgumentException("Not the attacker of this entry");
}
if (updateAttackTime) {
lastAttackTime = System.currentTimeMillis();
}
if (from.getDamageRecord() < damage) {
from.dropMessage("[DamageTrackingSystem](OldRecord:" + from.getDamageRecord() + ") (NewRecord:" + damage + ")");
from.setDamageRecord(damage);
}
}
@Override
public List<AttackingMapleCharacter> getAttackers() {
MapleCharacter chr = cserv.getPlayerStorage().getCharacterById(chrid);
if (chr != null) {
return Collections.singletonList(new AttackingMapleCharacter(chr, lastAttackTime));
} else {
return Collections.emptyList();
}
}
@Override
public boolean contains(MapleCharacter chr) {
return chrid == chr.getId();
}
@Override
public int getDamage() {
return damage;
}
@Override
public void killedMob(MapleMap map, int baseExp, boolean mostDamage) {
MapleCharacter chr = cserv.getPlayerStorage().getCharacterById(chrid);
if (chr != null && chr.getMap() == map) {
giveExpToCharacter(chr, baseExp, mostDamage, 1);
}
}
@Override
public int hashCode() {
return chrid;
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
final SingleAttackerEntry other = (SingleAttackerEntry) obj;
return chrid == other.chrid;
}
}
private static class OnePartyAttacker {
public MapleParty lastKnownParty;
public int damage;
public long lastAttackTime;
public OnePartyAttacker(MapleParty lastKnownParty, int damage) {
this.lastKnownParty = lastKnownParty;
this.damage = damage;
this.lastAttackTime = System.currentTimeMillis();
}
}
private class PartyAttackerEntry implements AttackerEntry {
private int totDamage;
private Map<Integer, OnePartyAttacker> attackers;
private ChannelServer cserv;
private int partyid;
public PartyAttackerEntry(int partyid, ChannelServer cserv) {
this.partyid = partyid;
this.cserv = cserv;
attackers = new HashMap<Integer, OnePartyAttacker>(6);
}
public List<AttackingMapleCharacter> getAttackers() {
List<AttackingMapleCharacter> ret = new ArrayList<AttackingMapleCharacter>(attackers.size());
for (Entry<Integer, OnePartyAttacker> entry : attackers.entrySet()) {
MapleCharacter chr = cserv.getPlayerStorage().getCharacterById(entry.getKey());
if (chr != null) {
ret.add(new AttackingMapleCharacter(chr, entry.getValue().lastAttackTime));
}
}
return ret;
}
private Map<MapleCharacter, OnePartyAttacker> resolveAttackers() {
Map<MapleCharacter, OnePartyAttacker> ret = new HashMap<MapleCharacter, OnePartyAttacker>(attackers.size());
for (Entry<Integer, OnePartyAttacker> aentry : attackers.entrySet()) {
MapleCharacter chr = cserv.getPlayerStorage().getCharacterById(aentry.getKey());
if (chr != null) {
ret.put(chr, aentry.getValue());
}
}
return ret;
}
@Override
public boolean contains(MapleCharacter chr) {
return attackers.containsKey(chr.getId());
}
@Override
public int getDamage() {
return totDamage;
}
public void addDamage(MapleCharacter from, int damage, boolean updateAttackTime) {
OnePartyAttacker oldPartyAttacker = attackers.get(from.getId());
if (oldPartyAttacker != null) {
oldPartyAttacker.damage += damage;
oldPartyAttacker.lastKnownParty = from.getParty();
if (updateAttackTime) {
oldPartyAttacker.lastAttackTime = System.currentTimeMillis();
}
} else {
// TODO actually this causes wrong behaviour when the party changes between attacks
// only the last setup will get exp - but otherwise we'd have to store the full party
// constellation for every attack/everytime it changes, might be wanted/needed in the
// future but not now
OnePartyAttacker onePartyAttacker = new OnePartyAttacker(from.getParty(), damage);
attackers.put(from.getId(), onePartyAttacker);
if (!updateAttackTime) {
onePartyAttacker.lastAttackTime = 0;
}
}
totDamage += damage;
}
@Override
public void killedMob(MapleMap map, int baseExp, boolean mostDamage) {
Map<MapleCharacter, OnePartyAttacker> attackers_ = resolveAttackers();
MapleCharacter highest = null;
int highestDamage = 0;
Map<MapleCharacter, Integer> expMap = new ArrayMap<MapleCharacter, Integer>(6);
for (Entry<MapleCharacter, OnePartyAttacker> attacker : attackers_.entrySet()) {
MapleParty party = attacker.getValue().lastKnownParty;
double averagePartyLevel = 0;
List<MapleCharacter> expApplicable = new ArrayList<MapleCharacter>();
for (MaplePartyCharacter partychar : party.getMembers()) {
if (attacker.getKey().getLevel() - partychar.getLevel() <= 5 || getLevel() - partychar.getLevel() <= 5) {
MapleCharacter pchr = cserv.getPlayerStorage().getCharacterByName(partychar.getName());
if (pchr != null) {
if (pchr.isAlive() && pchr.getMap() == map) {
expApplicable.add(pchr);
averagePartyLevel += pchr.getLevel();
}
}
}
}
double expBonus = 1.0;
if (expApplicable.size() > 1) {
expBonus = 1.10 + 0.05 * expApplicable.size();
averagePartyLevel /= expApplicable.size();
}
int iDamage = attacker.getValue().damage;
if (iDamage > highestDamage) {
highest = attacker.getKey();
highestDamage = iDamage;
}
double innerBaseExp = baseExp * ((double) iDamage / totDamage);
double expFraction = (innerBaseExp * expBonus) / (expApplicable.size() + 1);
for (MapleCharacter expReceiver : expApplicable) {
Integer oexp = expMap.get(expReceiver);
int iexp;
if (oexp == null) {
iexp = 0;
} else {
iexp = oexp.intValue();
}
double expWeight = (expReceiver == attacker.getKey() ? 2.0 : 1.0);
double levelMod = expReceiver.getLevel() / averagePartyLevel;
if (levelMod > 1.0 || this.attackers.containsKey(expReceiver.getId())) {
levelMod = 1.0;
}
iexp += (int) Math.round(expFraction * expWeight * levelMod);
expMap.put(expReceiver, Integer.valueOf(iexp));
}
}
for (Entry<MapleCharacter, Integer> expReceiver : expMap.entrySet()) {
giveExpToCharacter(expReceiver.getKey(), expReceiver.getValue(), mostDamage ? expReceiver.getKey() == highest : false, expMap.size());
}
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + partyid;
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
final PartyAttackerEntry other = (PartyAttackerEntry) obj;
if (partyid != other.partyid) {
return false;
}
return true;
}
}
public void addStolen(int itemId) {
stolenItems.add(itemId);
}
public void setTempEffectiveness(Element e, ElementalEffectiveness ee, long milli) {
final Element fE = e;
final ElementalEffectiveness fEE = stats.getEffectiveness(e);
if (!stats.getEffectiveness(e).equals(ElementalEffectiveness.WEAK)) {
stats.setEffectiveness(e, ee);
TimerManager.getInstance().schedule(new Runnable() {
public void run() {
stats.removeEffectiveness(fE);
stats.setEffectiveness(fE, fEE);
}
}, milli);
}
}
public BanishInfo getBanish() {
return stats.getBanishInfo();
}
public void setBoss(boolean boss) {
this.stats.setBoss(boss);
}
public int getDropPeriodTime() {
return stats.getDropPeriod();
}
public int getPADamage() {
return stats.getPADamage();
}
}
You could also add meso gain, or gaining items for setting certain records. Your choice.
All the things you need to add:
In MapleCharacter.java
Add
Code:
private int damagerecord;
Code:
private int reborns;Add
Code:
ret.damagerecord = 0;
Code:
ret.reborns = 0;Add
Code:
public int getDamageRecord() {
return damagerecord;
}
Code:
public int getReborns() {
return reborns;
}add
Code:
public void setDamageRecord(int amt) {
damagerecord = amt;
}
Code:
public void setReborns(int amt) {
reborns = amt;
}add
Code:
ret.damagerecord = rs.getInt("damagerecord");
Code:
Code:
ret.reborns = rs.getInt("reborns");add
Code:
damagerecord = ?,
Code:
reborns = ?,add
Code:
damagerecord,
Code:
reborns,dont forget to add one of these in values
Code:
?,add
Code:
ps.setInt(52, damagerecord);
Code:
ps.setInt(51, reborns);Now on to MapleMonster.java
Add
Code:
if (from.getDamageRecord() < damage) {
from.dropMessage("[DamageTrackingSystem](OldRecord:" + from.getDamageRecord() + ") (NewRecord:" + damage + ")");
from.setDamageRecord(damage);
}Under
Code:
public void addDamage(MapleCharacter from, int damage, boolean updateAttackTime) {
if (chrid == from.getId()) {
this.damage += damage;
} else {
throw new IllegalArgumentException("Not the attacker of this entry");
}
if (updateAttackTime) {
lastAttackTime = System.currentTimeMillis();
}SQL:
Code:
ALTER TABLE `characters` ADD COLUMN `damagerecord` int(11) NOT NULL default '0' AFTER `reborns`;
Last edited:
