MapleCharacter.java (Xephyr Version 114)

package client;

 

import client.anticheat.CheatTracker;

import client.anticheat.ReportType;

import client.inventory.Equip;

import client.inventory.Item;

import client.inventory.ItemFlag;

import client.inventory.ItemLoader;

import client.inventory.MapleAndroid;

import client.inventory.MapleImp;

import client.inventory.MapleImp.ImpFlag;

import client.inventory.MapleInventory;

import client.inventory.MapleInventoryIdentifier;

import client.inventory.MapleInventoryType;

import client.inventory.MapleMount;

import client.inventory.MaplePet;

import client.inventory.MapleRing;

import client.inventory.MapleRing.RingComparator;

import client.status.MonsterStatus;

import client.status.MonsterStatusEffect;

import constants.BattleConstants;

import constants.BattleConstants.HoldItem;

import constants.BattleConstants.PokemonNature;

import constants.BattleConstants.PokemonStat;

import constants.GameConstants;

import constants.MapConstants;

import constants.OccupationConstants;

import constants.ServerConstants;

import database.DatabaseConnection;

import database.DatabaseException;

import handling.channel.ChannelServer;

import handling.channel.PlayerStorage;

import handling.login.LoginInformationProvider.JobType;

import handling.login.LoginServer;

import handling.world.CharacterTransfer;

import handling.world.MapleCharacterLook;

import handling.world.MapleMessenger;

import handling.world.MapleMessengerCharacter;

import handling.world.MapleParty;

import handling.world.MaplePartyCharacter;

import handling.world.PartyOperation;

import handling.world.PlayerBuffStorage;

import handling.world.PlayerBuffValueHolder;

import handling.world.World;

import handling.world.World.Broadcast;

import handling.world.World.Family;

import handling.world.World.Guild;

import handling.world.World.Messenger;

import handling.world.World.Party;

import handling.world.family.MapleFamily;

import handling.world.family.MapleFamilyBuff;

import handling.world.family.MapleFamilyCharacter;

import handling.world.guild.MapleGuild;

import handling.world.guild.MapleGuildCharacter;

import java.awt.Point;

import java.awt.Rectangle;

import java.io.PrintStream;

import java.io.Serializable;

import java.lang.ref.WeakReference;

import java.sql.Connection;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.sql.Timestamp;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Calendar;

import java.util.Collection;

import java.util.Collections;

import java.util.Comparator;

import java.util.Deque;

import java.util.EnumMap;

import java.util.HashMap;

import java.util.Iterator;

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.concurrent.ScheduledFuture;

import java.util.concurrent.atomic.AtomicInteger;

import java.util.concurrent.locks.ReentrantReadWriteLock;

import java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock;

import java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock;

import org.apache.mina.common.IoSession;

import scripting.EventInstanceManager;

import scripting.NPCScriptManager;

import server.CashShop;

import server.MapleAchievement;

import server.MapleAchievements;

import server.MapleCarnivalChallenge;

import server.MapleCarnivalParty;

import server.MapleInventoryManipulator;

import server.MapleItemInformationProvider;

import server.MaplePortal;

import server.MapleShop;

import server.MapleStatEffect;

import server.MapleStatEffect.CancelEffectAction;

import server.MapleStorage;

import server.MapleTrade;

import server.PokemonBattle;

import server.RandomRewards;

import server.Randomizer;

import server.StructFamiliar;

import server.Timer.BuffTimer;

import server.Timer.MapTimer;

import server.life.MapleLifeFactory;

import server.life.MapleMonster;

import server.life.MapleMonsterStats;

import server.life.MobSkill;

import server.life.MobSkillFactory;

import server.life.PlayerNPC;

import server.maps.AnimatedMapleMapObject;

import server.maps.Event_PyramidSubway;

import server.maps.FieldLimitType;

import server.maps.MapleDoor;

import server.maps.MapleDragon;

import server.maps.MapleExtractor;

import server.maps.MapleFoothold;

import server.maps.MapleFootholdTree;

import server.maps.MapleMap;

import server.maps.MapleMapFactory;

import server.maps.MapleMapObject;

import server.maps.MapleMapObjectType;

import server.maps.MapleSummon;

import server.maps.MechDoor;

import server.maps.SavedLocationType;

import server.movement.LifeMovementFragment;

import server.quest.MapleQuest;

import server.quest.custom.CustomQuest;

import server.quest.custom.CustomQuestProvider;

import server.shops.HiredMerchant;

import server.shops.IMaplePlayerShop;

import tools.ConcurrentEnumMap;

import tools.FileoutputUtil;

import tools.MockIOSession;

import tools.Pair;

import tools.StringUtil;

import tools.Triple;

import tools.data.MaplePacketLittleEndianWriter;

import tools.packet.CField;

import tools.packet.CField.EffectPacket;

import tools.packet.CField.NPCPacket;

import tools.packet.CField.SummonPacket;

import tools.packet.CWvsContext;

import tools.packet.CWvsContext.BuddylistPacket;

import tools.packet.CWvsContext.BuffPacket;

import tools.packet.CWvsContext.InfoPacket;

import tools.packet.CWvsContext.InventoryPacket;

import tools.packet.MTSCSPacket;

import tools.packet.MobPacket;

import tools.packet.MonsterCarnivalPacket;

import tools.packet.PetPacket;

import tools.packet.PlayerShopPacket;

 

public class MapleCharacter extends AnimatedMapleMapObject

  implements Serializable, MapleCharacterLook

  private static final long serialVersionUID = 845748950829L;

  private String name;

  private String chalktext;

  private String BlessOfFairy_Origin;

  private String BlessOfEmpress_Origin;

  private String teleportname;

  private long lastCombo;

  private long lastfametime;

  private long keydown_skill;

  private long nextConsume;

  private long pqStartTime;

  private long lastDragonBloodTime;

  private long lastBerserkTime;

  private long lastRecoveryTime;

  private long lastSummonTime;

  private long mapChangeTime;

  private long lastFishingTime;

  private long lastFairyTime;

  private long lastHPTime;

  private long lastMPTime;

  private long lastFamiliarEffectTime;

  private long lastDOTTime;

  private byte gmLevel;

  private byte gender;

  private byte initialSpawnPoint;

  private byte skinColor;

  private byte guildrank = 5; private byte allianceRank = 5;

  private byte world;

  private byte fairyExp;

  private byte numClones;

  private byte subcategory;

  private byte cardStack;

  private short level;

  private short mulung_energy;

  private short combo;

  private short force;

  private short availableCP;

  private short fatigue;

  private short totalCP;

  private short hpApUsed;

  private short job;

  private short remainingAp;

  private short scrolledPosition;

  private int accountid;

  private int id;

  private int meso;

  private int exp;

  private int hair;

  private int face;

  private int demonMarking;

  private int mapid;

  private int fame;

  private int pvpExp;

  private int pvpPoints;

  private int totalWins;

  private int totalLosses;

  private int guildid = 0;

  private int fallcounter;

  private int maplepoints;

  private int acash;

  private int chair;

  private int itemEffect;

  private int points;

  private int vpoints;

  private int rank = 1; private int rankMove = 0; private int jobRank = 1; private int jobRankMove = 0;

  private int marriageId;

  private int marriageItemId;

  private int dotHP;

  private int runningStack;

  private int currentrep;

  private int totalrep;

  private int coconutteam;

  private int followid;

  private int battleshipHP;

  private int gachexp;

  private int challenge;

  private int guildContribution = 0;

  private int toSteal;

  private Point old;

  private MonsterFamiliar summonedFamiliar;

  private int[] wishlist;

  private int[] rocks;

  private int[] savedLocations;

  private int[] regrocks;

  private int[] hyperrocks;

  private int[] remainingSp = new int[10];

  private transient AtomicInteger inst;

  private transient AtomicInteger insd;

  private transient List<LifeMovementFragment> lastres;

  private List<Integer> lastmonthfameids;

  private List<Integer> lastmonthbattleids;

  private List<Integer> extendedSlots;

  private List<MapleDoor> doors;

  private List<MechDoor> mechDoors;

  private List<MaplePet> pets;

  private List<Item> rebuy;

  private MapleImp[] imps;

  private transient WeakReference<MapleCharacter>[] clones;

  private transient Set<MapleMonster> controlled;

  private transient Set<MapleMapObject> visibleMapObjects;

  private transient ReentrantReadWriteLock visibleMapObjectsLock;

  private transient ReentrantReadWriteLock summonsLock;

  private transient ReentrantReadWriteLock controlledLock;

  private transient MapleAndroid android;

  private Map<CustomQuest, MapleCustomQuestStatus> customQuests;

  private Map<MapleQuest, MapleQuestStatus> quests;

  private Map<Integer, String> questinfo;

  private Map<Skill, SkillEntry> skills;

  private transient Map<MapleBuffStat, MapleBuffStatValueHolder> effects;

  private transient List<MapleSummon> summons;

  private transient Map<Integer, MapleCoolDownValueHolder> coolDowns;

  private transient Map<MapleDisease, MapleDiseaseValueHolder> diseases;

  private Map<ReportType, Integer> reports;

  private CashShop cs;

  private transient Deque<MapleCarnivalChallenge> pendingCarnivalRequests;

  private transient MapleCarnivalParty carnivalParty;

  private BuddyList buddylist;

  private MonsterBook monsterbook;

  private transient CheatTracker anticheat;

  private MapleClient client;

  private transient MapleParty party;

  private PlayerStats stats;

  private MapleCharacterCards characterCard;

  private transient MapleMap map;

  private transient MapleShop shop;

  private transient MapleDragon dragon;

  private transient MapleExtractor extractor;

  private transient RockPaperScissors rps;

  private Map<Integer, MonsterFamiliar> familiars;

  private MapleStorage storage;

  private transient MapleTrade trade;

  private MapleMount mount;

  private List<Integer> finishedAchievements;

  private MapleMessenger messenger;

  private byte[] petStore;

  private transient IMaplePlayerShop playerShop;

  private boolean invincible;

  private boolean canTalk;

  private boolean clone;

  private boolean followinitiator;

  private boolean followon;

  private boolean smega;

  private boolean hasSummon;

  private MapleGuildCharacter mgc;

  private MapleFamilyCharacter mfc;

  private transient EventInstanceManager eventInstance;

  private MapleInventory[] inventory;

  private SkillMacro[] skillMacros = new SkillMacro[5];

  private EnumMap<MapleTrait.MapleTraitType, MapleTrait> traits;

  private Battler[] battlers = new Battler[6];

  private List<Battler> boxed;

  private MapleKeyLayout keylayout;

  private transient ScheduledFuture<?> mapTimeLimitTask;

  private transient Event_PyramidSubway pyramidSubway = null;

  private transient List<Integer> pendingExpiration = null;

  private transient Map<Skill, SkillEntry> pendingSkills = null;

  private transient Map<Integer, Integer> linkMobs;

  private transient PokemonBattle battle;

  protected MapleClient c;

  private HiredMerchant hiredMerchant = null;

  private boolean changed_wishlist;

  private boolean changed_trocklocations;

  private boolean changed_regrocklocations;

  private boolean changed_hyperrocklocations;

  private boolean changed_skillmacros;

  private boolean changed_achievements;

  private boolean changed_savedlocations;

  private boolean changed_pokemon;

  private boolean changed_questinfo;

  private boolean changed_skills;

  private boolean changed_reports;

  private boolean changed_extendedSlots;

  private int reborns;

  private int apstorage;

  private short occupationId;

  private short occupationEXP;

  private short mobKilledNo;

  private long loginTime;

  private transient PlayerRandomStream CRand;

 

  private MapleCharacter(boolean ChannelServer)

  {

    setStance(0);

    setPosition(new Point(0, 0));

 

    this.inventory = new MapleInventory[MapleInventoryType.values().length];

    for (MapleInventoryType type : MapleInventoryType.values()) {

      this.inventory[type.ordinal()] = new MapleInventory(type);

    }

    this.quests = new LinkedHashMap();

    this.skills = new LinkedHashMap();

    this.stats = new PlayerStats();

    this.characterCard = new MapleCharacterCards();

    for (int i = 0; i < this.remainingSp.length; ++i) {

      this.remainingSp[i] = 0;

    }

    this.traits = new EnumMap(MapleTrait.MapleTraitType.class);

    for (MapleTrait.MapleTraitType t : MapleTrait.MapleTraitType.values()) {

      this.traits.put(t, new MapleTrait(t));

    }

    if (ChannelServer) {

      this.changed_reports = false;

      this.changed_skills = false;

      this.changed_achievements = false;

      this.changed_wishlist = false;

      this.changed_trocklocations = false;

      this.changed_regrocklocations = false;

      this.changed_hyperrocklocations = false;

      this.changed_skillmacros = false;

      this.changed_savedlocations = false;

      this.changed_pokemon = false;

      this.changed_extendedSlots = false;

      this.changed_questinfo = false;

      this.scrolledPosition = 0;

      this.lastCombo = 0L;

      this.mulung_energy = 0;

 

      this.loginTime = 0L;

 

      this.combo = 0;

      this.force = 0;

      this.keydown_skill = 0L;

      this.nextConsume = 0L;

      this.pqStartTime = 0L;

      this.fairyExp = 0;

      this.cardStack = 0;

      this.runningStack = 1;

      this.mapChangeTime = 0L;

      this.lastRecoveryTime = 0L;

      this.lastDragonBloodTime = 0L;

      this.lastBerserkTime = 0L;

      this.lastFishingTime = 0L;

      this.lastFairyTime = 0L;

      this.lastHPTime = 0L;

      this.lastMPTime = 0L;

      this.lastFamiliarEffectTime = 0L;

      this.old = new Point(0, 0);

      this.coconutteam = 0;

      this.followid = 0;

      this.toSteal = 0;

      this.battleshipHP = 0;

      this.marriageItemId = 0;

      this.fallcounter = 0;

      this.challenge = 0;

      this.dotHP = 0;

      this.lastSummonTime = 0L;

      this.hasSummon = false;

      this.invincible = false;

      this.canTalk = true;

      this.clone = false;

      this.followinitiator = false;

      this.followon = false;

      this.rebuy = new ArrayList();

      this.linkMobs = new HashMap();

      this.finishedAchievements = new ArrayList();

      this.reports = new EnumMap(ReportType.class);

      this.teleportname = "";

      this.smega = true;

      this.petStore = new byte[3];

      for (int i = 0; i < this.petStore.length; ++i) {

        this.petStore[i] = -1;

      }

      this.wishlist = new int[10];

      this.rocks = new int[10];

      this.regrocks = new int[5];

      this.hyperrocks = new int[13];

      this.imps = new MapleImp[3];

      this.clones = new WeakReference[5];

      for (int i = 0; i < this.clones.length; ++i) {

        this.clones[i] = new WeakReference(null);

      }

      this.boxed = new ArrayList();

      this.familiars = new LinkedHashMap();

      this.extendedSlots = new ArrayList();

      this.effects = new ConcurrentEnumMap(MapleBuffStat.class);

      this.coolDowns = new LinkedHashMap();

      this.diseases = new ConcurrentEnumMap(MapleDisease.class);

      this.inst = new AtomicInteger(0);

      this.insd = new AtomicInteger(-1);

      this.keylayout = new MapleKeyLayout();

      this.doors = new ArrayList();

      this.mechDoors = new ArrayList();

      this.controlled = new LinkedHashSet();

      this.controlledLock = new ReentrantReadWriteLock();

      this.summons = new LinkedList();

      this.summonsLock = new ReentrantReadWriteLock();

      this.visibleMapObjects = new LinkedHashSet();

      this.visibleMapObjectsLock = new ReentrantReadWriteLock();

      this.pendingCarnivalRequests = new LinkedList();

 

      this.savedLocations = new int[SavedLocationType.values().length];

      for (int i = 0; i < SavedLocationType.values().length; ++i) {

        this.savedLocations[i] = -1;

      }

      this.questinfo = new LinkedHashMap();

      this.pets = new ArrayList();

    }

  }

 

  public static MapleCharacter getDefault(MapleClient client, JobType type) {

    MapleCharacter ret = new MapleCharacter(false);

    ret.client = client;

    ret.map = null;

    ret.exp = 0;

    ret.gmLevel = 0;

    ret.job = (short)type.id;

    ret.meso = 0;

    ret.level = (short)((type.id == 2400) ? 10 : (type.id == 508) ? 10 : 1);

    ret.remainingAp = 0;

    ret.fame = 0;

    ret.accountid = client.getAccID();

    ret.buddylist = new BuddyList((byte) 20);

    ret.stats.str = 12;

    ret.stats.dex = 5;

    ret.stats.int_ = 4;

    ret.stats.luk = 4;

    ret.stats.maxhp = 50;

    ret.stats.hp = 50;

    ret.stats.maxmp = 50;

    ret.stats.mp = 50;

    ret.gachexp = 0;

    try

    {

      Connection con = DatabaseConnection.getConnection();

 

      PreparedStatement ps = con.prepareStatement("SELECT * FROM accounts WHERE id = ?");

      ps.setInt(1, ret.accountid);

      ResultSet rs = ps.executeQuery();

 

      if (rs.next()) {

        ret.client.setAccountName(rs.getString("name"));

        ret.acash = rs.getInt("ACash");

        ret.maplepoints = rs.getInt("mPoints");

        ret.points = rs.getInt("points");

        ret.vpoints = rs.getInt("vpoints");

      }

      rs.close();

      ps.close();

    } catch (SQLException e) {

      System.err.println(new StringBuilder().append("Error getting character default").append(e).toString());

    }

    return ret;

  }

 

  public static final MapleCharacter ReconstructChr(CharacterTransfer ct, MapleClient client, boolean isChannel) {

    MapleCharacter ret = new MapleCharacter(true);

    ret.client = client;

    if (!(isChannel)) {

      ret.client.setChannel(ct.channel);

    }

    ret.id = ct.characterid;

    ret.name = ct.name;

    ret.level = ct.level;

    ret.fame = ct.fame;

 

    ret.CRand = new PlayerRandomStream();

 

    ret.stats.str = ct.str;

    ret.stats.dex = ct.dex;

    ret.stats.int_ = ct.int_;

    ret.stats.luk = ct.luk;

    ret.stats.maxhp = ct.maxhp;

    ret.stats.maxmp = ct.maxmp;

    ret.stats.hp = ct.hp;

    ret.stats.mp = ct.mp;

 

    ret.characterCard.setCards(ct.cardsInfo);

 

    ret.chalktext = ct.chalkboard;

    ret.gmLevel = ct.gmLevel;

    ret.exp = (((((ret.level >= 200) || ((GameConstants.isKOC(ret.job)) && (ret.level >= 120)))) && (!(ret.isIntern()))) ? 0 : ct.exp);

    ret.hpApUsed = ct.hpApUsed;

    ret.remainingSp = ct.remainingSp;

    ret.remainingAp = ct.remainingAp;

    ret.meso = ct.meso;

    ret.skinColor = ct.skinColor;

    ret.gender = ct.gender;

    ret.job = ct.job;

    ret.hair = ct.hair;

    ret.face = ct.face;

    ret.demonMarking = ct.demonMarking;

    ret.accountid = ct.accountid;

    ret.totalWins = ct.totalWins;

    ret.totalLosses = ct.totalLosses;

    client.setAccID(ct.accountid);

    ret.mapid = ct.mapid;

    ret.initialSpawnPoint = ct.initialSpawnPoint;

    ret.world = ct.world;

    ret.guildid = ct.guildid;

    ret.guildrank = ct.guildrank;

    ret.guildContribution = ct.guildContribution;

    ret.allianceRank = ct.alliancerank;

    ret.points = ct.points;

    ret.vpoints = ct.vpoints;

    ret.fairyExp = ct.fairyExp;

    ret.cardStack = ct.cardStack;

    ret.marriageId = ct.marriageId;

    ret.currentrep = ct.currentrep;

    ret.totalrep = ct.totalrep;

    ret.gachexp = ct.gachexp;

    ret.pvpExp = ct.pvpExp;

    ret.pvpPoints = ct.pvpPoints;

 

    ret.reborns = ct.reborns;

    ret.apstorage = ct.apstorage;

    ret.occupationId = ct.occupationId;

    ret.occupationEXP = ct.occupationEXP;

 

    ret.makeMFC(ct.familyid, ct.seniorid, ct.junior1, ct.junior2);

    if (ret.guildid > 0) {

      ret.mgc = new MapleGuildCharacter(ret);

    }

    ret.fatigue = ct.fatigue;

    ret.buddylist = new BuddyList(ct.buddysize);

    ret.subcategory = ct.subcategory;

 

    if (isChannel) {

      MapleMapFactory mapFactory = ChannelServer.getInstance(client.getChannel()).getMapFactory();

      ret.map = mapFactory.getMap(ret.mapid);

      if (ret.map == null) {

        ret.map = mapFactory.getMap(100000000);

      }

      else if ((ret.map.getForcedReturnId() != 999999999) && (ret.map.getForcedReturnMap() != null)) {

        ret.map = ret.map.getForcedReturnMap();

      }

 

      MaplePortal portal = ret.map.getPortal(ret.initialSpawnPoint);

      if (portal == null) {

        portal = ret.map.getPortal(0);

        ret.initialSpawnPoint = 0;

      }

      ret.setPosition(portal.getPosition());

 

      int messengerid = ct.messengerid;

      if (messengerid > 0)

        ret.messenger = World.Messenger.getMessenger(messengerid);

    }

    else

    {

      ret.messenger = null;

    }

    int partyid = ct.partyid;

    if (partyid >= 0) {

      MapleParty party = World.Party.getParty(partyid);

      if ((party != null) && (party.getMemberById(ret.id) != null)) {

        ret.party = party;

      }

 

    }

 

    for (Iterator i$ = ct.Quest.entrySet().iterator(); i$.hasNext(); ) { Map.Entry<Integer, Object> qs = (Map.Entry)i$.next();

      MapleQuestStatus queststatus_from = (MapleQuestStatus)qs.getValue();

      queststatus_from.setQuest(((Integer)qs.getKey()).intValue());

      ret.quests.put(queststatus_from.getQuest(), queststatus_from);

    }

    for (Iterator i$ = ct.Skills.entrySet().iterator(); i$.hasNext(); ) { Map.Entry<Integer, SkillEntry> qs = (Map.Entry)i$.next();

      ret.skills.put(SkillFactory.getSkill(((Integer)qs.getKey()).intValue()), qs.getValue());

    }

    for (Integer zz : ct.finishedAchievements) {

      ret.finishedAchievements.add(zz);

    }

    for (Iterator i$ = ct.boxed.iterator(); i$.hasNext(); ) { Object zz = i$.next();

      Battler zzz = (Battler)zz;

      zzz.setStats();

      ret.boxed.add(zzz);

    }

    for (Map.Entry t : ct.traits.entrySet()) {

      ((MapleTrait)ret.traits.get(t.getKey())).setExp(((Integer)t.getValue()).intValue());

    }

    for (Iterator i$ = ct.reports.entrySet().iterator(); i$.hasNext(); ) { Map.Entry<Byte, Integer> qs = (Map.Entry)i$.next();

      ret.reports.put(ReportType.getById(((Byte)qs.getKey()).byteValue()), qs.getValue());

    }

    ret.monsterbook = new MonsterBook(ct.mbook, ret);

    ret.inventory = ((MapleInventory[])(MapleInventory[])ct.inventorys);

    ret.BlessOfFairy_Origin = ct.BlessOfFairy;

    ret.BlessOfEmpress_Origin = ct.BlessOfEmpress;

    ret.skillMacros = ((SkillMacro[])(SkillMacro[])ct.skillmacro);

    ret.battlers = ((Battler[])(Battler[])ct.battlers);

    for (Battler b : ret.battlers) {

      if (b != null) {

        b.setStats();

      }

    }

    ret.petStore = ct.petStore;

    ret.keylayout = new MapleKeyLayout(ct.keymap);

    ret.questinfo = ct.InfoQuest;

    ret.familiars = ct.familiars;

    ret.savedLocations = ct.savedlocation;

    ret.wishlist = ct.wishlist;

    ret.rocks = ct.rocks;

    ret.regrocks = ct.regrocks;

    ret.hyperrocks = ct.hyperrocks;

    ret.buddylist.loadFromTransfer(ct.buddies);

    ret.keydown_skill = 0L;

    ret.lastfametime = ct.lastfametime;

    ret.lastmonthfameids = ct.famedcharacters;

    ret.lastmonthbattleids = ct.battledaccs;

    ret.extendedSlots = ct.extendedSlots;

    ret.storage = ((MapleStorage)ct.storage);

    ret.cs = ((CashShop)ct.cs);

    client.setAccountName(ct.accountname);

    ret.acash = ct.ACash;

    ret.maplepoints = ct.MaplePoints;

    ret.numClones = ct.clonez;

    ret.imps = ct.imps;

    ret.anticheat = ((CheatTracker)ct.anticheat);

    ret.anticheat.start(ret);

    ret.rebuy = ct.rebuy;

    ret.mount = new MapleMount(ret, ct.mount_itemid, PlayerStats.getSkillByJob(1004, ret.job), ct.mount_Fatigue, ct.mount_level, ct.mount_exp);

    ret.expirationTask(false, false);

    ret.stats.recalcLocalStats(true, ret);

    client.setTempIP(ct.tempIP);

 

    return ret;

  }

 

  public static MapleCharacter loadCharFromDB(int charid, MapleClient client, boolean channelserver) {

    return loadCharFromDB(charid, client, channelserver, null);

  }

 

  public static MapleCharacter loadCharFromDB(int charid, MapleClient client, boolean channelserver, Map<Integer, CardData> cads) {

    MapleCharacter ret = new MapleCharacter(channelserver);

    ret.client = client;

    ret.id = charid;

 

    Connection con = DatabaseConnection.getConnection();

    PreparedStatement ps = null;

    PreparedStatement pse = null;

    ResultSet rs = null;

    try

    {

      ps = con.prepareStatement("SELECT * FROM characters WHERE id = ?");

      ps.setInt(1, charid);

      rs = ps.executeQuery();

      if (!(rs.next())) {

        rs.close();

        ps.close();

        throw new RuntimeException("Loading the Char Failed (char not found)");

      }

      ret.name = rs.getString("name");

      ret.level = rs.getShort("level");

      ret.fame = rs.getInt("fame");

 

      ret.stats.str = rs.getShort("str");

      ret.stats.dex = rs.getShort("dex");

      ret.stats.int_ = rs.getShort("int");

      ret.stats.luk = rs.getShort("luk");

      ret.stats.maxhp = rs.getInt("maxhp");

      ret.stats.maxmp = rs.getInt("maxmp");

      ret.stats.hp = rs.getInt("hp");

      ret.stats.mp = rs.getInt("mp");

      ret.job = rs.getShort("job");

      ret.gmLevel = rs.getByte("gm");

      ret.exp = (((((ret.level >= 200) || ((GameConstants.isKOC(ret.job)) && (ret.level >= 120)))) && (!(ret.isIntern()))) ? 0 : rs.getInt("exp"));

      ret.hpApUsed = rs.getShort("hpApUsed");

      String[] sp = rs.getString("sp").split(",");

      for (int i = 0; i < ret.remainingSp.length; ++i) {

        ret.remainingSp[i] = Integer.parseInt(sp[i]);

      }

      ret.remainingAp = rs.getShort("ap");

      ret.meso = rs.getInt("meso");

      ret.skinColor = rs.getByte("skincolor");

      ret.gender = rs.getByte("gender");

 

      ret.hair = rs.getInt("hair");

      ret.face = rs.getInt("face");

      ret.demonMarking = rs.getInt("demonMarking");

      ret.accountid = rs.getInt("accountid");

      client.setAccID(ret.accountid);

      ret.mapid = rs.getInt("map");

      ret.initialSpawnPoint = rs.getByte("spawnpoint");

      ret.world = rs.getByte("world");

      ret.guildid = rs.getInt("guildid");

      ret.guildrank = rs.getByte("guildrank");

      ret.allianceRank = rs.getByte("allianceRank");

      ret.guildContribution = rs.getInt("guildContribution");

      ret.totalWins = rs.getInt("totalWins");

      ret.totalLosses = rs.getInt("totalLosses");

      ret.currentrep = rs.getInt("currentrep");

      ret.totalrep = rs.getInt("totalrep");

      ret.makeMFC(rs.getInt("familyid"), rs.getInt("seniorid"), rs.getInt("junior1"), rs.getInt("junior2"));

      if (ret.guildid > 0) {

        ret.mgc = new MapleGuildCharacter(ret);

      }

      ret.gachexp = rs.getInt("gachexp");

      ret.buddylist = new BuddyList(rs.getByte("buddyCapacity"));

      ret.subcategory = rs.getByte("subcategory");

      ret.mount = new MapleMount(ret, 0, PlayerStats.getSkillByJob(1004, ret.job), (byte) 0, (byte) 1, 0);

      ret.rank = rs.getInt("rank");

      ret.rankMove = rs.getInt("rankMove");

      ret.jobRank = rs.getInt("jobRank");

      ret.jobRankMove = rs.getInt("jobRankMove");

      ret.marriageId = rs.getInt("marriageId");

      ret.fatigue = rs.getShort("fatigue");

      ret.pvpExp = rs.getInt("pvpExp");

      ret.pvpPoints = rs.getInt("pvpPoints");

 

      ret.reborns = rs.getInt("reborns");

      ret.apstorage = rs.getInt("apstorage");

      ret.occupationId = rs.getShort("occupationId");

      ret.occupationEXP = rs.getShort("occupationEXP");

 

      for (MapleTrait t : ret.traits.values()) {

        t.setExp(rs.getInt(t.getType().name()));

      }

      if (channelserver) {

        ret.CRand = new PlayerRandomStream();

        ret.anticheat = new CheatTracker(ret);

        MapleMapFactory mapFactory = ChannelServer.getInstance(client.getChannel()).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");

        if (partyid >= 0) {

          MapleParty party = World.Party.getParty(partyid);

          if ((party != null) && (party.getMemberById(ret.id) != null)) {

            ret.party = party;

          }

        }

        String[] pets = rs.getString("pets").split(",");

        for (int i = 0; i < ret.petStore.length; ++i) {

          ret.petStore[i] = Byte.parseByte(pets[i]);

        }

        rs.close();

        ps.close();

        ps = con.prepareStatement("SELECT * FROM achievements WHERE accountid = ?");

        ps.setInt(1, ret.accountid);

        rs = ps.executeQuery();

        while (rs.next()) {

          ret.finishedAchievements.add(Integer.valueOf(rs.getInt("achievementid")));

        }

        ps.close();

        rs.close();

 

        ps = con.prepareStatement("SELECT * FROM reports WHERE characterid = ?");

        ps.setInt(1, charid);

        rs = ps.executeQuery();

        while (rs.next()) {

          if (ReportType.getById(rs.getByte("type")) != null);

          ret.reports.put(ReportType.getById(rs.getByte("type")), Integer.valueOf(rs.getInt("count")));

        }

 

      }

 

      rs.close();

      ps.close();

 

      if (cads != null)

        ret.characterCard.setCards(cads);

      else {

        ret.characterCard.loadCards(client, channelserver);

      }

 

      ps = con.prepareStatement("SELECT * FROM queststatus WHERE characterid = ?");

      ps.setInt(1, charid);

      rs = ps.executeQuery();

      pse = con.prepareStatement("SELECT * FROM queststatusmobs WHERE queststatusid = ?");

 

      while (rs.next()) {

        int id = rs.getInt("quest");

        MapleQuest q = MapleQuest.getInstance(id);

        byte stat = rs.getByte("status");

        if ((((stat == 1) || (stat == 2))) && (channelserver)) { if (q == null) continue; if (q.isBlocked())

            continue;

        }

        if ((stat == 1) && (channelserver) && (!(q.canStart(ret, null)))) {

          continue;

        }

        MapleQuestStatus status = new MapleQuestStatus(q, stat);

        long cTime = rs.getLong("time");

        if (cTime > -1L) {

          status.setCompletionTime(cTime * 1000L);

        }

        status.setForfeited(rs.getInt("forfeited"));

        status.setCustomData(rs.getString("customData"));

        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();

      Pair mit;

      if (channelserver) {

        ret.monsterbook = MonsterBook.loadCards(ret.accountid, ret);

 

        ps = con.prepareStatement("SELECT * FROM inventoryslot where characterid = ?");

        ps.setInt(1, charid);

        rs = ps.executeQuery();

 

        if (!(rs.next())) {

          rs.close();

          ps.close();

          throw new RuntimeException("No Inventory slot column found in SQL. [inventoryslot]");

        }

        ret.getInventory(MapleInventoryType.EQUIP).setSlotLimit(rs.getByte("equip"));

        ret.getInventory(MapleInventoryType.USE).setSlotLimit(rs.getByte("use"));

        ret.getInventory(MapleInventoryType.SETUP).setSlotLimit(rs.getByte("setup"));

        ret.getInventory(MapleInventoryType.ETC).setSlotLimit(rs.getByte("etc"));

        ret.getInventory(MapleInventoryType.CASH).setSlotLimit(rs.getByte("cash"));

 

        ps.close();

        rs.close();

 

        for (Iterator i$ = ItemLoader.INVENTORY.loadItems(false, charid).values().iterator(); i$.hasNext(); ) { mit = (Pair)i$.next();

          ret.getInventory((MapleInventoryType)mit.getRight()).addFromDB((Item)mit.getLeft());

          if (((Item)mit.getLeft()).getPet() != null) {

            ret.pets.add(((Item)mit.getLeft()).getPet());

          }

        }

 

        ps = con.prepareStatement("SELECT * FROM accounts WHERE id = ?");

        ps.setInt(1, ret.accountid);

        rs = ps.executeQuery();

        if (rs.next()) {

          ret.getClient().setAccountName(rs.getString("name"));

          ret.acash = rs.getInt("ACash");

          ret.maplepoints = rs.getInt("mPoints");

          ret.points = rs.getInt("points");

          ret.vpoints = rs.getInt("vpoints");

 

          if (rs.getTimestamp("lastlogon") != null) {

            Calendar cal = Calendar.getInstance();

            cal.setTimeInMillis(rs.getTimestamp("lastlogon").getTime());

            if (cal.get(7) + 1 == Calendar.getInstance().get(7)) {

              ret.acash += 500;

            }

          }

          if (rs.getInt("banned") > 0) {

            rs.close();

            ps.close();

            ret.getClient().getSession().close();

            throw new RuntimeException("Loading a banned character");

          }

          rs.close();

          ps.close();

 

          ps = con.prepareStatement("UPDATE accounts SET lastlogon = CURRENT_TIMESTAMP() WHERE id = ?");

          ps.setInt(1, ret.accountid);

          ps.executeUpdate();

        } else {

          rs.close();

        }

        ps.close();

 

        ps = con.prepareStatement("SELECT * FROM questinfo WHERE characterid = ?");

        ps.setInt(1, charid);

        rs = ps.executeQuery();

 

        while (rs.next()) {

          ret.questinfo.put(Integer.valueOf(rs.getInt("quest")), rs.getString("customData"));

        }

        rs.close();

        ps.close();

 

        ps = con.prepareStatement("SELECT skillid, skilllevel, masterlevel, expiration, slot, equipped FROM skills WHERE characterid = ?");

        ps.setInt(1, charid);

        rs = ps.executeQuery();

 

        while (rs.next()) {

          int skid = rs.getInt("skillid");

          Skill skil = SkillFactory.getSkill(skid);

          int skl = rs.getInt("skilllevel");

          byte msl = rs.getByte("masterlevel");

          if ((skil != null) && (GameConstants.isApplicableSkill(skid))) {

            if ((skl > skil.getMaxLevel()) && (skid < 92000000)) {

              if ((!(skil.isBeginnerSkill())) && (skil.canBeLearnedBy(ret.job)) && (!(skil.isSpecialSkill()))) {

                ret.remainingSp[GameConstants.getSkillBookForSkill(skid)] += skl - skil.getMaxLevel();

              }

              skl = (byte)skil.getMaxLevel();

            }

            if (msl > skil.getMaxLevel()) {

              msl = (byte)skil.getMaxLevel();

            }

            ret.skills.put(skil, new SkillEntry(skl, msl, rs.getLong("expiration"), rs.getByte("slot"), rs.getByte("equipped")));

          } else if ((skil == null) &&

            (!(GameConstants.isBeginnerJob(skid / 10000))) && (skid / 10000 != 900) && (skid / 10000 != 800) && (skid / 10000 != 9000)) {

            ret.remainingSp[GameConstants.getSkillBookForSkill(skid)] += skl;

          }

        }

 

        rs.close();

        ps.close();

 

        ret.expirationTask(false, true);

 

        ps = con.prepareStatement("SELECT * FROM characters WHERE accountid = ? ORDER BY level DESC");

        ps.setInt(1, ret.accountid);

        rs = ps.executeQuery();

        int maxlevel_ = 0; int maxlevel_2 = 0;

        while (rs.next()) {

          if (rs.getInt("id") != charid);

          if (GameConstants.isKOC(rs.getShort("job"))) {

            int maxlevel = rs.getShort("level") / 5;

 

            if (maxlevel > 24) {

              maxlevel = 24;

            }

            if ((maxlevel > maxlevel_2) || (maxlevel_2 == 0)) {

              maxlevel_2 = maxlevel;

              ret.BlessOfEmpress_Origin = rs.getString("name");

            }

          }

          int maxlevel = rs.getShort("level") / 10;

 

          if (maxlevel > 20) {

            maxlevel = 20;

          }

          if ((maxlevel > maxlevel_) || (maxlevel_ == 0)) {

            maxlevel_ = maxlevel;

            ret.BlessOfFairy_Origin = rs.getString("name");

          }

 

        }

 

        if (ret.BlessOfFairy_Origin == null) {

          ret.BlessOfFairy_Origin = ret.name;

        }

        ret.skills.put(SkillFactory.getSkill(GameConstants.getBOF_ForJob(ret.job)), new SkillEntry(maxlevel_, (byte) 0, -1L));

        if (SkillFactory.getSkill(GameConstants.getEmpress_ForJob(ret.job)) != null) {

          if (ret.BlessOfEmpress_Origin == null) {

            ret.BlessOfEmpress_Origin = ret.BlessOfFairy_Origin;

          }

          ret.skills.put(SkillFactory.getSkill(GameConstants.getEmpress_ForJob(ret.job)), new SkillEntry(maxlevel_2, (byte) 0, -1L));

        }

        ps.close();

        rs.close();

 

        ps = con.prepareStatement("SELECT * FROM skillmacros WHERE characterid = ?");

        ps.setInt(1, charid);

        rs = ps.executeQuery();

        int position;

        while (rs.next()) {

          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 * FROM familiars WHERE characterid = ?");

        ps.setInt(1, charid);

        rs = ps.executeQuery();

        while (rs.next()) {

          if (rs.getLong("expiry") <= System.currentTimeMillis()) {

            continue;

          }

          ret.familiars.put(Integer.valueOf(rs.getInt("familiar")), new MonsterFamiliar(charid, rs.getInt("id"), rs.getInt("familiar"), rs.getLong("expiry"), rs.getString("name"), rs.getInt("fatigue"), rs.getByte("vitality")));

        }

        rs.close();

        ps.close();

 

        ps = con.prepareStatement("SELECT * FROM pokemon WHERE characterid = ? OR (accountid = ? AND active = 0)");

        ps.setInt(1, charid);

        ps.setInt(2, ret.accountid);

        rs = ps.executeQuery();

        position = 0;

        while (rs.next()) {

          Battler b = new Battler(rs.getInt("level"), rs.getInt("exp"), charid, rs.getInt("monsterid"), rs.getString("name"), BattleConstants.PokemonNature.values()[rs.getInt("nature")], rs.getInt("itemid"), rs.getByte("gender"), rs.getByte("hpiv"), rs.getByte("atkiv"), rs.getByte("defiv"), rs.getByte("spatkiv"), rs.getByte("spdefiv"), rs.getByte("speediv"), rs.getByte("evaiv"), rs.getByte("acciv"), rs.getByte("ability"));

          if (b.getFamily() == null) {

            continue;

          }

          if ((rs.getInt("active") > 0) && (position < 6) && (rs.getInt("characterid") == charid)) {

            ret.battlers[position] = b;

            ++position;

          } else {

            ret.boxed.add(b);

          }

        }

        rs.close();

        ps.close();

 

        ps = con.prepareStatement("SELECT `key`,`type`,`action` FROM keymap WHERE characterid = ?");

        ps.setInt(1, charid);

        rs = ps.executeQuery();

 

        Map keyb = ret.keylayout.Layout();

        while (rs.next()) {

          keyb.put(Integer.valueOf(rs.getInt("key")), new Pair(Byte.valueOf(rs.getByte("type")), Integer.valueOf(rs.getInt("action"))));

        }

        rs.close();

        ps.close();

        ret.keylayout.unchanged();

 

        ps = con.prepareStatement("SELECT `locationtype`,`map` FROM savedlocations WHERE characterid = ?");

        ps.setInt(1, charid);

        rs = ps.executeQuery();

        while (rs.next()) {

          ret.savedLocations[rs.getInt("locationtype")] = rs.getInt("map");

        }

        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 = 0L;

        ret.lastmonthfameids = new ArrayList(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 `accid_to`,`when` FROM battlelog WHERE accid = ? AND DATEDIFF(NOW(),`when`) < 30");

        ps.setInt(1, ret.accountid);

        rs = ps.executeQuery();

        ret.lastmonthbattleids = new ArrayList();

        while (rs.next()) {

          ret.lastmonthbattleids.add(Integer.valueOf(rs.getInt("accid_to")));

        }

        rs.close();

        ps.close();

 

        ps = con.prepareStatement("SELECT `itemId` FROM extendedSlots WHERE characterid = ?");

        ps.setInt(1, charid);

        rs = ps.executeQuery();

        while (rs.next()) {

          ret.extendedSlots.add(Integer.valueOf(rs.getInt("itemId")));

        }

        rs.close();

        ps.close();

 

        ret.buddylist.loadFromDb(charid);

        ret.storage = MapleStorage.loadStorage(ret.accountid);