API tools faq
paste
Advertisement
horato

core? lol gl

horato
Aug 23rd, 2011
127
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 228.77 KB | None | 0 0
raw download clone embed print report
  1.  
  2. ### Eclipse Workspace Patch 1.0
  3. #P L2J_Server_BETA
  4. Index: java/com/l2jserver/gameserver/model/actor/L2Attackable.java
  5. ===================================================================
  6. --- java/com/l2jserver/gameserver/model/actor/L2Attackable.java (revision 4769)
  7. +++ java/com/l2jserver/gameserver/model/actor/L2Attackable.java (working copy)
  8. @@ -36,6 +36,7 @@
  9. import com.l2jserver.gameserver.datatables.ItemTable;
  10. import com.l2jserver.gameserver.datatables.SkillTable;
  11. import com.l2jserver.gameserver.instancemanager.CursedWeaponsManager;
  12. +import com.l2jserver.gameserver.model.CharacterAchievementSystem;
  13. import com.l2jserver.gameserver.model.L2CharPosition;
  14. import com.l2jserver.gameserver.model.L2CommandChannel;
  15. import com.l2jserver.gameserver.model.L2DropCategory;
  16. @@ -51,6 +52,7 @@
  17. import com.l2jserver.gameserver.model.actor.instance.L2NpcInstance;
  18. import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
  19. import com.l2jserver.gameserver.model.actor.instance.L2PetInstance;
  20. +import com.l2jserver.gameserver.model.actor.instance.L2RaidBossInstance;
  21. import com.l2jserver.gameserver.model.actor.instance.L2SummonInstance;
  22. import com.l2jserver.gameserver.model.actor.knownlist.AttackableKnownList;
  23. import com.l2jserver.gameserver.model.actor.status.AttackableStatus;
  24. @@ -536,6 +538,18 @@
  25. if (!super.doDie(killer))
  26. return false;
  27.  
  28. + if(!(this instanceof L2GrandBossInstance) && !(this instanceof L2RaidBossInstance))
  29. + {
  30. + L2PcInstance player = null;
  31. + if(killer instanceof L2PcInstance)
  32. + player = killer.getActingPlayer();
  33. + else if(killer instanceof L2PetInstance || killer instanceof L2SummonInstance)
  34. + player = killer.getPet().getOwner();
  35. + if(player != null)
  36. + if (CharacterAchievementSystem.checkOk(player))
  37. + player.getCAS().onMobKill();
  38. + }
  39. +
  40. // Notify the Quest Engine of the L2Attackable death if necessary
  41. try
  42. {
  43. Index: java/com/l2jserver/gameserver/model/actor/instance/L2ChestInstance.java
  44. ===================================================================
  45. --- java/com/l2jserver/gameserver/model/actor/instance/L2ChestInstance.java (revision 4769)
  46. +++ java/com/l2jserver/gameserver/model/actor/instance/L2ChestInstance.java (working copy)
  47. @@ -18,6 +18,7 @@
  48.  
  49. import com.l2jserver.gameserver.datatables.NpcTable;
  50. import com.l2jserver.gameserver.datatables.SkillTable;
  51. +import com.l2jserver.gameserver.model.CharacterAchievementSystem;
  52. import com.l2jserver.gameserver.model.L2Skill;
  53. import com.l2jserver.gameserver.model.actor.L2Character;
  54. import com.l2jserver.gameserver.network.serverpackets.MagicSkillUse;
  55. @@ -73,6 +74,12 @@
  56. @Override
  57. public void doItemDrop(L2NpcTemplate npcTemplate, L2Character lastAttacker)
  58. {
  59. + if (lastAttacker instanceof L2PcInstance)
  60. + {
  61. + L2PcInstance player = lastAttacker.getActingPlayer();
  62. + if (CharacterAchievementSystem.checkOk(player))
  63. + player.getCAS().onChestOpen();
  64. + }
  65. int id = getTemplate().npcId;
  66.  
  67. if (!_specialDrop)
  68. Index: java/com/l2jserver/gameserver/model/actor/instance/L2AioNpcInstance.java
  69. ===================================================================
  70. --- java/com/l2jserver/gameserver/model/actor/instance/L2AioNpcInstance.java (revision 0)
  71. +++ java/com/l2jserver/gameserver/model/actor/instance/L2AioNpcInstance.java (revision 0)
  72. @@ -0,0 +1,1289 @@
  73. +/*
  74. + * This program is free software: you can redistribute it and/or modify it under
  75. + * the terms of the GNU General Public License as published by the Free Software
  76. + * Foundation, either version 3 of the License, or (at your option) any later
  77. + * version.
  78. + *
  79. + * This program is distributed in the hope that it will be useful, but WITHOUT
  80. + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  81. + * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
  82. + * details.
  83. + *
  84. + * You should have received a copy of the GNU General Public License along with
  85. + * this program. If not, see <http://www.gnu.org/licenses/>.
  86. + */
  87. +package com.l2jserver.gameserver.model.actor.instance;
  88. +
  89. +import java.util.Iterator;
  90. +import java.util.Set;
  91. +
  92. +import javolution.util.FastList;
  93. +
  94. +import com.l2jserver.Config;
  95. +import com.l2jserver.gameserver.datatables.CharTemplateTable;
  96. +import com.l2jserver.gameserver.datatables.ClanTable;
  97. +import com.l2jserver.gameserver.datatables.MultiSell;
  98. +import com.l2jserver.gameserver.datatables.SkillTable;
  99. +import com.l2jserver.gameserver.datatables.SkillTreesData;
  100. +import com.l2jserver.gameserver.instancemanager.CastleManager;
  101. +import com.l2jserver.gameserver.instancemanager.FortManager;
  102. +import com.l2jserver.gameserver.instancemanager.FortSiegeManager;
  103. +import com.l2jserver.gameserver.instancemanager.QuestManager;
  104. +import com.l2jserver.gameserver.instancemanager.SiegeManager;
  105. +import com.l2jserver.gameserver.model.L2Clan;
  106. +import com.l2jserver.gameserver.model.L2ClanMember;
  107. +import com.l2jserver.gameserver.model.L2ItemInstance;
  108. +import com.l2jserver.gameserver.model.L2Skill;
  109. +import com.l2jserver.gameserver.model.L2SkillLearn;
  110. +import com.l2jserver.gameserver.model.L2Clan.SubPledge;
  111. +import com.l2jserver.gameserver.model.actor.L2Npc;
  112. +import com.l2jserver.gameserver.model.base.ClassId;
  113. +import com.l2jserver.gameserver.model.base.PlayerClass;
  114. +import com.l2jserver.gameserver.model.base.Race;
  115. +import com.l2jserver.gameserver.model.base.SubClass;
  116. +import com.l2jserver.gameserver.model.entity.Castle;
  117. +import com.l2jserver.gameserver.model.entity.Fort;
  118. +import com.l2jserver.gameserver.model.olympiad.Olympiad;
  119. +import com.l2jserver.gameserver.model.quest.QuestState;
  120. +import com.l2jserver.gameserver.network.SystemMessageId;
  121. +import com.l2jserver.gameserver.network.serverpackets.AcquireSkillList;
  122. +import com.l2jserver.gameserver.network.serverpackets.ActionFailed;
  123. +import com.l2jserver.gameserver.network.serverpackets.ExBrExtraUserInfo;
  124. +import com.l2jserver.gameserver.network.serverpackets.MagicSkillLaunched;
  125. +import com.l2jserver.gameserver.network.serverpackets.MagicSkillUse;
  126. +import com.l2jserver.gameserver.network.serverpackets.NpcHtmlMessage;
  127. +import com.l2jserver.gameserver.network.serverpackets.SystemMessage;
  128. +import com.l2jserver.gameserver.network.serverpackets.UserInfo;
  129. +import com.l2jserver.gameserver.network.serverpackets.AcquireSkillList.SkillType;
  130. +import com.l2jserver.gameserver.templates.chars.L2NpcTemplate;
  131. +import com.l2jserver.gameserver.util.Util;
  132. +import com.l2jserver.util.StringUtil;
  133. +
  134. +public class L2AioNpcInstance extends L2Npc
  135. +{
  136. +
  137. + public L2AioNpcInstance(int objectId, L2NpcTemplate template)
  138. + {
  139. + super(objectId, template);
  140. + setIsInvul(false);
  141. + }
  142. +
  143. + @Override
  144. + public String getHtmlPath(int npcId, int val)
  145. + {
  146. + String pom = "";
  147. +
  148. + if (val == 0)
  149. + pom = "" + npcId;
  150. + else
  151. + pom = npcId + "-" + val;
  152. +
  153. + return "data/html/default/" + pom + ".htm";
  154. + }
  155. +
  156. + @Override
  157. + public void onBypassFeedback(L2PcInstance player, String command)
  158. + {
  159. + final int[] _itemsIds = { 10280, 10281, 10282, 10283, 10284, 10285, 10286, 10287, 10288, 10289, 10290, 10291, 10292, 10293, 10294, 10612 };
  160. + final String htmlFolder = "data/html/masterTransformation/";
  161. + final int feeDeleteSubClassSkills = 10000000;
  162. + final String[] _questVarNames = { "EmergentAbility65-", "EmergentAbility70-", "ClassAbility75-", "ClassAbility80-" };
  163. +
  164. + String[] commandStr = command.split(" ");
  165. + String actualCommand = commandStr[0]; // Get actual command
  166. +
  167. + String cmdParams = "";
  168. + String cmdParams2 = "";
  169. +
  170. + if (commandStr.length >= 2)
  171. + cmdParams = commandStr[1];
  172. + if (commandStr.length >= 3)
  173. + cmdParams2 = commandStr[2];
  174. +
  175. + if (command.startsWith("ShowOlyManager"))
  176. + {
  177. + String filename = null;
  178. + if (player.isNoble())
  179. + filename = Olympiad.OLYMPIAD_HTML_PATH + "noble_main.htm";
  180. + else
  181. + filename = "data/html/default/aio/oly/31688.htm";
  182. + showChatWindow(player, filename);
  183. + }
  184. + else if (command.startsWith("ShowOlyMonument"))
  185. + {
  186. + String filename = null;
  187. + if (player.isHero() || player.isNoble())
  188. + filename = Olympiad.OLYMPIAD_HTML_PATH + "hero_main.htm";
  189. + else
  190. + filename = "data/html/default/31690.htm";
  191. + showChatWindow(player, filename);
  192. + }
  193. +
  194. + else if (actualCommand.equalsIgnoreCase("create_clan"))
  195. + {
  196. + if (cmdParams.isEmpty())
  197. + return;
  198. +
  199. + ClanTable.getInstance().createClan(player, cmdParams);
  200. + }
  201. + else if (actualCommand.equalsIgnoreCase("create_academy"))
  202. + {
  203. + if (cmdParams.isEmpty())
  204. + return;
  205. +
  206. + createSubPledge(player, cmdParams, null, L2Clan.SUBUNIT_ACADEMY, 5);
  207. + }
  208. + else if (actualCommand.equalsIgnoreCase("rename_pledge"))
  209. + {
  210. + if (cmdParams.isEmpty() || cmdParams2.isEmpty())
  211. + return;
  212. +
  213. + renameSubPledge(player, Integer.valueOf(cmdParams), cmdParams2);
  214. + }
  215. + else if (actualCommand.equalsIgnoreCase("create_royal"))
  216. + {
  217. + if (cmdParams.isEmpty())
  218. + return;
  219. +
  220. + createSubPledge(player, cmdParams, cmdParams2, L2Clan.SUBUNIT_ROYAL1, 6);
  221. + }
  222. + else if (actualCommand.equalsIgnoreCase("create_knight"))
  223. + {
  224. + if (cmdParams.isEmpty())
  225. + return;
  226. +
  227. + createSubPledge(player, cmdParams, cmdParams2, L2Clan.SUBUNIT_KNIGHT1, 7);
  228. + }
  229. + else if (actualCommand.equalsIgnoreCase("assign_subpl_leader"))
  230. + {
  231. + if (cmdParams.isEmpty())
  232. + return;
  233. +
  234. + assignSubPledgeLeader(player, cmdParams, cmdParams2);
  235. + }
  236. + else if (actualCommand.equalsIgnoreCase("create_ally"))
  237. + {
  238. + if (cmdParams.isEmpty())
  239. + return;
  240. +
  241. + if (player.getClan() == null)
  242. + player.sendPacket(SystemMessage.getSystemMessage(SystemMessageId.ONLY_CLAN_LEADER_CREATE_ALLIANCE));
  243. + else
  244. + player.getClan().createAlly(player, cmdParams);
  245. + }
  246. + else if (actualCommand.equalsIgnoreCase("dissolve_ally"))
  247. + {
  248. + player.getClan().dissolveAlly(player);
  249. + }
  250. + else if (actualCommand.equalsIgnoreCase("dissolve_clan"))
  251. + {
  252. + dissolveClan(player, player.getClanId());
  253. + }
  254. + else if (actualCommand.equalsIgnoreCase("change_clan_leader"))
  255. + {
  256. + if (cmdParams.isEmpty())
  257. + return;
  258. +
  259. + changeClanLeader(player, cmdParams);
  260. + }
  261. + else if (actualCommand.equalsIgnoreCase("recover_clan"))
  262. + {
  263. + recoverClan(player, player.getClanId());
  264. + }
  265. + else if (actualCommand.equalsIgnoreCase("increase_clan_level"))
  266. + {
  267. + if (player.getClan().levelUpClan(player))
  268. + {
  269. + player.broadcastPacket(new MagicSkillUse(player, 5103, 1, 0, 0));
  270. + player.broadcastPacket(new MagicSkillLaunched(player, 5103, 1));
  271. + }
  272. + }
  273. + else if (actualCommand.equalsIgnoreCase("learn_clan_skills"))
  274. + {
  275. + showPledgeSkillList(player);
  276. + }
  277. + else if (command.startsWith("Subclass"))
  278. + {
  279. + // Subclasses may not be changed while a skill is in use.
  280. + if (player.isCastingNow() || player.isAllSkillsDisabled())
  281. + {
  282. + player.sendPacket(SystemMessage.getSystemMessage(SystemMessageId.SUBCLASS_NO_CHANGE_OR_CREATE_WHILE_SKILL_IN_USE));
  283. + return;
  284. + }
  285. +
  286. + NpcHtmlMessage html = new NpcHtmlMessage(getObjectId());
  287. +
  288. + if (player.getTransformation() != null)
  289. + {
  290. + html.setFile(player.getHtmlPrefix(), "data/html/villagemaster/SubClass_NoTransformed.htm");
  291. + player.sendPacket(html);
  292. + return;
  293. + }
  294. +
  295. + int cmdChoice = 0;
  296. + int paramOne = 0;
  297. + int paramTwo = 0;
  298. +
  299. + try
  300. + {
  301. + cmdChoice = Integer.parseInt(command.substring(9, 10).trim());
  302. +
  303. + int endIndex = command.indexOf(' ', 11);
  304. + if (endIndex == -1)
  305. + endIndex = command.length();
  306. +
  307. + paramOne = Integer.parseInt(command.substring(11, endIndex).trim());
  308. + if (command.length() > endIndex)
  309. + paramTwo = Integer.parseInt(command.substring(endIndex).trim());
  310. + }
  311. + catch (Exception NumberFormatException)
  312. + {
  313. + }
  314. +
  315. + switch (cmdChoice)
  316. + {
  317. + case 0: // Subclass change menu
  318. + html.setFile(player.getHtmlPrefix(), getSubClassMenu(player.getRace()));
  319. + break;
  320. + case 1: // Add Subclass - Initial
  321. + // Avoid giving player an option to add a new sub class, if they have three already.
  322. + if (player.getTotalSubClasses() >= Config.MAX_SUBCLASS)
  323. + {
  324. + html.setFile(player.getHtmlPrefix(), getSubClassFail());
  325. + break;
  326. + }
  327. +
  328. + html.setFile(player.getHtmlPrefix(), "data/html/villagemaster/SubClass_Add.htm");
  329. + final StringBuilder content1 = StringUtil.startAppend(200);
  330. + Set<PlayerClass> subsAvailable = getAvailableSubClasses(player);
  331. +
  332. + if (subsAvailable != null && !subsAvailable.isEmpty())
  333. + {
  334. + for (PlayerClass subClass : subsAvailable)
  335. + {
  336. + StringUtil.append(content1, "<a action=\"bypass -h npc_%objectId%_Subclass 4 ", String.valueOf(subClass.ordinal()), "\" msg=\"1268;", formatClassForDisplay(subClass), "\">", formatClassForDisplay(subClass), "</a><br>");
  337. + }
  338. + }
  339. + else
  340. + {
  341. + // TODO: Retail message
  342. + player.sendMessage("There are no sub classes available at this time.");
  343. + return;
  344. + }
  345. + html.replace("%list%", content1.toString());
  346. + break;
  347. + case 2: // Change Class - Initial
  348. + if (player.getSubClasses().isEmpty())
  349. + html.setFile(player.getHtmlPrefix(), "data/html/villagemaster/SubClass_ChangeNo.htm");
  350. + else
  351. + {
  352. + final StringBuilder content2 = StringUtil.startAppend(200);
  353. +
  354. + if (checkVillageMaster(player.getBaseClass()))
  355. + {
  356. + StringUtil.append(content2, "<a action=\"bypass -h npc_%objectId%_Subclass 5 0\">", CharTemplateTable.getInstance().getClassNameById(player.getBaseClass()), "</a><br>");
  357. + }
  358. +
  359. + for (Iterator<SubClass> subList = iterSubClasses(player); subList.hasNext();)
  360. + {
  361. + SubClass subClass = subList.next();
  362. + if (checkVillageMaster(subClass.getClassDefinition()))
  363. + {
  364. + StringUtil.append(content2, "<a action=\"bypass -h npc_%objectId%_Subclass 5 ", String.valueOf(subClass.getClassIndex()), "\">", formatClassForDisplay(subClass.getClassDefinition()), "</a><br>");
  365. + }
  366. + }
  367. +
  368. + if (content2.length() > 0)
  369. + {
  370. + html.setFile(player.getHtmlPrefix(), "data/html/villagemaster/SubClass_Change.htm");
  371. + html.replace("%list%", content2.toString());
  372. + }
  373. + else
  374. + html.setFile(player.getHtmlPrefix(), "data/html/villagemaster/SubClass_ChangeNotFound.htm");
  375. + }
  376. + break;
  377. + case 3: // Change/Cancel Subclass - Initial
  378. + if (player.getSubClasses() == null || player.getSubClasses().isEmpty())
  379. + {
  380. + html.setFile(player.getHtmlPrefix(), "data/html/villagemaster/SubClass_ModifyEmpty.htm");
  381. + break;
  382. + }
  383. +
  384. + // custom value
  385. + if (player.getTotalSubClasses() > 3)
  386. + {
  387. + html.setFile(player.getHtmlPrefix(), "data/html/villagemaster/SubClass_ModifyCustom.htm");
  388. + final StringBuilder content3 = StringUtil.startAppend(200);
  389. + int classIndex = 1;
  390. +
  391. + for (Iterator<SubClass> subList = iterSubClasses(player); subList.hasNext();)
  392. + {
  393. + SubClass subClass = subList.next();
  394. +
  395. + StringUtil.append(content3, "Sub-class ", String.valueOf(classIndex++), "<br>", "<a action=\"bypass -h npc_%objectId%_Subclass 6 ", String.valueOf(subClass.getClassIndex()), "\">", CharTemplateTable.getInstance().getClassNameById(subClass.getClassId()), "</a><br>");
  396. + }
  397. + html.replace("%list%", content3.toString());
  398. + }
  399. + else
  400. + {
  401. + // retail html contain only 3 subclasses
  402. + html.setFile(player.getHtmlPrefix(), "data/html/villagemaster/SubClass_Modify.htm");
  403. + if (player.getSubClasses().containsKey(1))
  404. + html.replace("%sub1%", CharTemplateTable.getInstance().getClassNameById(player.getSubClasses().get(1).getClassId()));
  405. + else
  406. + html.replace("<a action=\"bypass -h npc_%objectId%_Subclass 6 1\">%sub1%</a><br>", "");
  407. +
  408. + if (player.getSubClasses().containsKey(2))
  409. + html.replace("%sub2%", CharTemplateTable.getInstance().getClassNameById(player.getSubClasses().get(2).getClassId()));
  410. + else
  411. + html.replace("<a action=\"bypass -h npc_%objectId%_Subclass 6 2\">%sub2%</a><br>", "");
  412. +
  413. + if (player.getSubClasses().containsKey(3))
  414. + html.replace("%sub3%", CharTemplateTable.getInstance().getClassNameById(player.getSubClasses().get(3).getClassId()));
  415. + else
  416. + html.replace("<a action=\"bypass -h npc_%objectId%_Subclass 6 3\">%sub3%</a><br>", "");
  417. + }
  418. + break;
  419. + case 4: // Add Subclass - Action (Subclass 4 x[x])
  420. + /*
  421. + * If the character is less than level 75 on any of their previously chosen
  422. + * classes then disallow them to change to their most recently added sub-class choice.
  423. + */
  424. +
  425. + if (!player.getFloodProtectors().getSubclass().tryPerformAction("add subclass"))
  426. + {
  427. + _log.warning("Player " + player.getName() + " has performed a subclass change too fast");
  428. + return;
  429. + }
  430. +
  431. + boolean allowAddition = true;
  432. +
  433. + if (player.getTotalSubClasses() >= Config.MAX_SUBCLASS)
  434. + allowAddition = false;
  435. +
  436. + if (player.getLevel() < 75)
  437. + allowAddition = false;
  438. +
  439. + if (allowAddition)
  440. + {
  441. + if (!player.getSubClasses().isEmpty())
  442. + {
  443. + for (Iterator<SubClass> subList = iterSubClasses(player); subList.hasNext();)
  444. + {
  445. + SubClass subClass = subList.next();
  446. +
  447. + if (subClass.getLevel() < 75)
  448. + {
  449. + allowAddition = false;
  450. + break;
  451. + }
  452. + }
  453. + }
  454. + }
  455. +
  456. + /*
  457. + * If quest checking is enabled, verify if the character has completed the Mimir's Elixir (Path to Subclass)
  458. + * and Fate's Whisper (A Grade Weapon) quests by checking for instances of their unique reward items.
  459. + *
  460. + * If they both exist, remove both unique items and continue with adding the sub-class.
  461. + */
  462. + if (allowAddition && !Config.ALT_GAME_SUBCLASS_WITHOUT_QUESTS)
  463. + allowAddition = checkQuests(player);
  464. +
  465. + if (allowAddition && isValidNewSubClass(player, paramOne))
  466. + {
  467. + if (!player.addSubClass(paramOne, player.getTotalSubClasses() + 1))
  468. + return;
  469. +
  470. + player.setActiveClass(player.getTotalSubClasses());
  471. +
  472. + html.setFile(player.getHtmlPrefix(), "data/html/villagemaster/SubClass_AddOk.htm");
  473. +
  474. + player.sendPacket(SystemMessage.getSystemMessage(SystemMessageId.ADD_NEW_SUBCLASS)); // Subclass added.
  475. + }
  476. + else
  477. + html.setFile(player.getHtmlPrefix(), getSubClassFail());
  478. + break;
  479. + case 5: // Change Class - Action
  480. + /*
  481. + * If the character is less than level 75 on any of their previously chosen
  482. + * classes then disallow them to change to their most recently added sub-class choice.
  483. + *
  484. + * Note: paramOne = classIndex
  485. + */
  486. +
  487. + if (!player.getFloodProtectors().getSubclass().tryPerformAction("change class"))
  488. + {
  489. + _log.warning("Player " + player.getName() + " has performed a subclass change too fast");
  490. + return;
  491. + }
  492. +
  493. + if (player.getClassIndex() == paramOne)
  494. + {
  495. + html.setFile(player.getHtmlPrefix(), "data/html/villagemaster/SubClass_Current.htm");
  496. + break;
  497. + }
  498. +
  499. + if (paramOne == 0)
  500. + {
  501. + if (!checkVillageMaster(player.getBaseClass()))
  502. + return;
  503. + }
  504. + else
  505. + {
  506. + try
  507. + {
  508. + if (!checkVillageMaster(player.getSubClasses().get(paramOne).getClassDefinition()))
  509. + return;
  510. + }
  511. + catch (NullPointerException e)
  512. + {
  513. + return;
  514. + }
  515. + }
  516. +
  517. + player.setActiveClass(paramOne);
  518. +
  519. + player.sendPacket(SystemMessage.getSystemMessage(SystemMessageId.SUBCLASS_TRANSFER_COMPLETED)); // Transfer completed.
  520. + return;
  521. + case 6: // Change/Cancel Subclass - Choice
  522. + // validity check
  523. + if (paramOne < 1 || paramOne > Config.MAX_SUBCLASS)
  524. + return;
  525. +
  526. + subsAvailable = getAvailableSubClasses(player);
  527. +
  528. + // another validity check
  529. + if (subsAvailable == null || subsAvailable.isEmpty())
  530. + {
  531. + // TODO: Retail message
  532. + player.sendMessage("There are no sub classes available at this time.");
  533. + return;
  534. + }
  535. +
  536. + final StringBuilder content6 = StringUtil.startAppend(200);
  537. +
  538. + for (PlayerClass subClass : subsAvailable)
  539. + {
  540. + StringUtil.append(content6, "<a action=\"bypass -h npc_%objectId%_Subclass 7 ", String.valueOf(paramOne), " ", String.valueOf(subClass.ordinal()), "\" msg=\"1445;", "\">", formatClassForDisplay(subClass), "</a><br>");
  541. + }
  542. +
  543. + switch (paramOne)
  544. + {
  545. + case 1:
  546. + html.setFile(player.getHtmlPrefix(), "data/html/villagemaster/SubClass_ModifyChoice1.htm");
  547. + break;
  548. + case 2:
  549. + html.setFile(player.getHtmlPrefix(), "data/html/villagemaster/SubClass_ModifyChoice2.htm");
  550. + break;
  551. + case 3:
  552. + html.setFile(player.getHtmlPrefix(), "data/html/villagemaster/SubClass_ModifyChoice3.htm");
  553. + break;
  554. + default:
  555. + html.setFile(player.getHtmlPrefix(), "data/html/villagemaster/SubClass_ModifyChoice.htm");
  556. + }
  557. + html.replace("%list%", content6.toString());
  558. + break;
  559. + case 7: // Change Subclass - Action
  560. + /*
  561. + * Warning: the information about this subclass will be removed from the
  562. + * subclass list even if false!
  563. + */
  564. +
  565. + if (!player.getFloodProtectors().getSubclass().tryPerformAction("change class"))
  566. + {
  567. + _log.warning("Player " + player.getName() + " has performed a subclass change too fast");
  568. + return;
  569. + }
  570. +
  571. + if (!isValidNewSubClass(player, paramTwo))
  572. + return;
  573. +
  574. + if (player.modifySubClass(paramOne, paramTwo))
  575. + {
  576. + player.abortCast();
  577. + player.stopAllEffectsExceptThoseThatLastThroughDeath(); // all effects from old subclass stopped!
  578. + player.stopCubics();
  579. + player.setActiveClass(paramOne);
  580. +
  581. + html.setFile(player.getHtmlPrefix(), "data/html/villagemaster/SubClass_ModifyOk.htm");
  582. + html.replace("%name%", CharTemplateTable.getInstance().getClassNameById(paramTwo));
  583. +
  584. + player.sendPacket(SystemMessage.getSystemMessage(SystemMessageId.ADD_NEW_SUBCLASS)); // Subclass added.
  585. + }
  586. + else
  587. + {
  588. + /*
  589. + * This isn't good! modifySubClass() removed subclass from memory
  590. + * we must update _classIndex! Else IndexOutOfBoundsException can turn
  591. + * up some place down the line along with other seemingly unrelated
  592. + * problems.
  593. + */
  594. + player.setActiveClass(0); // Also updates _classIndex plus switching _classid to baseclass.
  595. +
  596. + player.sendMessage("The sub class could not be added, you have been reverted to your base class.");
  597. + return;
  598. + }
  599. + break;
  600. + }
  601. +
  602. + html.replace("%objectId%", String.valueOf(getObjectId()));
  603. + player.sendPacket(html);
  604. + }
  605. + else if (command.startsWith("LearnSubClassSkill"))
  606. + {
  607. + if (player.isSubClassActive())
  608. + {
  609. + NpcHtmlMessage html = new NpcHtmlMessage(getObjectId());
  610. + html.setFile(player.getHtmlPrefix(), htmlFolder + "master_transformation008.htm");
  611. + player.sendPacket(html);
  612. + }
  613. + else
  614. + {
  615. + boolean hasItems = false;
  616. + for (int i : _itemsIds)
  617. + {
  618. + if (player.getInventory().getItemByItemId(i) != null)
  619. + {
  620. + hasItems = true;
  621. + break;
  622. + }
  623. + }
  624. + if (hasItems)
  625. + {
  626. + showSubClassSkillList(player);
  627. + }
  628. + else
  629. + {
  630. + NpcHtmlMessage html = new NpcHtmlMessage(getObjectId());
  631. + html.setFile(player.getHtmlPrefix(), htmlFolder + "master_transformation008.htm");
  632. + player.sendPacket(html);
  633. + }
  634. + }
  635. + return;
  636. + }
  637. + else if (command.startsWith("CancelCertification"))
  638. + {
  639. + final NpcHtmlMessage html = new NpcHtmlMessage(getObjectId());
  640. + if (player.getSubClasses().size() == 0)
  641. + {
  642. + html.setFile(player.getHtmlPrefix(), htmlFolder + "master_transformation007.htm");
  643. + }
  644. + else if (player.isSubClassActive())
  645. + {
  646. + html.setFile(player.getHtmlPrefix(), htmlFolder + "master_transformation008.htm");
  647. + }
  648. + else if (player.getAdena() < feeDeleteSubClassSkills)
  649. + {
  650. + html.setFile(player.getHtmlPrefix(), htmlFolder + "master_transformation008no.htm");
  651. + }
  652. + else
  653. + {
  654. + QuestState st = player.getQuestState("SubClassSkills");
  655. + if (st == null)
  656. + {
  657. + st = QuestManager.getInstance().getQuest("SubClassSkills").newQuestState(player);
  658. + }
  659. +
  660. + int activeCertifications = 0;
  661. + for (String varName : _questVarNames)
  662. + {
  663. + for (int i = 1; i <= Config.MAX_SUBCLASS; i++)
  664. + {
  665. + String qvar = st.getGlobalQuestVar(varName + i);
  666. + if (!qvar.isEmpty() && (qvar.endsWith(";") || !qvar.equals("0")))
  667. + {
  668. + activeCertifications++;
  669. + }
  670. + }
  671. + }
  672. + if (activeCertifications == 0)
  673. + {
  674. + html.setFile(player.getHtmlPrefix(), htmlFolder + "master_transformation010no.htm");
  675. + }
  676. + else
  677. + {
  678. + for (String varName : _questVarNames)
  679. + {
  680. + for (int i = 1; i <= Config.MAX_SUBCLASS; i++)
  681. + {
  682. + final String qvarName = varName + i;
  683. + final String qvar = st.getGlobalQuestVar(qvarName);
  684. + if (qvar.endsWith(";"))
  685. + {
  686. + final String skillIdVar = qvar.replace(";", "");
  687. + if (Util.isDigit(skillIdVar))
  688. + {
  689. + int skillId = Integer.parseInt(skillIdVar);
  690. + final L2Skill sk = SkillTable.getInstance().getInfo(skillId, 1);
  691. + if (sk != null)
  692. + {
  693. + player.removeSkill(sk);
  694. + st.saveGlobalQuestVar(qvarName, "0");
  695. + }
  696. + }
  697. + else
  698. + {
  699. + _log.warning("Invalid Sub-Class Skill Id: " + skillIdVar + " for player " + player.getName() + "!");
  700. + }
  701. + }
  702. + else if (!qvar.isEmpty() && !qvar.equals("0"))
  703. + {
  704. + if (Util.isDigit(qvar))
  705. + {
  706. + final int itemObjId = Integer.parseInt(qvar);
  707. + L2ItemInstance itemInstance = player.getInventory().getItemByObjectId(itemObjId);
  708. + if (itemInstance != null)
  709. + {
  710. + player.destroyItem("CancelCertification", itemObjId, 1, player, false);
  711. + }
  712. + else
  713. + {
  714. + itemInstance = player.getWarehouse().getItemByObjectId(itemObjId);
  715. + if (itemInstance != null)
  716. + {
  717. + _log.warning("Somehow " + player.getName() + " put a certification book into warehouse!");
  718. + player.getWarehouse().destroyItem("CancelCertification", itemInstance, 1, player, false);
  719. + }
  720. + else
  721. + {
  722. + _log.warning("Somehow " + player.getName() + " deleted a certification book!");
  723. + }
  724. + }
  725. + st.saveGlobalQuestVar(qvarName, "0");
  726. + }
  727. + else
  728. + {
  729. + _log.warning("Invalid item object Id: " + qvar + " for player " + player.getName() + "!");
  730. + }
  731. + }
  732. + }
  733. + }
  734. + st.takeItems(57, 10000000);
  735. + html.setFile(player.getHtmlPrefix(), htmlFolder + "master_transformation009no.htm");
  736. + player.sendSkillList();
  737. + }
  738. +
  739. + //Let's consume all certification books, even those not present in database.
  740. + L2ItemInstance itemInstance = null;
  741. + for (int itemId : _itemsIds)
  742. + {
  743. + itemInstance = player.getInventory().getItemByItemId(itemId);
  744. + if (itemInstance != null)
  745. + {
  746. + _log.warning(L2TransformManagerInstance.class.getName() + ": player " + player + " had 'extra' certification skill books while cancelling sub-class certifications!");
  747. + player.destroyItem("CancelCertificationExtraBooks", itemInstance, this, false);
  748. + }
  749. + }
  750. + }
  751. + player.sendPacket(html);
  752. + return;
  753. + }
  754. + if (command.startsWith("LearnTransformationSkill"))
  755. + {
  756. + if (canTransform(player))
  757. + {
  758. + L2TransformManagerInstance.showTransformSkillList(player);
  759. + }
  760. + else
  761. + {
  762. + NpcHtmlMessage html = new NpcHtmlMessage(getObjectId());
  763. + html.setFile(player.getHtmlPrefix(), htmlFolder + "master_transformation003.htm");
  764. + player.sendPacket(html);
  765. + }
  766. + return;
  767. + }
  768. + else if (command.startsWith("BuyTransformationItems"))
  769. + {
  770. + if (canTransform(player))
  771. + {
  772. + MultiSell.getInstance().separateAndSend(32323001, player, this, false);
  773. + }
  774. + else
  775. + {
  776. + NpcHtmlMessage html = new NpcHtmlMessage(getObjectId());
  777. + html.setFile(player.getHtmlPrefix(), htmlFolder + "master_transformation004.htm");
  778. + player.sendPacket(html);
  779. + }
  780. + return;
  781. + }
  782. + else
  783. + {
  784. + // this class dont know any other commands, let forward
  785. + // the command to the parent class
  786. + super.onBypassFeedback(player, command);
  787. + }
  788. + }
  789. +
  790. + private String getSubClassMenu(Race pRace)
  791. + {
  792. + if (Config.ALT_GAME_SUBCLASS_EVERYWHERE || pRace != Race.Kamael)
  793. + return "data/html/villagemaster/SubClass.htm";
  794. +
  795. + return "data/html/villagemaster/SubClass_NoOther.htm";
  796. + }
  797. +
  798. + private String getSubClassFail()
  799. + {
  800. + return "data/html/villagemaster/SubClass_Fail.htm";
  801. + }
  802. +
  803. + private final Set<PlayerClass> getAvailableSubClasses(L2PcInstance player)
  804. + {
  805. + // get player base class
  806. + final int currentBaseId = player.getBaseClass();
  807. + final ClassId baseCID = ClassId.values()[currentBaseId];
  808. +
  809. + // we need 2nd occupation ID
  810. + final int baseClassId;
  811. + if (baseCID.level() > 2)
  812. + baseClassId = baseCID.getParent().ordinal();
  813. + else
  814. + baseClassId = currentBaseId;
  815. +
  816. + Set<PlayerClass> availSubs = PlayerClass.values()[baseClassId].getAvailableSubclasses(player);
  817. +
  818. + if (availSubs != null && !availSubs.isEmpty())
  819. + {
  820. + for (Iterator<PlayerClass> availSub = availSubs.iterator(); availSub.hasNext();)
  821. + {
  822. + PlayerClass pclass = availSub.next();
  823. +
  824. + // check for the village master
  825. + if (!checkVillageMaster(pclass))
  826. + {
  827. + availSub.remove();
  828. + continue;
  829. + }
  830. +
  831. + // scan for already used subclasses
  832. + int availClassId = pclass.ordinal();
  833. + ClassId cid = ClassId.values()[availClassId];
  834. + for (Iterator<SubClass> subList = iterSubClasses(player); subList.hasNext();)
  835. + {
  836. + SubClass prevSubClass = subList.next();
  837. + ClassId subClassId = ClassId.values()[prevSubClass.getClassId()];
  838. +
  839. + if (subClassId.equalsOrChildOf(cid))
  840. + {
  841. + availSub.remove();
  842. + break;
  843. + }
  844. + }
  845. + }
  846. + }
  847. +
  848. + return availSubs;
  849. + }
  850. +
  851. + private static final String formatClassForDisplay(PlayerClass className)
  852. + {
  853. + String classNameStr = className.toString();
  854. + char[] charArray = classNameStr.toCharArray();
  855. +
  856. + for (int i = 1; i < charArray.length; i++)
  857. + {
  858. + if (Character.isUpperCase(charArray[i]))
  859. + classNameStr = classNameStr.substring(0, i) + " " + classNameStr.substring(i);
  860. + }
  861. +
  862. + return classNameStr;
  863. + }
  864. +
  865. + private final boolean checkVillageMaster(PlayerClass pclass)
  866. + {
  867. + if (Config.ALT_GAME_SUBCLASS_EVERYWHERE)
  868. + return true;
  869. +
  870. + return checkVillageMasterRace(pclass) && checkVillageMasterTeachType(pclass);
  871. + }
  872. +
  873. + private final boolean checkVillageMaster(int classId)
  874. + {
  875. + return checkVillageMaster(PlayerClass.values()[classId]);
  876. + }
  877. +
  878. + private static final Iterator<SubClass> iterSubClasses(L2PcInstance player)
  879. + {
  880. + return player.getSubClasses().values().iterator();
  881. + }
  882. +
  883. + private boolean checkQuests(L2PcInstance player)
  884. + {
  885. + // Noble players can add subbclasses without quests
  886. + if (player.isNoble())
  887. + return true;
  888. +
  889. + QuestState qs = player.getQuestState("234_FatesWhisper");
  890. + if (qs == null || !qs.isCompleted())
  891. + return false;
  892. +
  893. + qs = player.getQuestState("235_MimirsElixir");
  894. + if (qs == null || !qs.isCompleted())
  895. + return false;
  896. +
  897. + return true;
  898. + }
  899. +
  900. + private final boolean isValidNewSubClass(L2PcInstance player, int classId)
  901. + {
  902. + if (!checkVillageMaster(classId))
  903. + return false;
  904. +
  905. + final ClassId cid = ClassId.values()[classId];
  906. + for (Iterator<SubClass> subList = iterSubClasses(player); subList.hasNext();)
  907. + {
  908. + SubClass sub = subList.next();
  909. + ClassId subClassId = ClassId.values()[sub.getClassId()];
  910. +
  911. + if (subClassId.equalsOrChildOf(cid))
  912. + return false;
  913. + }
  914. +
  915. + // get player base class
  916. + final int currentBaseId = player.getBaseClass();
  917. + final ClassId baseCID = ClassId.values()[currentBaseId];
  918. +
  919. + // we need 2nd occupation ID
  920. + final int baseClassId;
  921. + if (baseCID.level() > 2)
  922. + baseClassId = baseCID.getParent().ordinal();
  923. + else
  924. + baseClassId = currentBaseId;
  925. +
  926. + Set<PlayerClass> availSubs = PlayerClass.values()[baseClassId].getAvailableSubclasses(player);
  927. + if (availSubs == null || availSubs.isEmpty())
  928. + return false;
  929. +
  930. + boolean found = false;
  931. + for (Iterator<PlayerClass> availSub = availSubs.iterator(); availSub.hasNext();)
  932. + {
  933. + PlayerClass pclass = availSub.next();
  934. + if (pclass.ordinal() == classId)
  935. + {
  936. + found = true;
  937. + break;
  938. + }
  939. + }
  940. +
  941. + return found;
  942. + }
  943. +
  944. + private boolean checkVillageMasterRace(PlayerClass pclass)
  945. + {
  946. + return true;
  947. + }
  948. +
  949. + private boolean checkVillageMasterTeachType(PlayerClass pclass)
  950. + {
  951. + return true;
  952. + }
  953. +
  954. + private static final void createSubPledge(L2PcInstance player, String clanName, String leaderName, int pledgeType, int minClanLvl)
  955. + {
  956. + if (!player.isClanLeader())
  957. + {
  958. + player.sendPacket(SystemMessage.getSystemMessage(SystemMessageId.YOU_ARE_NOT_AUTHORIZED_TO_DO_THAT));
  959. + return;
  960. + }
  961. +
  962. + final L2Clan clan = player.getClan();
  963. + if (clan.getLevel() < minClanLvl)
  964. + {
  965. + if (pledgeType == L2Clan.SUBUNIT_ACADEMY)
  966. + player.sendPacket(SystemMessage.getSystemMessage(SystemMessageId.YOU_DO_NOT_MEET_CRITERIA_IN_ORDER_TO_CREATE_A_CLAN_ACADEMY));
  967. + else
  968. + player.sendPacket(SystemMessage.getSystemMessage(SystemMessageId.YOU_DO_NOT_MEET_CRITERIA_IN_ORDER_TO_CREATE_A_MILITARY_UNIT));
  969. +
  970. + return;
  971. + }
  972. + if (!Util.isAlphaNumeric(clanName) || 2 > clanName.length())
  973. + {
  974. + player.sendPacket(SystemMessage.getSystemMessage(SystemMessageId.CLAN_NAME_INCORRECT));
  975. + return;
  976. + }
  977. + if (clanName.length() > 16)
  978. + {
  979. + player.sendPacket(SystemMessage.getSystemMessage(SystemMessageId.CLAN_NAME_TOO_LONG));
  980. + return;
  981. + }
  982. +
  983. + for (L2Clan tempClan : ClanTable.getInstance().getClans())
  984. + {
  985. + if (tempClan.getSubPledge(clanName) != null)
  986. + {
  987. + if (pledgeType == L2Clan.SUBUNIT_ACADEMY)
  988. + {
  989. + SystemMessage sm = SystemMessage.getSystemMessage(SystemMessageId.S1_ALREADY_EXISTS);
  990. + sm.addString(clanName);
  991. + player.sendPacket(sm);
  992. + sm = null;
  993. + }
  994. + else
  995. + player.sendPacket(SystemMessage.getSystemMessage(SystemMessageId.ANOTHER_MILITARY_UNIT_IS_ALREADY_USING_THAT_NAME));
  996. +
  997. + return;
  998. + }
  999. + }
  1000. +
  1001. + if (pledgeType != L2Clan.SUBUNIT_ACADEMY)
  1002. + {
  1003. + if (clan.getClanMember(leaderName) == null || clan.getClanMember(leaderName).getPledgeType() != 0)
  1004. + {
  1005. + if (pledgeType >= L2Clan.SUBUNIT_KNIGHT1)
  1006. + player.sendPacket(SystemMessage.getSystemMessage(SystemMessageId.CAPTAIN_OF_ORDER_OF_KNIGHTS_CANNOT_BE_APPOINTED));
  1007. + else if (pledgeType >= L2Clan.SUBUNIT_ROYAL1)
  1008. + player.sendPacket(SystemMessage.getSystemMessage(SystemMessageId.CAPTAIN_OF_ROYAL_GUARD_CANNOT_BE_APPOINTED));
  1009. +
  1010. + return;
  1011. + }
  1012. + }
  1013. +
  1014. + final int leaderId = pledgeType != L2Clan.SUBUNIT_ACADEMY ? clan.getClanMember(leaderName).getObjectId() : 0;
  1015. +
  1016. + if (clan.createSubPledge(player, pledgeType, leaderId, clanName) == null)
  1017. + return;
  1018. +
  1019. + SystemMessage sm;
  1020. + if (pledgeType == L2Clan.SUBUNIT_ACADEMY)
  1021. + {
  1022. + sm = SystemMessage.getSystemMessage(SystemMessageId.THE_S1S_CLAN_ACADEMY_HAS_BEEN_CREATED);
  1023. + sm.addString(player.getClan().getName());
  1024. + }
  1025. + else if (pledgeType >= L2Clan.SUBUNIT_KNIGHT1)
  1026. + {
  1027. + sm = SystemMessage.getSystemMessage(SystemMessageId.THE_KNIGHTS_OF_S1_HAVE_BEEN_CREATED);
  1028. + sm.addString(player.getClan().getName());
  1029. + }
  1030. + else if (pledgeType >= L2Clan.SUBUNIT_ROYAL1)
  1031. + {
  1032. + sm = SystemMessage.getSystemMessage(SystemMessageId.THE_ROYAL_GUARD_OF_S1_HAVE_BEEN_CREATED);
  1033. + sm.addString(player.getClan().getName());
  1034. + }
  1035. + else
  1036. + sm = SystemMessage.getSystemMessage(SystemMessageId.CLAN_CREATED);
  1037. + player.sendPacket(sm);
  1038. +
  1039. + if (pledgeType != L2Clan.SUBUNIT_ACADEMY)
  1040. + {
  1041. + final L2ClanMember leaderSubPledge = clan.getClanMember(leaderName);
  1042. + final L2PcInstance leaderPlayer = leaderSubPledge.getPlayerInstance();
  1043. + if (leaderPlayer != null)
  1044. + {
  1045. + leaderPlayer.setPledgeClass(leaderSubPledge.calculatePledgeClass(leaderPlayer));
  1046. + leaderPlayer.sendPacket(new UserInfo(leaderPlayer));
  1047. + leaderPlayer.sendPacket(new ExBrExtraUserInfo(leaderPlayer));
  1048. + }
  1049. + }
  1050. + }
  1051. +
  1052. + private static final void renameSubPledge(L2PcInstance player, int pledgeType, String pledgeName)
  1053. + {
  1054. + if (!player.isClanLeader())
  1055. + {
  1056. + player.sendPacket(SystemMessage.getSystemMessage(SystemMessageId.YOU_ARE_NOT_AUTHORIZED_TO_DO_THAT));
  1057. + return;
  1058. + }
  1059. +
  1060. + final L2Clan clan = player.getClan();
  1061. + final SubPledge subPledge = player.getClan().getSubPledge(pledgeType);
  1062. +
  1063. + if (subPledge == null)
  1064. + {
  1065. + player.sendMessage("Pledge don't exists.");
  1066. + return;
  1067. + }
  1068. + if (!Util.isAlphaNumeric(pledgeName) || 2 > pledgeName.length())
  1069. + {
  1070. + player.sendPacket(SystemMessage.getSystemMessage(SystemMessageId.CLAN_NAME_INCORRECT));
  1071. + return;
  1072. + }
  1073. + if (pledgeName.length() > 16)
  1074. + {
  1075. + player.sendPacket(SystemMessage.getSystemMessage(SystemMessageId.CLAN_NAME_TOO_LONG));
  1076. + return;
  1077. + }
  1078. +
  1079. + subPledge.setName(pledgeName);
  1080. + clan.updateSubPledgeInDB(subPledge.getId());
  1081. + clan.broadcastClanStatus();
  1082. + player.sendMessage("Pledge name changed.");
  1083. + }
  1084. +
  1085. + private static final void assignSubPledgeLeader(L2PcInstance player, String clanName, String leaderName)
  1086. + {
  1087. + if (!player.isClanLeader())
  1088. + {
  1089. + player.sendPacket(SystemMessage.getSystemMessage(SystemMessageId.YOU_ARE_NOT_AUTHORIZED_TO_DO_THAT));
  1090. + return;
  1091. + }
  1092. + if (leaderName.length() > 16)
  1093. + {
  1094. + player.sendPacket(SystemMessage.getSystemMessage(SystemMessageId.NAMING_CHARNAME_UP_TO_16CHARS));
  1095. + return;
  1096. + }
  1097. + if (player.getName().equals(leaderName))
  1098. + {
  1099. + player.sendPacket(SystemMessage.getSystemMessage(SystemMessageId.CAPTAIN_OF_ROYAL_GUARD_CANNOT_BE_APPOINTED));
  1100. + return;
  1101. + }
  1102. +
  1103. + final L2Clan clan = player.getClan();
  1104. + final SubPledge subPledge = player.getClan().getSubPledge(clanName);
  1105. +
  1106. + if (null == subPledge || subPledge.getId() == L2Clan.SUBUNIT_ACADEMY)
  1107. + {
  1108. + player.sendPacket(SystemMessage.getSystemMessage(SystemMessageId.CLAN_NAME_INCORRECT));
  1109. + return;
  1110. + }
  1111. + if (clan.getClanMember(leaderName) == null || (clan.getClanMember(leaderName).getPledgeType() != 0))
  1112. + {
  1113. + if (subPledge.getId() >= L2Clan.SUBUNIT_KNIGHT1)
  1114. + player.sendPacket(SystemMessage.getSystemMessage(SystemMessageId.CAPTAIN_OF_ORDER_OF_KNIGHTS_CANNOT_BE_APPOINTED));
  1115. + else if (subPledge.getId() >= L2Clan.SUBUNIT_ROYAL1)
  1116. + player.sendPacket(SystemMessage.getSystemMessage(SystemMessageId.CAPTAIN_OF_ROYAL_GUARD_CANNOT_BE_APPOINTED));
  1117. +
  1118. + return;
  1119. + }
  1120. +
  1121. + subPledge.setLeaderId(clan.getClanMember(leaderName).getObjectId());
  1122. + clan.updateSubPledgeInDB(subPledge.getId());
  1123. +
  1124. + final L2ClanMember leaderSubPledge = clan.getClanMember(leaderName);
  1125. + final L2PcInstance leaderPlayer = leaderSubPledge.getPlayerInstance();
  1126. + if (leaderPlayer != null)
  1127. + {
  1128. + leaderPlayer.setPledgeClass(leaderSubPledge.calculatePledgeClass(leaderPlayer));
  1129. + leaderPlayer.sendPacket(new UserInfo(leaderPlayer));
  1130. + leaderPlayer.sendPacket(new ExBrExtraUserInfo(leaderPlayer));
  1131. + }
  1132. +
  1133. + clan.broadcastClanStatus();
  1134. + SystemMessage sm = SystemMessage.getSystemMessage(SystemMessageId.C1_HAS_BEEN_SELECTED_AS_CAPTAIN_OF_S2);
  1135. + sm.addString(leaderName);
  1136. + sm.addString(clanName);
  1137. + clan.broadcastToOnlineMembers(sm);
  1138. + sm = null;
  1139. + }
  1140. +
  1141. + /**
  1142. + * this displays PledgeSkillList to the player.
  1143. + * @param player
  1144. + */
  1145. + private static final void showPledgeSkillList(L2PcInstance player)
  1146. + {
  1147. + if (player.getClan() == null || !player.isClanLeader())
  1148. + {
  1149. + NpcHtmlMessage html = new NpcHtmlMessage(1);
  1150. + html.setFile(player.getHtmlPrefix(), "data/html/villagemaster/NotClanLeader.htm");
  1151. + player.sendPacket(html);
  1152. + player.sendPacket(ActionFailed.STATIC_PACKET);
  1153. + return;
  1154. + }
  1155. +
  1156. + final FastList<L2SkillLearn> skills = SkillTreesData.getInstance().getAvailablePledgeSkills(player.getClan());
  1157. + final AcquireSkillList asl = new AcquireSkillList(SkillType.Pledge);
  1158. + int counts = 0;
  1159. +
  1160. + for (L2SkillLearn s : skills)
  1161. + {
  1162. + asl.addSkill(s.getSkillId(), s.getSkillLevel(), s.getSkillLevel(), s.getLevelUpSp(), s.getSocialClass());
  1163. + counts++;
  1164. + }
  1165. +
  1166. + if (counts == 0)
  1167. + {
  1168. + if (player.getClan().getLevel() < 8)
  1169. + {
  1170. + SystemMessage sm = SystemMessage.getSystemMessage(SystemMessageId.DO_NOT_HAVE_FURTHER_SKILLS_TO_LEARN_S1);
  1171. + if (player.getClan().getLevel() < 5)
  1172. + sm.addNumber(5);
  1173. + else
  1174. + sm.addNumber(player.getClan().getLevel() + 1);
  1175. + player.sendPacket(sm);
  1176. + }
  1177. + else
  1178. + {
  1179. + NpcHtmlMessage html = new NpcHtmlMessage(1);
  1180. + html.setFile(player.getHtmlPrefix(), "data/html/villagemaster/NoMoreSkills.htm");
  1181. + player.sendPacket(html);
  1182. + }
  1183. + }
  1184. + else
  1185. + {
  1186. + player.sendPacket(asl);
  1187. + }
  1188. + player.sendPacket(ActionFailed.STATIC_PACKET);
  1189. + }
  1190. +
  1191. + private static final void dissolveClan(L2PcInstance player, int clanId)
  1192. + {
  1193. + if (!player.isClanLeader())
  1194. + {
  1195. + player.sendPacket(SystemMessage.getSystemMessage(SystemMessageId.YOU_ARE_NOT_AUTHORIZED_TO_DO_THAT));
  1196. + return;
  1197. + }
  1198. +
  1199. + final L2Clan clan = player.getClan();
  1200. + if (clan.getAllyId() != 0)
  1201. + {
  1202. + player.sendPacket(SystemMessage.getSystemMessage(SystemMessageId.CANNOT_DISPERSE_THE_CLANS_IN_ALLY));
  1203. + return;
  1204. + }
  1205. + if (clan.isAtWar())
  1206. + {
  1207. + player.sendPacket(SystemMessage.getSystemMessage(SystemMessageId.CANNOT_DISSOLVE_WHILE_IN_WAR));
  1208. + return;
  1209. + }
  1210. + if (clan.getHasCastle() != 0 || clan.getHasHideout() != 0 || clan.getHasFort() != 0)
  1211. + {
  1212. + player.sendPacket(SystemMessage.getSystemMessage(SystemMessageId.CANNOT_DISSOLVE_WHILE_OWNING_CLAN_HALL_OR_CASTLE));
  1213. + return;
  1214. + }
  1215. +
  1216. + for (Castle castle : CastleManager.getInstance().getCastles())
  1217. + {
  1218. + if (SiegeManager.getInstance().checkIsRegistered(clan, castle.getCastleId()))
  1219. + {
  1220. + player.sendPacket(SystemMessage.getSystemMessage(SystemMessageId.CANNOT_DISSOLVE_WHILE_IN_SIEGE));
  1221. + return;
  1222. + }
  1223. + }
  1224. + for (Fort fort : FortManager.getInstance().getForts())
  1225. + {
  1226. + if (FortSiegeManager.getInstance().checkIsRegistered(clan, fort.getFortId()))
  1227. + {
  1228. + player.sendPacket(SystemMessage.getSystemMessage(SystemMessageId.CANNOT_DISSOLVE_WHILE_IN_SIEGE));
  1229. + return;
  1230. + }
  1231. + }
  1232. +
  1233. + if (player.isInsideZone(L2PcInstance.ZONE_SIEGE))
  1234. + {
  1235. + player.sendPacket(SystemMessage.getSystemMessage(SystemMessageId.CANNOT_DISSOLVE_WHILE_IN_SIEGE));
  1236. + return;
  1237. + }
  1238. + if (clan.getDissolvingExpiryTime() > System.currentTimeMillis())
  1239. + {
  1240. + player.sendPacket(SystemMessage.getSystemMessage(SystemMessageId.DISSOLUTION_IN_PROGRESS));
  1241. + return;
  1242. + }
  1243. +
  1244. + clan.setDissolvingExpiryTime(System.currentTimeMillis() + Config.ALT_CLAN_DISSOLVE_DAYS * 86400000L); //24*60*60*1000 = 86400000
  1245. + clan.updateClanInDB();
  1246. +
  1247. + ClanTable.getInstance().scheduleRemoveClan(clan.getClanId());
  1248. +
  1249. + player.sendMessage("Your clan will be dissolved after " + Config.ALT_CLAN_DISSOLVE_DAYS + " days");
  1250. +
  1251. + // The clan leader should take the XP penalty of a full death.
  1252. + player.deathPenalty(false, false, false);
  1253. + }
  1254. +
  1255. + private static final void recoverClan(L2PcInstance player, int clanId)
  1256. + {
  1257. + if (!player.isClanLeader())
  1258. + {
  1259. + player.sendPacket(SystemMessage.getSystemMessage(SystemMessageId.YOU_ARE_NOT_AUTHORIZED_TO_DO_THAT));
  1260. + return;
  1261. + }
  1262. +
  1263. + final L2Clan clan = player.getClan();
  1264. + clan.setDissolvingExpiryTime(0);
  1265. + clan.updateClanInDB();
  1266. +
  1267. + player.sendMessage("Your clan deletion has been canceled");
  1268. + }
  1269. +
  1270. + private static final void changeClanLeader(L2PcInstance player, String target)
  1271. + {
  1272. + if (!player.isClanLeader())
  1273. + {
  1274. + player.sendPacket(SystemMessage.getSystemMessage(SystemMessageId.YOU_ARE_NOT_AUTHORIZED_TO_DO_THAT));
  1275. + return;
  1276. + }
  1277. + if (player.getName().equalsIgnoreCase(target))
  1278. + return;
  1279. + /*
  1280. + * Until proper clan leader change support is done, this is a little
  1281. + * exploit fix (leader, while fliying wyvern changes clan leader and the new leader
  1282. + * can ride the wyvern too)
  1283. + * DrHouse
  1284. + */
  1285. + if (player.isFlying())
  1286. + {
  1287. + player.sendMessage("Please, stop flying");
  1288. + return;
  1289. + }
  1290. +
  1291. + final L2Clan clan = player.getClan();
  1292. +
  1293. + final L2ClanMember member = clan.getClanMember(target);
  1294. + if (member == null)
  1295. + {
  1296. + SystemMessage sm = SystemMessage.getSystemMessage(SystemMessageId.S1_DOES_NOT_EXIST);
  1297. + sm.addString(target);
  1298. + player.sendPacket(sm);
  1299. + sm = null;
  1300. + return;
  1301. + }
  1302. + if (!member.isOnline())
  1303. + {
  1304. + player.sendPacket(SystemMessage.getSystemMessage(SystemMessageId.INVITED_USER_NOT_ONLINE));
  1305. + return;
  1306. + }
  1307. + clan.setNewLeader(member);
  1308. + }
  1309. +
  1310. + public static void showSubClassSkillList(L2PcInstance player)
  1311. + {
  1312. + final FastList<L2SkillLearn> subClassSkills = SkillTreesData.getInstance().getAvailableSubClassSkills(player);
  1313. + final AcquireSkillList asl = new AcquireSkillList(AcquireSkillList.SkillType.SubClass);
  1314. + int count = 0;
  1315. +
  1316. + for (L2SkillLearn s : subClassSkills)
  1317. + {
  1318. + final L2Skill sk = SkillTable.getInstance().getInfo(s.getSkillId(), s.getSkillLevel());
  1319. + if (sk != null)
  1320. + {
  1321. + count++;
  1322. + asl.addSkill(s.getSkillId(), s.getSkillLevel(), s.getSkillLevel(), 0, 0);
  1323. + }
  1324. + }
  1325. + if (count > 0)
  1326. + {
  1327. + player.sendPacket(asl);
  1328. + }
  1329. + else
  1330. + {
  1331. + player.sendPacket(SystemMessageId.NO_MORE_SKILLS_TO_LEARN);
  1332. + }
  1333. + }
  1334. +
  1335. + private static boolean canTransform(L2PcInstance player)
  1336. + {
  1337. + if (Config.ALLOW_TRANSFORM_WITHOUT_QUEST)
  1338. + {
  1339. + return true;
  1340. + }
  1341. + final QuestState st = player.getQuestState("136_MoreThanMeetsTheEye");
  1342. + if ((st != null) && st.isCompleted())
  1343. + {
  1344. + return true;
  1345. + }
  1346. + return false;
  1347. + }
  1348. +
  1349. + public void showChatWindow(L2PcInstance player, int val, String suffix)
  1350. + {
  1351. + String filename = Olympiad.OLYMPIAD_HTML_PATH;
  1352. +
  1353. + filename += "noble_desc" + val;
  1354. + filename += (suffix != null) ? suffix + ".htm" : ".htm";
  1355. +
  1356. + if (filename.equals(Olympiad.OLYMPIAD_HTML_PATH + "noble_desc0.htm"))
  1357. + filename = Olympiad.OLYMPIAD_HTML_PATH + "noble_main.htm";
  1358. +
  1359. + showChatWindow(player, filename);
  1360. + }
  1361. +}
  1362. Index: java/com/l2jserver/gameserver/model/actor/instance/L2PcInstance.java
  1363. ===================================================================
  1364. --- java/com/l2jserver/gameserver/model/actor/instance/L2PcInstance.java (revision 4769)
  1365. +++ java/com/l2jserver/gameserver/model/actor/instance/L2PcInstance.java (working copy)
  1366. @@ -93,6 +93,7 @@
  1367. import com.l2jserver.gameserver.instancemanager.TerritoryWarManager;
  1368. import com.l2jserver.gameserver.model.BlockList;
  1369. import com.l2jserver.gameserver.model.CharEffectList;
  1370. +import com.l2jserver.gameserver.model.CharacterAchievementSystem;
  1371. import com.l2jserver.gameserver.model.Elementals;
  1372. import com.l2jserver.gameserver.model.FishData;
  1373. import com.l2jserver.gameserver.model.L2AccessLevel;
  1374. @@ -270,6 +271,8 @@
  1375. import com.l2jserver.gameserver.util.Util;
  1376. import com.l2jserver.util.Rnd;
  1377.  
  1378. +import custom.PlayerKill.PlayerKill;
  1379. +
  1380. /**
  1381. * This class represents all player characters in the world.
  1382. * There is always a client-thread connected to this (except if a player-store is activated upon logout).<BR><BR>
  1383. @@ -301,7 +304,6 @@
  1384. private static final String RESTORE_TP_BOOKMARK = "SELECT Id,x,y,z,icon,tag,name FROM character_tpbookmark WHERE charId=?";
  1385. private static final String DELETE_TP_BOOKMARK = "DELETE FROM character_tpbookmark WHERE charId=? AND Id=?";
  1386.  
  1387. -
  1388. // Character Subclass SQL String Definitions:
  1389. private static final String RESTORE_CHAR_SUBCLASSES = "SELECT class_id,exp,sp,level,class_index FROM character_subclasses WHERE charId=? ORDER BY class_index ASC";
  1390. private static final String ADD_CHAR_SUBCLASS = "INSERT INTO character_subclasses (charId,class_id,exp,sp,level,class_index) VALUES (?,?,?,?,?,?)";
  1391. @@ -454,11 +456,7 @@
  1392.  
  1393. public enum PunishLevel
  1394. {
  1395. - NONE(0, ""),
  1396. - CHAT(1, "chat banned"),
  1397. - JAIL(2, "jailed"),
  1398. - CHAR(3, "banned"),
  1399. - ACC(4, "banned");
  1400. + NONE(0, ""), CHAT(1, "chat banned"), JAIL(2, "jailed"), CHAR(3, "banned"), ACC(4, "banned");
  1401.  
  1402. private final int punValue;
  1403. private final String punString;
  1404. @@ -659,12 +657,12 @@
  1405.  
  1406. private L2AccessLevel _accessLevel;
  1407.  
  1408. - private boolean _messageRefusal = false; // message refusal mode
  1409. + private boolean _messageRefusal = false; // message refusal mode
  1410.  
  1411. - private boolean _silenceMode = false; // silence mode
  1412. - private boolean _dietMode = false; // ignore weight penalty
  1413. - private boolean _tradeRefusal = false; // Trade refusal
  1414. - private boolean _exchangeRefusal = false; // Exchange refusal
  1415. + private boolean _silenceMode = false; // silence mode
  1416. + private boolean _dietMode = false; // ignore weight penalty
  1417. + private boolean _tradeRefusal = false; // Trade refusal
  1418. + private boolean _exchangeRefusal = false; // Exchange refusal
  1419.  
  1420. private L2Party _party;
  1421.  
  1422. @@ -678,10 +676,19 @@
  1423.  
  1424. // Used for protection after teleport
  1425. private long _protectEndTime = 0;
  1426. - public boolean isSpawnProtected() { return _protectEndTime > GameTimeController.getGameTicks(); }
  1427. +
  1428. + public boolean isSpawnProtected()
  1429. + {
  1430. + return _protectEndTime > GameTimeController.getGameTicks();
  1431. + }
  1432. +
  1433. private long _teleportProtectEndTime = 0;
  1434. - public boolean isTeleportProtected() { return _teleportProtectEndTime > GameTimeController.getGameTicks(); }
  1435.  
  1436. + public boolean isTeleportProtected()
  1437. + {
  1438. + return _teleportProtectEndTime > GameTimeController.getGameTicks();
  1439. + }
  1440. +
  1441. // protects a char from agro mobs when getting up from fake death
  1442. private long _recentFakeDeathEndTime = 0;
  1443. private boolean _isFakeDeath;
  1444. @@ -873,6 +880,7 @@
  1445.  
  1446. /** Herbs Task Time **/
  1447. private int _herbstask = 0;
  1448. +
  1449. /** Task for Herbs */
  1450.  
  1451. private class HerbTask implements Runnable
  1452. @@ -997,10 +1005,12 @@
  1453. private static class GatesRequest
  1454. {
  1455. private L2DoorInstance _target = null;
  1456. +
  1457. public void setTarget(L2DoorInstance door)
  1458. {
  1459. _target = door;
  1460. }
  1461. +
  1462. public L2DoorInstance getDoor()
  1463. {
  1464. return _target;
  1465. @@ -1009,7 +1019,7 @@
  1466.  
  1467. // Save responder name for log it
  1468. private String _lastPetitionGmName = null;
  1469. -
  1470. +
  1471. /**
  1472. * Create a new L2PcInstance and add it in the characters table of the database.<BR><BR>
  1473. *
  1474. @@ -1110,19 +1120,19 @@
  1475. result |= RelationChanged.RELATION_PARTY4; // 0x8
  1476. break;
  1477. case 2:
  1478. - result |= RelationChanged.RELATION_PARTY3+RelationChanged.RELATION_PARTY2+RelationChanged.RELATION_PARTY1; // 0x7
  1479. + result |= RelationChanged.RELATION_PARTY3 + RelationChanged.RELATION_PARTY2 + RelationChanged.RELATION_PARTY1; // 0x7
  1480. break;
  1481. case 3:
  1482. - result |= RelationChanged.RELATION_PARTY3+RelationChanged.RELATION_PARTY2; // 0x6
  1483. + result |= RelationChanged.RELATION_PARTY3 + RelationChanged.RELATION_PARTY2; // 0x6
  1484. break;
  1485. case 4:
  1486. - result |= RelationChanged.RELATION_PARTY3+RelationChanged.RELATION_PARTY1; // 0x5
  1487. + result |= RelationChanged.RELATION_PARTY3 + RelationChanged.RELATION_PARTY1; // 0x5
  1488. break;
  1489. case 5:
  1490. result |= RelationChanged.RELATION_PARTY3; // 0x4
  1491. break;
  1492. case 6:
  1493. - result |= RelationChanged.RELATION_PARTY2+RelationChanged.RELATION_PARTY1; // 0x3
  1494. + result |= RelationChanged.RELATION_PARTY2 + RelationChanged.RELATION_PARTY1; // 0x3
  1495. break;
  1496. case 7:
  1497. result |= RelationChanged.RELATION_PARTY2; // 0x2
  1498. @@ -1150,20 +1160,18 @@
  1499. }
  1500. if (getClan() != null && target.getClan() != null)
  1501. {
  1502. - if (target.getPledgeType() != L2Clan.SUBUNIT_ACADEMY
  1503. - && getPledgeType() != L2Clan.SUBUNIT_ACADEMY
  1504. - && target.getClan().isAtWarWith(getClan().getClanId()))
  1505. + if (target.getPledgeType() != L2Clan.SUBUNIT_ACADEMY && getPledgeType() != L2Clan.SUBUNIT_ACADEMY && target.getClan().isAtWarWith(getClan().getClanId()))
  1506. {
  1507. result |= RelationChanged.RELATION_1SIDED_WAR;
  1508. if (getClan().isAtWarWith(target.getClan().getClanId()))
  1509. result |= RelationChanged.RELATION_MUTUAL_WAR;
  1510. }
  1511. }
  1512. - if(getBlockCheckerArena() != -1)
  1513. + if (getBlockCheckerArena() != -1)
  1514. {
  1515. result |= RelationChanged.RELATION_INSIEGE;
  1516. HandysBlockCheckerManager.ArenaParticipantsHolder holder = HandysBlockCheckerManager.getInstance().getHolder(getBlockCheckerArena());
  1517. - if(holder.getPlayerTeam(this) == 0)
  1518. + if (holder.getPlayerTeam(this) == 0)
  1519. result |= RelationChanged.RELATION_ENEMY;
  1520. else
  1521. result |= RelationChanged.RELATION_ALLY;
  1522. @@ -1222,9 +1230,9 @@
  1523. super.initCharStatusUpdateValues();
  1524. initPcStatusUpdateValues();
  1525.  
  1526. - _accountName = accountName;
  1527. + _accountName = accountName;
  1528. app.setOwner(this);
  1529. - _appearance = app;
  1530. + _appearance = app;
  1531.  
  1532. // Create an AI
  1533. _ai = new L2PlayerAI(new L2PcInstance.AIAccessor());
  1534. @@ -1246,7 +1254,7 @@
  1535. @Override
  1536. public final PcKnownList getKnownList()
  1537. {
  1538. - return (PcKnownList)super.getKnownList();
  1539. + return (PcKnownList) super.getKnownList();
  1540. }
  1541.  
  1542. @Override
  1543. @@ -1258,7 +1266,7 @@
  1544. @Override
  1545. public final PcStat getStat()
  1546. {
  1547. - return (PcStat)super.getStat();
  1548. + return (PcStat) super.getStat();
  1549. }
  1550.  
  1551. @Override
  1552. @@ -1270,7 +1278,7 @@
  1553. @Override
  1554. public final PcStatus getStatus()
  1555. {
  1556. - return (PcStatus)super.getStatus();
  1557. + return (PcStatus) super.getStatus();
  1558. }
  1559.  
  1560. @Override
  1561. @@ -1282,7 +1290,7 @@
  1562. @Override
  1563. public PcPosition getPosition()
  1564. {
  1565. - return (PcPosition)super.getPosition();
  1566. + return (PcPosition) super.getPosition();
  1567. }
  1568.  
  1569. @Override
  1570. @@ -1306,9 +1314,15 @@
  1571.  
  1572. /** Return the L2PcTemplate link to the L2PcInstance. */
  1573. @Override
  1574. - public final L2PcTemplate getTemplate() { return (L2PcTemplate)super.getTemplate(); }
  1575. + public final L2PcTemplate getTemplate()
  1576. + {
  1577. + return (L2PcTemplate) super.getTemplate();
  1578. + }
  1579.  
  1580. - public void setTemplate(ClassId newclass) { super.setTemplate(CharTemplateTable.getInstance().getTemplate(newclass)); }
  1581. + public void setTemplate(ClassId newclass)
  1582. + {
  1583. + super.setTemplate(CharTemplateTable.getInstance().getTemplate(newclass));
  1584. + }
  1585.  
  1586. /**
  1587. * Return the AI of the L2PcInstance (create it if necessary).<BR><BR>
  1588. @@ -1319,9 +1333,10 @@
  1589. L2CharacterAI ai = _ai; // copy handle
  1590. if (ai == null)
  1591. {
  1592. - synchronized(this)
  1593. + synchronized (this)
  1594. {
  1595. - if (_ai == null) _ai = new L2PlayerAI(new L2PcInstance.AIAccessor());
  1596. + if (_ai == null)
  1597. + _ai = new L2PlayerAI(new L2PcInstance.AIAccessor());
  1598. return _ai;
  1599. }
  1600. }
  1601. @@ -1330,7 +1345,10 @@
  1602.  
  1603. /** Return the Level of the L2PcInstance. */
  1604. @Override
  1605. - public final int getLevel() { return getStat().getLevel(); }
  1606. + public final int getLevel()
  1607. + {
  1608. + return getStat().getLevel();
  1609. + }
  1610.  
  1611. /**
  1612. * Return the _newbie rewards state of the L2PcInstance.<BR><BR>
  1613. @@ -1361,7 +1379,11 @@
  1614. _baseClass = classId.ordinal();
  1615. }
  1616.  
  1617. - public boolean isInStoreMode() { return (getPrivateStoreType() > 0); }
  1618. + public boolean isInStoreMode()
  1619. + {
  1620. + return (getPrivateStoreType() > 0);
  1621. + }
  1622. +
  1623. // public boolean isInCraftMode() { return (getPrivateStoreType() == STORE_PRIVATE_MANUFACTURE); }
  1624.  
  1625. public boolean isInCraftMode()
  1626. @@ -1404,7 +1426,6 @@
  1627. }
  1628. }
  1629.  
  1630. -
  1631. /**
  1632. * Return a table containing all Common L2RecipeList of the L2PcInstance.<BR><BR>
  1633. */
  1634. @@ -1459,7 +1480,7 @@
  1635. {
  1636. if (_dwarvenRecipeBook.containsKey(recipeId))
  1637. return true;
  1638. - else if(_commonRecipeBook.containsKey(recipeId))
  1639. + else if (_commonRecipeBook.containsKey(recipeId))
  1640. return true;
  1641. else
  1642. return false;
  1643. @@ -1478,7 +1499,7 @@
  1644. else if (_commonRecipeBook.remove(recipeId) != null)
  1645. deleteRecipeData(recipeId, false);
  1646. else
  1647. - _log.warning("Attempted to remove unknown RecipeList: "+recipeId);
  1648. + _log.warning("Attempted to remove unknown RecipeList: " + recipeId);
  1649.  
  1650. L2ShortCut[] allShortCuts = getAllShortCuts();
  1651.  
  1652. @@ -1497,7 +1518,7 @@
  1653. con = L2DatabaseFactory.getInstance().getConnection();
  1654. PreparedStatement statement = con.prepareStatement("INSERT INTO character_recipebook (charId, id, classIndex, type) values(?,?,?,?)");
  1655. statement.setInt(1, getObjectId());
  1656. - statement.setInt(2,recipeId);
  1657. + statement.setInt(2, recipeId);
  1658. statement.setInt(3, isDwarf ? _classIndex : 0);
  1659. statement.setInt(4, isDwarf ? 1 : 0);
  1660. statement.execute();
  1661. @@ -1505,8 +1526,8 @@
  1662. }
  1663. catch (SQLException e)
  1664. {
  1665. - if(_log.isLoggable(Level.SEVERE))
  1666. - _log.log(Level.SEVERE, "SQL exception while inserting recipe: "+recipeId+" from character "+getObjectId(), e);
  1667. + if (_log.isLoggable(Level.SEVERE))
  1668. + _log.log(Level.SEVERE, "SQL exception while inserting recipe: " + recipeId + " from character " + getObjectId(), e);
  1669. }
  1670. finally
  1671. {
  1672. @@ -1531,7 +1552,7 @@
  1673. catch (SQLException e)
  1674. {
  1675. if (_log.isLoggable(Level.SEVERE))
  1676. - _log.log(Level.SEVERE, "SQL exception while deleting recipe: "+recipeId+" from character "+getObjectId(), e);
  1677. + _log.log(Level.SEVERE, "SQL exception while deleting recipe: " + recipeId + " from character " + getObjectId(), e);
  1678. }
  1679. finally
  1680. {
  1681. @@ -1574,7 +1595,6 @@
  1682. _quests.put(qs.getQuestName(), qs);
  1683. }
  1684.  
  1685. -
  1686. /**
  1687. * Remove a QuestState from the table _quest containing all quests began by the L2PcInstance.<BR><BR>
  1688. *
  1689. @@ -1589,8 +1609,8 @@
  1690. private QuestState[] addToQuestStateArray(QuestState[] questStateArray, QuestState state)
  1691. {
  1692. int len = questStateArray.length;
  1693. - QuestState[] tmp = new QuestState[len+1];
  1694. - for (int i=0; i < len; i++)
  1695. + QuestState[] tmp = new QuestState[len + 1];
  1696. + for (int i = 0; i < len; i++)
  1697. tmp[i] = questStateArray[i];
  1698. tmp[len] = state;
  1699. return tmp;
  1700. @@ -1612,7 +1632,7 @@
  1701. continue;
  1702.  
  1703. int questId = qs.getQuest().getQuestIntId();
  1704. - if ((questId>19999) || (questId<1))
  1705. + if ((questId > 19999) || (questId < 1))
  1706. continue;
  1707.  
  1708. if (!qs.isStarted() && !Config.DEVELOPER)
  1709. @@ -1639,11 +1659,11 @@
  1710. for (Quest quest : npc.getTemplate().getEventQuests(Quest.QuestEventType.ON_ATTACK))
  1711. {
  1712. // Check if the Identifier of the L2Attackable attck is needed for the current quest
  1713. - if (getQuestState(quest.getName())!=null)
  1714. + if (getQuestState(quest.getName()) != null)
  1715. {
  1716. // Copy the current L2PcInstance QuestState in the QuestState table
  1717. if (states == null)
  1718. - states = new QuestState[]{getQuestState(quest.getName())};
  1719. + states = new QuestState[] { getQuestState(quest.getName()) };
  1720. else
  1721. states = addToQuestStateArray(states, getQuestState(quest.getName()));
  1722. }
  1723. @@ -1668,11 +1688,11 @@
  1724. for (Quest quest : npc.getTemplate().getEventQuests(Quest.QuestEventType.ON_KILL))
  1725. {
  1726. // Check if the Identifier of the L2Attackable killed is needed for the current quest
  1727. - if (getQuestState(quest.getName())!=null)
  1728. + if (getQuestState(quest.getName()) != null)
  1729. {
  1730. // Copy the current L2PcInstance QuestState in the QuestState table
  1731. if (states == null)
  1732. - states = new QuestState[]{getQuestState(quest.getName())};
  1733. + states = new QuestState[] { getQuestState(quest.getName()) };
  1734. else
  1735. states = addToQuestStateArray(states, getQuestState(quest.getName()));
  1736. }
  1737. @@ -1697,15 +1717,15 @@
  1738. Quest[] quests = NpcTable.getInstance().getTemplate(npcId).getEventQuests(Quest.QuestEventType.ON_TALK);
  1739. if (quests != null)
  1740. {
  1741. - for (Quest quest: quests)
  1742. + for (Quest quest : quests)
  1743. {
  1744. if (quest != null)
  1745. {
  1746. // Copy the current L2PcInstance QuestState in the QuestState table
  1747. - if (getQuestState(quest.getName())!=null)
  1748. + if (getQuestState(quest.getName()) != null)
  1749. {
  1750. if (states == null)
  1751. - states = new QuestState[]{getQuestState(quest.getName())};
  1752. + states = new QuestState[] { getQuestState(quest.getName()) };
  1753. else
  1754. states = addToQuestStateArray(states, getQuestState(quest.getName()));
  1755. }
  1756. @@ -1725,19 +1745,21 @@
  1757. QuestState qs = getQuestState(quest);
  1758. if (qs == null && event.length() == 0)
  1759. return retval;
  1760. - if (qs == null) {
  1761. + if (qs == null)
  1762. + {
  1763. Quest q = QuestManager.getInstance().getQuest(quest);
  1764. if (q == null)
  1765. return retval;
  1766. qs = q.newQuestState(this);
  1767. }
  1768. - if (qs != null) {
  1769. + if (qs != null)
  1770. + {
  1771. if (getLastQuestNpcObject() > 0)
  1772. {
  1773. L2Object object = L2World.getInstance().findObject(getLastQuestNpcObject());
  1774. if (object instanceof L2Npc && isInsideRadius(object, L2Npc.INTERACTION_DISTANCE, false, false))
  1775. {
  1776. - L2Npc npc = (L2Npc)object;
  1777. + L2Npc npc = (L2Npc) object;
  1778. QuestState[] states = getQuestsForTalk(npc.getNpcId());
  1779.  
  1780. if (states != null)
  1781. @@ -1762,20 +1784,20 @@
  1782.  
  1783. private void showQuestWindow(String questId, String stateId)
  1784. {
  1785. - String path = "data/scripts/quests/"+questId+"/"+stateId+".htm";
  1786. - String content = HtmCache.getInstance().getHtm(getHtmlPrefix(), path); //TODO path for quests html
  1787. + String path = "data/scripts/quests/" + questId + "/" + stateId + ".htm";
  1788. + String content = HtmCache.getInstance().getHtm(getHtmlPrefix(), path); //TODO path for quests html
  1789.  
  1790. if (content != null)
  1791. {
  1792. if (Config.DEBUG)
  1793. - _log.fine("Showing quest window for quest "+questId+" state "+stateId+" html path: " + path);
  1794. + _log.fine("Showing quest window for quest " + questId + " state " + stateId + " html path: " + path);
  1795.  
  1796. NpcHtmlMessage npcReply = new NpcHtmlMessage(5);
  1797. npcReply.setHtml(content);
  1798. sendPacket(npcReply);
  1799. }
  1800.  
  1801. - sendPacket( ActionFailed.STATIC_PACKET );
  1802. + sendPacket(ActionFailed.STATIC_PACKET);
  1803. }
  1804.  
  1805. /** List of all QuestState instance that needs to be notified of this L2PcInstance's or its pet's death */
  1806. @@ -1787,7 +1809,7 @@
  1807. * @param qs The QuestState that subscribe to this event
  1808. *
  1809. */
  1810. - public void addNotifyQuestOfDeath (QuestState qs)
  1811. + public void addNotifyQuestOfDeath(QuestState qs)
  1812. {
  1813. if (qs == null)
  1814. return;
  1815. @@ -1802,7 +1824,7 @@
  1816. * @param qs The QuestState that subscribe to this event
  1817. *
  1818. */
  1819. - public void removeNotifyQuestOfDeath (QuestState qs)
  1820. + public void removeNotifyQuestOfDeath(QuestState qs)
  1821. {
  1822. if (qs == null || _notifyQuestOfDeathList == null)
  1823. return;
  1824. @@ -1813,11 +1835,11 @@
  1825. /**
  1826. * Return a list of QuestStates which registered for notify of death of this L2PcInstance.<BR><BR>
  1827. */
  1828. - public final List<QuestState> getNotifyQuestOfDeath ()
  1829. + public final List<QuestState> getNotifyQuestOfDeath()
  1830. {
  1831. if (_notifyQuestOfDeathList == null)
  1832. {
  1833. - synchronized(this)
  1834. + synchronized (this)
  1835. {
  1836. if (_notifyQuestOfDeathList == null)
  1837. _notifyQuestOfDeathList = new FastList<QuestState>();
  1838. @@ -1900,6 +1922,7 @@
  1839. {
  1840. _siegeState = siegeState;
  1841. }
  1842. +
  1843. /**
  1844. * Get the siege state of the L2PcInstance.<BR><BR>
  1845. * 1 = attacker, 2 = defender, 0 = not involved
  1846. @@ -1934,7 +1957,7 @@
  1847. */
  1848. public void setPvpFlag(int pvpFlag)
  1849. {
  1850. - _pvpFlag = (byte)pvpFlag;
  1851. + _pvpFlag = (byte) pvpFlag;
  1852. }
  1853.  
  1854. @Override
  1855. @@ -1954,7 +1977,8 @@
  1856. sendPacket(new ExBrExtraUserInfo(this));
  1857.  
  1858. // If this player has a pet update the pets pvp flag as well
  1859. - if (getPet() != null) sendPacket(new RelationChanged(getPet(), getRelation(this), false));
  1860. + if (getPet() != null)
  1861. + sendPacket(new RelationChanged(getPet(), getRelation(this), false));
  1862.  
  1863. Collection<L2PcInstance> plrs = getKnownList().getKnownPlayers().values();
  1864. //synchronized (getKnownList().getKnownPlayers())
  1865. @@ -1972,16 +1996,19 @@
  1866. public void revalidateZone(boolean force)
  1867. {
  1868. // Cannot validate if not in a world region (happens during teleport)
  1869. - if (getWorldRegion() == null) return;
  1870. + if (getWorldRegion() == null)
  1871. + return;
  1872.  
  1873. // This function is called too often from movement code
  1874. - if (force) _zoneValidateCounter = 4;
  1875. + if (force)
  1876. + _zoneValidateCounter = 4;
  1877. else
  1878. {
  1879. _zoneValidateCounter--;
  1880. if (_zoneValidateCounter < 0)
  1881. _zoneValidateCounter = 4;
  1882. - else return;
  1883. + else
  1884. + return;
  1885. }
  1886.  
  1887. getWorldRegion().revalidateZones(this);
  1888. @@ -1991,43 +2018,50 @@
  1889.  
  1890. if (isInsideZone(ZONE_ALTERED))
  1891. {
  1892. - if (_lastCompassZone == ExSetCompassZoneCode.ALTEREDZONE) return;
  1893. + if (_lastCompassZone == ExSetCompassZoneCode.ALTEREDZONE)
  1894. + return;
  1895. _lastCompassZone = ExSetCompassZoneCode.ALTEREDZONE;
  1896. ExSetCompassZoneCode cz = new ExSetCompassZoneCode(ExSetCompassZoneCode.ALTEREDZONE);
  1897. sendPacket(cz);
  1898. }
  1899. else if (isInsideZone(ZONE_SIEGE))
  1900. {
  1901. - if (_lastCompassZone == ExSetCompassZoneCode.SIEGEWARZONE2) return;
  1902. + if (_lastCompassZone == ExSetCompassZoneCode.SIEGEWARZONE2)
  1903. + return;
  1904. _lastCompassZone = ExSetCompassZoneCode.SIEGEWARZONE2;
  1905. ExSetCompassZoneCode cz = new ExSetCompassZoneCode(ExSetCompassZoneCode.SIEGEWARZONE2);
  1906. sendPacket(cz);
  1907. }
  1908. else if (isInsideZone(ZONE_PVP))
  1909. {
  1910. - if (_lastCompassZone == ExSetCompassZoneCode.PVPZONE) return;
  1911. + if (_lastCompassZone == ExSetCompassZoneCode.PVPZONE)
  1912. + return;
  1913. _lastCompassZone = ExSetCompassZoneCode.PVPZONE;
  1914. ExSetCompassZoneCode cz = new ExSetCompassZoneCode(ExSetCompassZoneCode.PVPZONE);
  1915. sendPacket(cz);
  1916. }
  1917. else if (isIn7sDungeon())
  1918. {
  1919. - if (_lastCompassZone == ExSetCompassZoneCode.SEVENSIGNSZONE) return;
  1920. + if (_lastCompassZone == ExSetCompassZoneCode.SEVENSIGNSZONE)
  1921. + return;
  1922. _lastCompassZone = ExSetCompassZoneCode.SEVENSIGNSZONE;
  1923. ExSetCompassZoneCode cz = new ExSetCompassZoneCode(ExSetCompassZoneCode.SEVENSIGNSZONE);
  1924. sendPacket(cz);
  1925. }
  1926. else if (isInsideZone(ZONE_PEACE))
  1927. {
  1928. - if (_lastCompassZone == ExSetCompassZoneCode.PEACEZONE) return;
  1929. + if (_lastCompassZone == ExSetCompassZoneCode.PEACEZONE)
  1930. + return;
  1931. _lastCompassZone = ExSetCompassZoneCode.PEACEZONE;
  1932. ExSetCompassZoneCode cz = new ExSetCompassZoneCode(ExSetCompassZoneCode.PEACEZONE);
  1933. sendPacket(cz);
  1934. }
  1935. else
  1936. {
  1937. - if (_lastCompassZone == ExSetCompassZoneCode.GENERALZONE) return;
  1938. - if (_lastCompassZone == ExSetCompassZoneCode.SIEGEWARZONE2) updatePvPStatus();
  1939. + if (_lastCompassZone == ExSetCompassZoneCode.GENERALZONE)
  1940. + return;
  1941. + if (_lastCompassZone == ExSetCompassZoneCode.SIEGEWARZONE2)
  1942. + updatePvPStatus();
  1943. _lastCompassZone = ExSetCompassZoneCode.GENERALZONE;
  1944. ExSetCompassZoneCode cz = new ExSetCompassZoneCode(ExSetCompassZoneCode.GENERALZONE);
  1945. sendPacket(cz);
  1946. @@ -2099,7 +2133,7 @@
  1947. {
  1948. return _inventory.getTotalWeight();
  1949. }
  1950. -
  1951. +
  1952. /**
  1953. * Return the number of recommandation obtained by the L2PcInstance.<BR><BR>
  1954. */
  1955. @@ -2194,7 +2228,8 @@
  1956. */
  1957. public void setKarma(int karma)
  1958. {
  1959. - if (karma < 0) karma = 0;
  1960. + if (karma < 0)
  1961. + karma = 0;
  1962. if (_karma == 0 && karma > 0)
  1963. {
  1964. Collection<L2Object> objs = getKnownList().getKnownObjects().values();
  1965. @@ -2229,10 +2264,12 @@
  1966. // Source http://l2p.bravehost.com/weightlimit.html (May 2007)
  1967. // Fitted exponential curve to the data
  1968. int con = getCON();
  1969. - if (con < 1) return 31000;
  1970. - if (con > 59) return 176000;
  1971. - double baseLoad = Math.pow(1.029993928, con)*30495.627366;
  1972. - return (int)calcStat(Stats.MAX_LOAD, baseLoad*Config.ALT_WEIGHT_LIMIT, this, null);
  1973. + if (con < 1)
  1974. + return 31000;
  1975. + if (con > 59)
  1976. + return 176000;
  1977. + double baseLoad = Math.pow(1.029993928, con) * 30495.627366;
  1978. + return (int) calcStat(Stats.MAX_LOAD, baseLoad * Config.ALT_WEIGHT_LIMIT, this, null);
  1979. }
  1980.  
  1981. public int getExpertiseArmorPenalty()
  1982. @@ -2260,7 +2297,7 @@
  1983. int maxLoad = getMaxLoad();
  1984. if (maxLoad > 0)
  1985. {
  1986. - long weightproc = (long)getCurrentLoad() * 1000 / maxLoad;
  1987. + long weightproc = (long) getCurrentLoad() * 1000 / maxLoad;
  1988. weightproc *= calcStat(Stats.WEIGHT_LIMIT, 1, this, null);
  1989. int newWeightPenalty;
  1990. if (weightproc < 500 || _dietMode)
  1991. @@ -2271,7 +2308,7 @@
  1992. {
  1993. newWeightPenalty = 1;
  1994. }
  1995. - else if ( weightproc < 800)
  1996. + else if (weightproc < 800)
  1997. {
  1998. newWeightPenalty = 2;
  1999. }
  2000. @@ -2289,7 +2326,7 @@
  2001. _curWeightPenalty = newWeightPenalty;
  2002. if (newWeightPenalty > 0 && !_dietMode)
  2003. {
  2004. - super.addSkill(SkillTable.getInstance().getInfo(4270,newWeightPenalty));
  2005. + super.addSkill(SkillTable.getInstance().getInfo(4270, newWeightPenalty));
  2006. setIsOverloaded(getCurrentLoad() > maxLoad);
  2007. }
  2008. else
  2009. @@ -2315,8 +2352,7 @@
  2010.  
  2011. for (L2ItemInstance item : getInventory().getItems())
  2012. {
  2013. - if (item != null && item.isEquipped() &&
  2014. - ((item.getItemType() != L2EtcItemType.ARROW) && (item.getItemType() != L2EtcItemType.BOLT)))
  2015. + if (item != null && item.isEquipped() && ((item.getItemType() != L2EtcItemType.ARROW) && (item.getItemType() != L2EtcItemType.BOLT)))
  2016. {
  2017. int crystaltype = item.getItem().getCrystalType();
  2018.  
  2019. @@ -2397,7 +2433,7 @@
  2020. sendPacket(sm);
  2021.  
  2022. if (Config.DEBUG)
  2023. - _log.info(" | Skill "+effectSkill.getName()+" has been disabled for ("+getName()+"); Reason: Incompatible Weapon Type.");
  2024. + _log.info(" | Skill " + effectSkill.getName() + " has been disabled for (" + getName() + "); Reason: Incompatible Weapon Type.");
  2025.  
  2026. currenteffect.exit();
  2027. }
  2028. @@ -2489,14 +2525,15 @@
  2029. sendPacket(SystemMessageId.CANNOT_EQUIP_ITEM_DUE_TO_BAD_CONDITION);
  2030. }
  2031. refreshExpertisePenalty();
  2032. -
  2033. +
  2034. broadcastUserInfo();
  2035.  
  2036. InventoryUpdate iu = new InventoryUpdate();
  2037. iu.addItems(Arrays.asList(items));
  2038. sendPacket(iu);
  2039.  
  2040. - if (abortAttack) abortAttack();
  2041. + if (abortAttack)
  2042. + abortAttack();
  2043.  
  2044. if (getInventoryLimit() != oldInvLimit)
  2045. sendPacket(new ExStorageMaxCount(this));
  2046. @@ -2562,12 +2599,12 @@
  2047. {
  2048. if (getLvlJoinedAcademy() != 0 && _clan != null && PlayerClass.values()[Id].getLevel() == ClassLevel.Third)
  2049. {
  2050. - if(getLvlJoinedAcademy() <= 16)
  2051. + if (getLvlJoinedAcademy() <= 16)
  2052. _clan.addReputationScore(Config.JOIN_ACADEMY_MAX_REP_SCORE, true);
  2053. - else if(getLvlJoinedAcademy() >= 39)
  2054. + else if (getLvlJoinedAcademy() >= 39)
  2055. _clan.addReputationScore(Config.JOIN_ACADEMY_MIN_REP_SCORE, true);
  2056. else
  2057. - _clan.addReputationScore((Config.JOIN_ACADEMY_MAX_REP_SCORE-(getLvlJoinedAcademy()-16)*20), true);
  2058. + _clan.addReputationScore((Config.JOIN_ACADEMY_MAX_REP_SCORE - (getLvlJoinedAcademy() - 16) * 20), true);
  2059. setLvlJoinedAcademy(0);
  2060. //oust pledge member from the academy, cuz he has finished his 2nd class transfer
  2061. SystemMessage msg = SystemMessage.getSystemMessage(SystemMessageId.CLAN_MEMBER_S1_EXPELLED);
  2062. @@ -2578,7 +2615,7 @@
  2063. sendPacket(SystemMessage.getSystemMessage(SystemMessageId.ACADEMY_MEMBERSHIP_TERMINATED));
  2064.  
  2065. // receive graduation gift
  2066. - getInventory().addItem("Gift",8181,1,this,null); // give academy circlet
  2067. + getInventory().addItem("Gift", 8181, 1, this, null); // give academy circlet
  2068. }
  2069. if (isSubClassActive())
  2070. {
  2071. @@ -2612,7 +2649,10 @@
  2072. }
  2073.  
  2074. /** Return the Experience of the L2PcInstance. */
  2075. - public long getExp() { return getStat().getExp(); }
  2076. + public long getExp()
  2077. + {
  2078. + return getStat().getExp();
  2079. + }
  2080.  
  2081. public void setActiveEnchantAttrItem(L2ItemInstance stone)
  2082. {
  2083. @@ -2689,7 +2729,7 @@
  2084. {
  2085. return _fistsWeaponItem;
  2086. }
  2087. -
  2088. +
  2089. /**
  2090. * Return the fists weapon of the L2PcInstance Class (used when no weapon is equiped).<BR><BR>
  2091. */
  2092. @@ -2700,55 +2740,55 @@
  2093. {
  2094. //human fighter fists
  2095. L2Item temp = ItemTable.getInstance().getTemplate(246);
  2096. - weaponItem = (L2Weapon)temp;
  2097. + weaponItem = (L2Weapon) temp;
  2098. }
  2099. else if ((classId >= 0x0a) && (classId <= 0x11))
  2100. {
  2101. //human mage fists
  2102. L2Item temp = ItemTable.getInstance().getTemplate(251);
  2103. - weaponItem = (L2Weapon)temp;
  2104. + weaponItem = (L2Weapon) temp;
  2105. }
  2106. else if ((classId >= 0x12) && (classId <= 0x18))
  2107. {
  2108. //elven fighter fists
  2109. L2Item temp = ItemTable.getInstance().getTemplate(244);
  2110. - weaponItem = (L2Weapon)temp;
  2111. + weaponItem = (L2Weapon) temp;
  2112. }
  2113. else if ((classId >= 0x19) && (classId <= 0x1e))
  2114. {
  2115. //elven mage fists
  2116. L2Item temp = ItemTable.getInstance().getTemplate(249);
  2117. - weaponItem = (L2Weapon)temp;
  2118. + weaponItem = (L2Weapon) temp;
  2119. }
  2120. else if ((classId >= 0x1f) && (classId <= 0x25))
  2121. {
  2122. //dark elven fighter fists
  2123. L2Item temp = ItemTable.getInstance().getTemplate(245);
  2124. - weaponItem = (L2Weapon)temp;
  2125. + weaponItem = (L2Weapon) temp;
  2126. }
  2127. else if ((classId >= 0x26) && (classId <= 0x2b))
  2128. {
  2129. //dark elven mage fists
  2130. L2Item temp = ItemTable.getInstance().getTemplate(250);
  2131. - weaponItem = (L2Weapon)temp;
  2132. + weaponItem = (L2Weapon) temp;
  2133. }
  2134. else if ((classId >= 0x2c) && (classId <= 0x30))
  2135. {
  2136. //orc fighter fists
  2137. L2Item temp = ItemTable.getInstance().getTemplate(248);
  2138. - weaponItem = (L2Weapon)temp;
  2139. + weaponItem = (L2Weapon) temp;
  2140. }
  2141. else if ((classId >= 0x31) && (classId <= 0x34))
  2142. {
  2143. //orc mage fists
  2144. L2Item temp = ItemTable.getInstance().getTemplate(252);
  2145. - weaponItem = (L2Weapon)temp;
  2146. + weaponItem = (L2Weapon) temp;
  2147. }
  2148. else if ((classId >= 0x35) && (classId <= 0x39))
  2149. {
  2150. //dwarven fists
  2151. L2Item temp = ItemTable.getInstance().getTemplate(247);
  2152. - weaponItem = (L2Weapon)temp;
  2153. + weaponItem = (L2Weapon) temp;
  2154. }
  2155.  
  2156. return weaponItem;
  2157. @@ -2825,7 +2865,7 @@
  2158.  
  2159. while (skills.size() > unLearnable)
  2160. {
  2161. - for (L2SkillLearn s: skills)
  2162. + for (L2SkillLearn s : skills)
  2163. {
  2164. L2Skill sk = SkillTable.getInstance().getInfo(s.getSkillId(), s.getSkillLevel());
  2165. if (sk == null || (sk.getId() == L2Skill.SKILL_DIVINE_INSPIRATION && !Config.AUTO_LEARN_DIVINE_INSPIRATION && !isGM()))
  2166. @@ -2871,7 +2911,7 @@
  2167.  
  2168. if ((autoGetSkills != null) && !autoGetSkills.isEmpty())
  2169. {
  2170. - for (L2SkillLearn s: autoGetSkills)
  2171. + for (L2SkillLearn s : autoGetSkills)
  2172. {
  2173. final L2Skill skill = SkillTable.getInstance().getInfo(s.getSkillId(), s.getSkillLevel());
  2174. if (skill != null)
  2175. @@ -2925,7 +2965,10 @@
  2176. }
  2177.  
  2178. /** Return the SP amount of the L2PcInstance. */
  2179. - public int getSp() { return getStat().getSp(); }
  2180. + public int getSp()
  2181. + {
  2182. + return getStat().getSp();
  2183. + }
  2184.  
  2185. /** Set the SP amount of the L2PcInstance. */
  2186. public void setSp(int sp)
  2187. @@ -2955,6 +2998,7 @@
  2188.  
  2189. return false;
  2190. }
  2191. +
  2192. /**
  2193. * Return the Clan Identifier of the L2PcInstance.<BR><BR>
  2194. */
  2195. @@ -3043,6 +3087,7 @@
  2196. {
  2197. _waitTypeSitting = state;
  2198. }
  2199. +
  2200. /**
  2201. * Sit down the L2PcInstance, set the AI Intention to AI_INTENTION_REST and send a Server->Client ChangeWaitType packet (broadcast)<BR><BR>
  2202. */
  2203. @@ -3063,12 +3108,13 @@
  2204. {
  2205. breakAttack();
  2206. setIsSitting(true);
  2207. - broadcastPacket(new ChangeWaitType (this, ChangeWaitType.WT_SITTING));
  2208. + broadcastPacket(new ChangeWaitType(this, ChangeWaitType.WT_SITTING));
  2209. // Schedule a sit down task to wait for the animation to finish
  2210. ThreadPoolManager.getInstance().scheduleGeneral(new SitDownTask(), 2500);
  2211. setIsParalyzed(true);
  2212. }
  2213. }
  2214. +
  2215. /**
  2216. * Sit down Task
  2217. */
  2218. @@ -3081,6 +3127,7 @@
  2219. L2PcInstance.this.getAI().setIntention(CtrlIntention.AI_INTENTION_REST);
  2220. }
  2221. }
  2222. +
  2223. /**
  2224. * Stand up Task
  2225. */
  2226. @@ -3093,6 +3140,7 @@
  2227. L2PcInstance.this.getAI().setIntention(CtrlIntention.AI_INTENTION_IDLE);
  2228. }
  2229. }
  2230. +
  2231. /**
  2232. * Stand up the L2PcInstance, set the AI Intention to AI_INTENTION_IDLE and send a Server->Client ChangeWaitType packet (broadcast)<BR><BR>
  2233. */
  2234. @@ -3109,7 +3157,7 @@
  2235. stopEffects(L2EffectType.RELAXING);
  2236. }
  2237.  
  2238. - broadcastPacket(new ChangeWaitType (this, ChangeWaitType.WT_STANDING));
  2239. + broadcastPacket(new ChangeWaitType(this, ChangeWaitType.WT_STANDING));
  2240. // Schedule a stand up task to wait for the animation to finish
  2241. ThreadPoolManager.getInstance().scheduleGeneral(new StandUpTask(), 2500);
  2242. }
  2243. @@ -3142,11 +3190,11 @@
  2244.  
  2245. /**
  2246. * Return the PcFreight object of the L2PcInstance.<BR><BR>
  2247. - */
  2248. - public PcFreight getFreight()
  2249. - {
  2250. - return _freight;
  2251. - }
  2252. + */
  2253. + public PcFreight getFreight()
  2254. + {
  2255. + return _freight;
  2256. + }
  2257.  
  2258. /**
  2259. * Returns true if refund list is not empty
  2260. @@ -3236,7 +3284,8 @@
  2261. iu.addItem(_inventory.getAdenaInstance());
  2262. sendPacket(iu);
  2263. }
  2264. - else sendPacket(new ItemList(this, false));
  2265. + else
  2266. + sendPacket(new ItemList(this, false));
  2267. }
  2268. }
  2269.  
  2270. @@ -3252,7 +3301,8 @@
  2271. {
  2272. if (count > getAdena())
  2273. {
  2274. - if (sendMessage) sendPacket(SystemMessage.getSystemMessage(SystemMessageId.YOU_NOT_ENOUGH_ADENA));
  2275. + if (sendMessage)
  2276. + sendPacket(SystemMessage.getSystemMessage(SystemMessageId.YOU_NOT_ENOUGH_ADENA));
  2277. return false;
  2278. }
  2279.  
  2280. @@ -3269,7 +3319,8 @@
  2281. iu.addItem(adenaItem);
  2282. sendPacket(iu);
  2283. }
  2284. - else sendPacket(new ItemList(this, false));
  2285. + else
  2286. + sendPacket(new ItemList(this, false));
  2287.  
  2288. if (sendMessage)
  2289. {
  2290. @@ -3310,7 +3361,8 @@
  2291. iu.addItem(_inventory.getAncientAdenaInstance());
  2292. sendPacket(iu);
  2293. }
  2294. - else sendPacket(new ItemList(this, false));
  2295. + else
  2296. + sendPacket(new ItemList(this, false));
  2297. }
  2298. }
  2299.  
  2300. @@ -3431,15 +3483,15 @@
  2301. dropItem("InvDrop", newitem, null, true, true);
  2302.  
  2303. // Cursed Weapon
  2304. - else if(CursedWeaponsManager.getInstance().isCursed(newitem.getItemId()))
  2305. + else if (CursedWeaponsManager.getInstance().isCursed(newitem.getItemId()))
  2306. {
  2307. CursedWeaponsManager.getInstance().activate(this, newitem);
  2308. }
  2309.  
  2310. // Combat Flag
  2311. - else if(FortSiegeManager.getInstance().isCombat(item.getItemId()))
  2312. + else if (FortSiegeManager.getInstance().isCombat(item.getItemId()))
  2313. {
  2314. - if(FortSiegeManager.getInstance().activateCombatFlag(this, item))
  2315. + if (FortSiegeManager.getInstance().activateCombatFlag(this, item))
  2316. {
  2317. Fort fort = FortManager.getInstance().getFort(this);
  2318. fort.getSiege().announceToPlayer(SystemMessage.getSystemMessage(SystemMessageId.C1_ACQUIRED_THE_FLAG), this.getName());
  2319. @@ -3468,7 +3520,7 @@
  2320. if (count > 0)
  2321. {
  2322. L2ItemInstance item = null;
  2323. - if(ItemTable.getInstance().getTemplate(itemId) != null)
  2324. + if (ItemTable.getInstance().getTemplate(itemId) != null)
  2325. {
  2326. item = ItemTable.getInstance().createDummyItem(itemId);
  2327. }
  2328. @@ -3478,8 +3530,7 @@
  2329. return null;
  2330. }
  2331. // Sends message to client if requested
  2332. - if (sendMessage && ((!isCastingNow() && item.getItemType() == L2EtcItemType.HERB)
  2333. - || item.getItemType() != L2EtcItemType.HERB))
  2334. + if (sendMessage && ((!isCastingNow() && item.getItemType() == L2EtcItemType.HERB) || item.getItemType() != L2EtcItemType.HERB))
  2335. {
  2336. if (count > 1)
  2337. {
  2338. @@ -3517,7 +3568,7 @@
  2339. //Auto use herbs - autoloot
  2340. if (item.getItemType() == L2EtcItemType.HERB) //If item is herb dont add it to iv :]
  2341. {
  2342. - if(!isCastingNow())
  2343. + if (!isCastingNow())
  2344. {
  2345. L2ItemInstance herb = new L2ItemInstance(_charId, itemId);
  2346. IItemHandler handler = ItemHandler.getInstance().getItemHandler(herb.getEtcItem());
  2347. @@ -3526,8 +3577,8 @@
  2348. else
  2349. {
  2350. handler.useItem(this, herb, false);
  2351. - if(_herbstask>=100)
  2352. - _herbstask -=100;
  2353. + if (_herbstask >= 100)
  2354. + _herbstask -= 100;
  2355. }
  2356. }
  2357. else
  2358. @@ -3546,13 +3597,13 @@
  2359. dropItem("InvDrop", createdItem, null, true);
  2360.  
  2361. // Cursed Weapon
  2362. - else if(CursedWeaponsManager.getInstance().isCursed(createdItem.getItemId()))
  2363. + else if (CursedWeaponsManager.getInstance().isCursed(createdItem.getItemId()))
  2364. CursedWeaponsManager.getInstance().activate(this, createdItem);
  2365.  
  2366. // Combat Flag
  2367. - else if(FortSiegeManager.getInstance().isCombat(createdItem.getItemId()))
  2368. + else if (FortSiegeManager.getInstance().isCombat(createdItem.getItemId()))
  2369. {
  2370. - if( FortSiegeManager.getInstance().activateCombatFlag(this, item))
  2371. + if (FortSiegeManager.getInstance().activateCombatFlag(this, item))
  2372. {
  2373. Fort fort = FortManager.getInstance().getFort(this);
  2374. fort.getSiege().announceToPlayer(SystemMessage.getSystemMessage(SystemMessageId.C1_ACQUIRED_THE_FLAG), this.getName());
  2375. @@ -3632,7 +3683,7 @@
  2376. sm.addItemNumber(count);
  2377. sendPacket(sm);
  2378. }
  2379. - else
  2380. + else
  2381. {
  2382. SystemMessage sm = SystemMessage.getSystemMessage(SystemMessageId.S1_DISAPPEARED);
  2383. sm.addItemName(item);
  2384. @@ -3728,7 +3779,8 @@
  2385. playerIU.addItem(item);
  2386. sendPacket(playerIU);
  2387. }
  2388. - else sendPacket(new ItemList(this, false));
  2389. + else
  2390. + sendPacket(new ItemList(this, false));
  2391.  
  2392. // Update current load as well
  2393. StatusUpdate su = new StatusUpdate(this);
  2394. @@ -3745,7 +3797,7 @@
  2395. sm.addItemNumber(count);
  2396. sendPacket(sm);
  2397. }
  2398. - else
  2399. + else
  2400. {
  2401. SystemMessage sm = SystemMessage.getSystemMessage(SystemMessageId.S1_DISAPPEARED);
  2402. sm.addItemName(itemId);
  2403. @@ -3755,7 +3807,7 @@
  2404.  
  2405. return true;
  2406. }
  2407. -
  2408. +
  2409. /**
  2410. * Transfers item to another ItemContainer and send a Server->Client InventoryUpdate packet to the L2PcInstance.
  2411. * @param process : String Identifier of process triggering this action
  2412. @@ -3767,9 +3819,11 @@
  2413. public L2ItemInstance transferItem(String process, int objectId, long count, Inventory target, L2Object reference)
  2414. {
  2415. L2ItemInstance oldItem = checkItemManipulation(objectId, count, "transfer");
  2416. - if (oldItem == null) return null;
  2417. + if (oldItem == null)
  2418. + return null;
  2419. L2ItemInstance newItem = getInventory().transferItem(process, objectId, count, target, this, reference);
  2420. - if (newItem == null) return null;
  2421. + if (newItem == null)
  2422. + return null;
  2423.  
  2424. // Send inventory update packet
  2425. if (!Config.FORCE_INVENTORY_UPDATE)
  2426. @@ -3783,7 +3837,8 @@
  2427.  
  2428. sendPacket(playerIU);
  2429. }
  2430. - else sendPacket(new ItemList(this, false));
  2431. + else
  2432. + sendPacket(new ItemList(this, false));
  2433.  
  2434. // Update current load as well
  2435. StatusUpdate playerSU = new StatusUpdate(this);
  2436. @@ -3793,7 +3848,7 @@
  2437. // Send target update packet
  2438. if (target instanceof PcInventory)
  2439. {
  2440. - L2PcInstance targetPlayer = ((PcInventory)target).getOwner();
  2441. + L2PcInstance targetPlayer = ((PcInventory) target).getOwner();
  2442.  
  2443. if (!Config.FORCE_INVENTORY_UPDATE)
  2444. {
  2445. @@ -3806,7 +3861,8 @@
  2446.  
  2447. targetPlayer.sendPacket(playerIU);
  2448. }
  2449. - else targetPlayer.sendPacket(new ItemList(targetPlayer, false));
  2450. + else
  2451. + targetPlayer.sendPacket(new ItemList(targetPlayer, false));
  2452.  
  2453. // Update current load as well
  2454. playerSU = new StatusUpdate(targetPlayer);
  2455. @@ -3822,7 +3878,7 @@
  2456. else
  2457. petIU.addNewItem(newItem);
  2458.  
  2459. - ((PetInventory)target).getOwner().getOwner().sendPacket(petIU);
  2460. + ((PetInventory) target).getOwner().getOwner().sendPacket(petIU);
  2461. }
  2462. return newItem;
  2463. }
  2464. @@ -3850,24 +3906,23 @@
  2465.  
  2466. item.dropMe(this, getX() + Rnd.get(50) - 25, getY() + Rnd.get(50) - 25, getZ() + 20);
  2467.  
  2468. - if (Config.AUTODESTROY_ITEM_AFTER > 0
  2469. - && Config.DESTROY_DROPPED_PLAYER_ITEM
  2470. - && !Config.LIST_PROTECTED_ITEMS.contains(item.getItemId())) {
  2471. - if ((item.isEquipable() && Config.DESTROY_EQUIPABLE_PLAYER_ITEM)
  2472. - || !item.isEquipable())
  2473. + if (Config.AUTODESTROY_ITEM_AFTER > 0 && Config.DESTROY_DROPPED_PLAYER_ITEM && !Config.LIST_PROTECTED_ITEMS.contains(item.getItemId()))
  2474. + {
  2475. + if ((item.isEquipable() && Config.DESTROY_EQUIPABLE_PLAYER_ITEM) || !item.isEquipable())
  2476. ItemsAutoDestroy.getInstance().addItem(item);
  2477. }
  2478.  
  2479. // protection against auto destroy dropped item
  2480. - if (Config.DESTROY_DROPPED_PLAYER_ITEM) {
  2481. - if (!item.isEquipable()
  2482. - || (item.isEquipable() && Config.DESTROY_EQUIPABLE_PLAYER_ITEM))
  2483. + if (Config.DESTROY_DROPPED_PLAYER_ITEM)
  2484. + {
  2485. + if (!item.isEquipable() || (item.isEquipable() && Config.DESTROY_EQUIPABLE_PLAYER_ITEM))
  2486. item.setProtected(false);
  2487. else
  2488. item.setProtected(true);
  2489. - } else
  2490. + }
  2491. + else
  2492. item.setProtected(true);
  2493. -
  2494. +
  2495. // retail drop protection
  2496. if (protectItem)
  2497. item.getDropProtection().protect(this);
  2498. @@ -3879,7 +3934,8 @@
  2499. playerIU.addItem(item);
  2500. sendPacket(playerIU);
  2501. }
  2502. - else sendPacket(new ItemList(this, false));
  2503. + else
  2504. + sendPacket(new ItemList(this, false));
  2505.  
  2506. // Update current load as well
  2507. StatusUpdate su = new StatusUpdate(this);
  2508. @@ -3929,13 +3985,14 @@
  2509.  
  2510. item.dropMe(this, x, y, z);
  2511.  
  2512. - if (Config.AUTODESTROY_ITEM_AFTER >0 && Config.DESTROY_DROPPED_PLAYER_ITEM && !Config.LIST_PROTECTED_ITEMS.contains(item.getItemId()))
  2513. + if (Config.AUTODESTROY_ITEM_AFTER > 0 && Config.DESTROY_DROPPED_PLAYER_ITEM && !Config.LIST_PROTECTED_ITEMS.contains(item.getItemId()))
  2514. {
  2515. - if ( (item.isEquipable() && Config.DESTROY_EQUIPABLE_PLAYER_ITEM) || !item.isEquipable())
  2516. + if ((item.isEquipable() && Config.DESTROY_EQUIPABLE_PLAYER_ITEM) || !item.isEquipable())
  2517. ItemsAutoDestroy.getInstance().addItem(item);
  2518. }
  2519. - if (Config.DESTROY_DROPPED_PLAYER_ITEM){
  2520. - if (!item.isEquipable() || (item.isEquipable() && Config.DESTROY_EQUIPABLE_PLAYER_ITEM ))
  2521. + if (Config.DESTROY_DROPPED_PLAYER_ITEM)
  2522. + {
  2523. + if (!item.isEquipable() || (item.isEquipable() && Config.DESTROY_EQUIPABLE_PLAYER_ITEM))
  2524. item.setProtected(false);
  2525. else
  2526. item.setProtected(true);
  2527. @@ -3980,7 +4037,7 @@
  2528. //TODO: if we remove objects that are not visisble from the L2World, we'll have to remove this check
  2529. if (L2World.getInstance().findObject(objectId) == null)
  2530. {
  2531. - _log.finest(getObjectId()+": player tried to " + action + " item not available in L2World");
  2532. + _log.finest(getObjectId() + ": player tried to " + action + " item not available in L2World");
  2533. return null;
  2534. }
  2535.  
  2536. @@ -3988,19 +4045,19 @@
  2537.  
  2538. if (item == null || item.getOwnerId() != getObjectId())
  2539. {
  2540. - _log.finest(getObjectId()+": player tried to " + action + " item he is not owner of");
  2541. + _log.finest(getObjectId() + ": player tried to " + action + " item he is not owner of");
  2542. return null;
  2543. }
  2544.  
  2545. if (count < 0 || (count > 1 && !item.isStackable()))
  2546. {
  2547. - _log.finest(getObjectId()+": player tried to " + action + " item with invalid count: "+ count);
  2548. + _log.finest(getObjectId() + ": player tried to " + action + " item with invalid count: " + count);
  2549. return null;
  2550. }
  2551.  
  2552. if (count > item.getCount())
  2553. {
  2554. - _log.finest(getObjectId()+": player tried to " + action + " more items than he owns");
  2555. + _log.finest(getObjectId() + ": player tried to " + action + " more items than he owns");
  2556. return null;
  2557. }
  2558.  
  2559. @@ -4008,7 +4065,7 @@
  2560. if (getPet() != null && getPet().getControlObjectId() == objectId || getMountObjectID() == objectId)
  2561. {
  2562. if (Config.DEBUG)
  2563. - _log.finest(getObjectId()+": player tried to " + action + " item controling pet");
  2564. + _log.finest(getObjectId() + ": player tried to " + action + " item controling pet");
  2565.  
  2566. return null;
  2567. }
  2568. @@ -4016,11 +4073,11 @@
  2569. if (getActiveEnchantItem() != null && getActiveEnchantItem().getObjectId() == objectId)
  2570. {
  2571. if (Config.DEBUG)
  2572. - _log.finest(getObjectId()+":player tried to " + action + " an enchant scroll he was using");
  2573. + _log.finest(getObjectId() + ":player tried to " + action + " an enchant scroll he was using");
  2574.  
  2575. return null;
  2576. }
  2577. -
  2578. +
  2579. // We cannot put a Weapon with Augmention in WH while casting (Possible Exploit)
  2580. if (item.isAugmented() && (isCastingNow() || this.isCastingSimultaneouslyNow()))
  2581. return null;
  2582. @@ -4034,7 +4091,7 @@
  2583. public void setProtection(boolean protect)
  2584. {
  2585. if (Config.DEVELOPER && (protect || _protectEndTime > 0))
  2586. - _log.warning(getName() + ": Protection " + (protect?"ON " + (GameTimeController.getGameTicks() + Config.PLAYER_SPAWN_PROTECTION * GameTimeController.TICKS_PER_SECOND) :"OFF") + " (currently " + GameTimeController.getGameTicks() + ")");
  2587. + _log.warning(getName() + ": Protection " + (protect ? "ON " + (GameTimeController.getGameTicks() + Config.PLAYER_SPAWN_PROTECTION * GameTimeController.TICKS_PER_SECOND) : "OFF") + " (currently " + GameTimeController.getGameTicks() + ")");
  2588.  
  2589. _protectEndTime = protect ? GameTimeController.getGameTicks() + Config.PLAYER_SPAWN_PROTECTION * GameTimeController.TICKS_PER_SECOND : 0;
  2590. }
  2591. @@ -4042,9 +4099,9 @@
  2592. public void setTeleportProtection(boolean protect)
  2593. {
  2594. if (Config.DEVELOPER && (protect || _teleportProtectEndTime > 0))
  2595. - _log.warning(getName() + ": Tele Protection " + (protect?"ON " + (GameTimeController.getGameTicks() + Config.PLAYER_TELEPORT_PROTECTION * GameTimeController.TICKS_PER_SECOND) :"OFF") + " (currently " + GameTimeController.getGameTicks() + ")");
  2596. + _log.warning(getName() + ": Tele Protection " + (protect ? "ON " + (GameTimeController.getGameTicks() + Config.PLAYER_TELEPORT_PROTECTION * GameTimeController.TICKS_PER_SECOND) : "OFF") + " (currently " + GameTimeController.getGameTicks() + ")");
  2597.  
  2598. - _teleportProtectEndTime = protect? GameTimeController.getGameTicks() + Config.PLAYER_TELEPORT_PROTECTION * GameTimeController.TICKS_PER_SECOND : 0;
  2599. + _teleportProtectEndTime = protect ? GameTimeController.getGameTicks() + Config.PLAYER_TELEPORT_PROTECTION * GameTimeController.TICKS_PER_SECOND : 0;
  2600. }
  2601.  
  2602. /**
  2603. @@ -4157,8 +4214,7 @@
  2604. sendPacket(SystemMessage.getSystemMessage(SystemMessageId.A_MALICIOUS_SKILL_CANNOT_BE_USED_IN_PEACE_ZONE));
  2605. return false;
  2606. }
  2607. - if (getTrap() != null
  2608. - && getTrap().getSkill().getId() == ((L2SkillTrap)skill).getTriggerSkillId())
  2609. + if (getTrap() != null && getTrap().getSkill().getId() == ((L2SkillTrap) skill).getTriggerSkillId())
  2610. {
  2611. SystemMessage sm = SystemMessage.getSystemMessage(SystemMessageId.S1_CANNOT_BE_USED);
  2612. sm.addSkillName(skill);
  2613. @@ -4169,7 +4225,7 @@
  2614. }
  2615. case SUMMON:
  2616. {
  2617. - if (!((L2SkillSummon)skill).isCubic() && (getPet() != null || isMounted() || CharSummonTable.getInstance().getPets().contains(getObjectId()) || CharSummonTable.getInstance().getPets().contains(getObjectId())))
  2618. + if (!((L2SkillSummon) skill).isCubic() && (getPet() != null || isMounted() || CharSummonTable.getInstance().getPets().contains(getObjectId()) || CharSummonTable.getInstance().getPets().contains(getObjectId())))
  2619. {
  2620. if (Config.DEBUG)
  2621. _log.fine("player has a pet already. ignore summon skill");
  2622. @@ -4182,8 +4238,7 @@
  2623.  
  2624. // TODO: Should possibly be checked only in L2PcInstance's useMagic
  2625. // Can't use Hero and resurrect skills during Olympiad
  2626. - if (isInOlympiadMode() &&
  2627. - (skill.isHeroSkill() || skill.getSkillType() == L2SkillType.RESURRECT))
  2628. + if (isInOlympiadMode() && (skill.isHeroSkill() || skill.getSkillType() == L2SkillType.RESURRECT))
  2629. {
  2630. SystemMessage sm = SystemMessage.getSystemMessage(SystemMessageId.THIS_SKILL_IS_NOT_AVAILABLE_FOR_THE_OLYMPIAD_EVENT);
  2631. sendPacket(sm);
  2632. @@ -4192,8 +4247,7 @@
  2633.  
  2634. final int charges = getCharges();
  2635. // Check if the spell using charges or not in AirShip
  2636. - if ((skill.getMaxCharges() == 0 && charges < skill.getNumCharges())
  2637. - || (isInAirShip() && skill.getSkillType() != L2SkillType.REFUEL))
  2638. + if ((skill.getMaxCharges() == 0 && charges < skill.getNumCharges()) || (isInAirShip() && skill.getSkillType() != L2SkillType.REFUEL))
  2639. {
  2640. SystemMessage sm = SystemMessage.getSystemMessage(SystemMessageId.S1_CANNOT_BE_USED);
  2641. sm.addSkillName(skill);
  2642. @@ -4225,7 +4279,7 @@
  2643. else
  2644. {
  2645. double doubleMulti = currentCp / _cpUpdateInterval;
  2646. - int intMulti = (int)doubleMulti;
  2647. + int intMulti = (int) doubleMulti;
  2648.  
  2649. _cpUpdateDecCheck = _cpUpdateInterval * (doubleMulti < intMulti ? intMulti-- : intMulti);
  2650. _cpUpdateIncCheck = _cpUpdateDecCheck + _cpUpdateInterval;
  2651. @@ -4258,7 +4312,7 @@
  2652. else
  2653. {
  2654. double doubleMulti = currentMp / _mpUpdateInterval;
  2655. - int intMulti = (int)doubleMulti;
  2656. + int intMulti = (int) doubleMulti;
  2657.  
  2658. _mpUpdateDecCheck = _mpUpdateInterval * (doubleMulti < intMulti ? intMulti-- : intMulti);
  2659. _mpUpdateIncCheck = _mpUpdateDecCheck + _mpUpdateInterval;
  2660. @@ -4292,17 +4346,14 @@
  2661. su.addAttribute(StatusUpdate.CUR_HP, (int) getCurrentHp());
  2662. su.addAttribute(StatusUpdate.CUR_MP, (int) getCurrentMp());
  2663. su.addAttribute(StatusUpdate.CUR_CP, (int) getCurrentCp());
  2664. - su.addAttribute(StatusUpdate.MAX_CP, getMaxCp());
  2665. + su.addAttribute(StatusUpdate.MAX_CP, getMaxCp());
  2666. sendPacket(su);
  2667.  
  2668. final boolean needCpUpdate = needCpUpdate(352);
  2669. final boolean needHpUpdate = needHpUpdate(352);
  2670. // Check if a party is in progress and party window update is usefull
  2671. L2Party party = _party;
  2672. - if (party != null
  2673. - && (needCpUpdate
  2674. - || needHpUpdate
  2675. - || needMpUpdate(352)))
  2676. + if (party != null && (needCpUpdate || needHpUpdate || needMpUpdate(352)))
  2677. {
  2678. if (Config.DEBUG)
  2679. _log.fine("Send status for party window of " + getObjectId() + "(" + getName() + ") to his party. CP: " + getCurrentCp() + " HP: " + getCurrentHp() + " MP: " + getCurrentMp());
  2680. @@ -4311,18 +4362,15 @@
  2681. party.broadcastToPartyMembers(this, update);
  2682. }
  2683.  
  2684. - if (isInOlympiadMode()
  2685. - && isOlympiadStart()
  2686. - && (needCpUpdate || needHpUpdate))
  2687. + if (isInOlympiadMode() && isOlympiadStart() && (needCpUpdate || needHpUpdate))
  2688. {
  2689. final OlympiadGameTask game = OlympiadGameManager.getInstance().getOlympiadTask(getOlympiadGameId());
  2690. if (game != null && game.isBattleStarted())
  2691. game.getZone().broadcastStatusUpdate(this);
  2692. }
  2693. -
  2694. +
  2695. // In duel MP updated only with CP or HP
  2696. - if (isInDuel()
  2697. - && (needCpUpdate || needHpUpdate))
  2698. + if (isInDuel() && (needCpUpdate || needHpUpdate))
  2699. {
  2700. ExDuelUpdateUserInfo update = new ExDuelUpdateUserInfo(this);
  2701. DuelManager.getInstance().broadcastToOppositTeam(this, update);
  2702. @@ -4355,9 +4403,7 @@
  2703.  
  2704. broadcastPacket(new CharInfo(this));
  2705. broadcastPacket(new ExBrExtraUserInfo(this));
  2706. - if (TerritoryWarManager.getInstance().isTWInProgress()
  2707. - && (TerritoryWarManager.getInstance().checkIsRegistered(-1, getObjectId())
  2708. - || TerritoryWarManager.getInstance().checkIsRegistered(-1, getClan())))
  2709. + if (TerritoryWarManager.getInstance().isTWInProgress() && (TerritoryWarManager.getInstance().checkIsRegistered(-1, getObjectId()) || TerritoryWarManager.getInstance().checkIsRegistered(-1, getClan())))
  2710. {
  2711. broadcastPacket(new ExDominionWarStart(this));
  2712. }
  2713. @@ -4494,7 +4540,7 @@
  2714. this.sendPacket(new GameGuardQuery());
  2715. if (Config.GAMEGUARD_ENFORCE)
  2716. {
  2717. - ThreadPoolManager.getInstance().scheduleGeneral(new GameGuardCheck(), 30*1000);
  2718. + ThreadPoolManager.getInstance().scheduleGeneral(new GameGuardCheck(), 30 * 1000);
  2719. }
  2720. }
  2721.  
  2722. @@ -4509,8 +4555,8 @@
  2723. L2GameClient client = L2PcInstance.this.getClient();
  2724. if (client != null && !client.isAuthedGG() && L2PcInstance.this.isOnline())
  2725. {
  2726. - GmListTable.broadcastMessageToGMs("Client "+client+" failed to reply GameGuard query and is being kicked!");
  2727. - _log.info("Client "+client+" failed to reply GameGuard query and is being kicked!");
  2728. + GmListTable.broadcastMessageToGMs("Client " + client + " failed to reply GameGuard query and is being kicked!");
  2729. + _log.info("Client " + client + " failed to reply GameGuard query and is being kicked!");
  2730. client.close(LeaveWorld.STATIC_PACKET);
  2731. }
  2732. }
  2733. @@ -4587,13 +4633,14 @@
  2734. */
  2735. public void doAutoLoot(L2Attackable target, L2Attackable.RewardItem item)
  2736. {
  2737. - if (isInParty()&&ItemTable.getInstance().getTemplate(item.getItemId()).getItemType() != L2EtcItemType.HERB)
  2738. + if (isInParty() && ItemTable.getInstance().getTemplate(item.getItemId()).getItemType() != L2EtcItemType.HERB)
  2739. getParty().distributeItem(this, item, false, target);
  2740. - else if (item.getItemId() == 57) addAdena("Loot", item.getCount(), target, true);
  2741. - else addItem("Loot", item.getItemId(), item.getCount(), target, true);
  2742. + else if (item.getItemId() == 57)
  2743. + addAdena("Loot", item.getCount(), target, true);
  2744. + else
  2745. + addItem("Loot", item.getItemId(), item.getCount(), target, true);
  2746. }
  2747.  
  2748. -
  2749. /**
  2750. * Manage Pickup Task.<BR><BR>
  2751. *
  2752. @@ -4612,16 +4659,17 @@
  2753. */
  2754. protected void doPickupItem(L2Object object)
  2755. {
  2756. - if (isAlikeDead() || isFakeDeath()) return;
  2757. + if (isAlikeDead() || isFakeDeath())
  2758. + return;
  2759.  
  2760. // Set the AI Intention to AI_INTENTION_IDLE
  2761. getAI().setIntention(CtrlIntention.AI_INTENTION_IDLE);
  2762.  
  2763. // Check if the L2Object to pick up is a L2ItemInstance
  2764. - if (! (object instanceof L2ItemInstance))
  2765. + if (!(object instanceof L2ItemInstance))
  2766. {
  2767. // dont try to pickup anything that is not an item :)
  2768. - _log.warning(this+" trying to pickup wrong target."+getTarget());
  2769. + _log.warning(this + " trying to pickup wrong target." + getTarget());
  2770. return;
  2771. }
  2772.  
  2773. @@ -4633,7 +4681,7 @@
  2774. // Send a Server->Client packet StopMove to this L2PcInstance
  2775. StopMove sm = new StopMove(this);
  2776. if (Config.DEBUG)
  2777. - _log.fine("pickup pos: "+ target.getX() + " "+target.getY()+ " "+target.getZ() );
  2778. + _log.fine("pickup pos: " + target.getX() + " " + target.getY() + " " + target.getZ());
  2779. sendPacket(sm);
  2780.  
  2781. SystemMessage smsg = null;
  2782. @@ -4656,7 +4704,7 @@
  2783. return;
  2784. }
  2785.  
  2786. - if ( ((isInParty() && getParty().getLootDistribution() == L2Party.ITEM_LOOTER) || !isInParty()) && !_inventory.validateCapacity(target))
  2787. + if (((isInParty() && getParty().getLootDistribution() == L2Party.ITEM_LOOTER) || !isInParty()) && !_inventory.validateCapacity(target))
  2788. {
  2789. sendPacket(ActionFailed.STATIC_PACKET);
  2790. sendPacket(SystemMessage.getSystemMessage(SystemMessageId.SLOTS_FULL));
  2791. @@ -4696,19 +4744,18 @@
  2792. }
  2793.  
  2794. // You can pickup only 1 combat flag
  2795. - if(FortSiegeManager.getInstance().isCombat(target.getItemId()) )
  2796. + if (FortSiegeManager.getInstance().isCombat(target.getItemId()))
  2797. {
  2798. if (!FortSiegeManager.getInstance().checkIfCanPickup(this))
  2799. - return ;
  2800. + return;
  2801. }
  2802.  
  2803. - if(target.getItemLootShedule() != null
  2804. - && (target.getOwnerId() == getObjectId() || isInLooterParty(target.getOwnerId())))
  2805. + if (target.getItemLootShedule() != null && (target.getOwnerId() == getObjectId() || isInLooterParty(target.getOwnerId())))
  2806. target.resetOwnerTimer();
  2807.  
  2808. // Remove the L2ItemInstance from the world and send server->client GetItem packets
  2809. target.pickupMe(this);
  2810. - if(Config.SAVE_DROPPED_ITEM) // item must be removed from ItemsOnGroundManager if is active
  2811. + if (Config.SAVE_DROPPED_ITEM) // item must be removed from ItemsOnGroundManager if is active
  2812. ItemsOnGroundManager.getInstance().removeObject(target);
  2813. }
  2814.  
  2815. @@ -4723,18 +4770,18 @@
  2816. ItemTable.getInstance().destroyItem("Consume", target, this, null);
  2817. }
  2818. // Cursed Weapons are not distributed
  2819. - else if(CursedWeaponsManager.getInstance().isCursed(target.getItemId()))
  2820. + else if (CursedWeaponsManager.getInstance().isCursed(target.getItemId()))
  2821. {
  2822. addItem("Pickup", target, null, true);
  2823. }
  2824. - else if(FortSiegeManager.getInstance().isCombat(target.getItemId()) )
  2825. + else if (FortSiegeManager.getInstance().isCombat(target.getItemId()))
  2826. {
  2827. addItem("Pickup", target, null, true);
  2828. }
  2829. else
  2830. {
  2831. // if item is instance of L2ArmorType or L2WeaponType broadcast an "Attention" system message
  2832. - if(target.getItemType() instanceof L2ArmorType || target.getItemType() instanceof L2WeaponType)
  2833. + if (target.getItemType() instanceof L2ArmorType || target.getItemType() instanceof L2WeaponType)
  2834. {
  2835. if (target.getEnchantLevel() > 0)
  2836. {
  2837. @@ -4754,7 +4801,8 @@
  2838. }
  2839.  
  2840. // Check if a Party is in progress
  2841. - if (isInParty()) getParty().distributeItem(this, target);
  2842. + if (isInParty())
  2843. + getParty().distributeItem(this, target);
  2844. // Target is adena
  2845. else if (target.getItemId() == 57 && getInventory().getAdenaInstance() != null)
  2846. {
  2847. @@ -4784,8 +4832,7 @@
  2848.  
  2849. public boolean canOpenPrivateStore()
  2850. {
  2851. - return !isAlikeDead() && !isInOlympiadMode() && !isMounted()
  2852. - && !isInsideZone(ZONE_NOSTORE) && !isCastingNow();
  2853. + return !isAlikeDead() && !isInOlympiadMode() && !isMounted() && !isInsideZone(ZONE_NOSTORE) && !isCastingNow();
  2854. }
  2855.  
  2856. public void tryOpenPrivateBuyStore()
  2857. @@ -4874,7 +4921,7 @@
  2858. return;
  2859. }
  2860. setQueuedSkill(null, false, false);
  2861. - if(isMounted())
  2862. + if (isMounted())
  2863. {
  2864. // Get off the strider or something else if character is mounted
  2865. dismount();
  2866. @@ -4895,7 +4942,7 @@
  2867. if (_transformation != null)
  2868. {
  2869. setQueuedSkill(null, false, false);
  2870. - setTransformAllowedSkills(new int[]{});
  2871. + setTransformAllowedSkills(new int[] {});
  2872. _transformation.onUntransform();
  2873. _transformation = null;
  2874. stopEffects(L2EffectType.TRANSFORMATION);
  2875. @@ -4940,8 +4987,7 @@
  2876. {
  2877. _transformationId = getTransformationId();
  2878.  
  2879. - if (_transformationId == L2Transformation.TRANSFORM_AKAMANAH
  2880. - || _transformationId == L2Transformation.TRANSFORM_ZARICHE)
  2881. + if (_transformationId == L2Transformation.TRANSFORM_AKAMANAH || _transformationId == L2Transformation.TRANSFORM_ZARICHE)
  2882. return;
  2883.  
  2884. Connection con = null;
  2885. @@ -4958,7 +5004,7 @@
  2886. }
  2887. catch (Exception e)
  2888. {
  2889. - _log.log(Level.SEVERE, "Transformation insert info: ",e);
  2890. + _log.log(Level.SEVERE, "Transformation insert info: ", e);
  2891. }
  2892. finally
  2893. {
  2894. @@ -4988,7 +5034,7 @@
  2895. }
  2896. catch (Exception e)
  2897. {
  2898. - _log.log(Level.SEVERE, "Transformation select info: ",e);
  2899. + _log.log(Level.SEVERE, "Transformation select info: ", e);
  2900. }
  2901. finally
  2902. {
  2903. @@ -5012,9 +5058,9 @@
  2904. public void setTarget(L2Object newTarget)
  2905. {
  2906.  
  2907. - if(newTarget!=null)
  2908. + if (newTarget != null)
  2909. {
  2910. - boolean isParty=(( (newTarget instanceof L2PcInstance) && isInParty() && getParty().getPartyMembers().contains(newTarget)));
  2911. + boolean isParty = (((newTarget instanceof L2PcInstance) && isInParty() && getParty().getPartyMembers().contains(newTarget)));
  2912.  
  2913. // Check if the new target is visible
  2914. if (!isParty && !newTarget.isVisible())
  2915. @@ -5024,10 +5070,10 @@
  2916. if (newTarget != null && !isParty && Math.abs(newTarget.getZ() - getZ()) > 1000)
  2917. newTarget = null;
  2918. }
  2919. - if(!isGM())
  2920. + if (!isGM())
  2921. {
  2922. // Can't target and attack festival monsters if not participant
  2923. - if((newTarget instanceof L2FestivalMonsterInstance) && !isFestivalParticipant())
  2924. + if ((newTarget instanceof L2FestivalMonsterInstance) && !isFestivalParticipant())
  2925. newTarget = null;
  2926.  
  2927. // vehicles cant be targeted
  2928. @@ -5035,7 +5081,7 @@
  2929. newTarget = null;
  2930.  
  2931. // Can't target and attack rift invaders if not in the same room
  2932. - else if(isInParty() && getParty().isInDimensionalRift())
  2933. + else if (isInParty() && getParty().isInDimensionalRift())
  2934. {
  2935. byte riftType = getParty().getDimensionalRift().getType();
  2936. byte riftRoom = getParty().getDimensionalRift().getCurrentRoom();
  2937. @@ -5052,7 +5098,7 @@
  2938. {
  2939. if (oldTarget.equals(newTarget))
  2940. return; // no target change
  2941. -
  2942. +
  2943. // Remove the L2PcInstance from the _statusListener of the old target if it was a L2Character
  2944. if (oldTarget instanceof L2Character)
  2945. ((L2Character) oldTarget).removeStatusListener(this);
  2946. @@ -5134,14 +5180,12 @@
  2947.  
  2948. if (armor != null && legs != null)
  2949. {
  2950. - if ((L2ArmorType)legs.getItemType() == L2ArmorType.HEAVY
  2951. - && ((L2ArmorType)armor.getItemType() == L2ArmorType.HEAVY))
  2952. + if ((L2ArmorType) legs.getItemType() == L2ArmorType.HEAVY && ((L2ArmorType) armor.getItemType() == L2ArmorType.HEAVY))
  2953. return true;
  2954. }
  2955. if (armor != null)
  2956. {
  2957. - if ((getInventory().getPaperdollItem(Inventory.PAPERDOLL_CHEST).getItem().getBodyPart() == L2Item.SLOT_FULL_ARMOR
  2958. - && (L2ArmorType)armor.getItemType() == L2ArmorType.HEAVY))
  2959. + if ((getInventory().getPaperdollItem(Inventory.PAPERDOLL_CHEST).getItem().getBodyPart() == L2Item.SLOT_FULL_ARMOR && (L2ArmorType) armor.getItemType() == L2ArmorType.HEAVY))
  2960. return true;
  2961. }
  2962. return false;
  2963. @@ -5154,14 +5198,12 @@
  2964.  
  2965. if (armor != null && legs != null)
  2966. {
  2967. - if ((L2ArmorType)legs.getItemType() == L2ArmorType.LIGHT
  2968. - && ((L2ArmorType)armor.getItemType() == L2ArmorType.LIGHT))
  2969. + if ((L2ArmorType) legs.getItemType() == L2ArmorType.LIGHT && ((L2ArmorType) armor.getItemType() == L2ArmorType.LIGHT))
  2970. return true;
  2971. }
  2972. if (armor != null)
  2973. {
  2974. - if ((getInventory().getPaperdollItem(Inventory.PAPERDOLL_CHEST).getItem().getBodyPart() == L2Item.SLOT_FULL_ARMOR
  2975. - && (L2ArmorType)armor.getItemType() == L2ArmorType.LIGHT))
  2976. + if ((getInventory().getPaperdollItem(Inventory.PAPERDOLL_CHEST).getItem().getBodyPart() == L2Item.SLOT_FULL_ARMOR && (L2ArmorType) armor.getItemType() == L2ArmorType.LIGHT))
  2977. return true;
  2978. }
  2979. return false;
  2980. @@ -5174,14 +5216,12 @@
  2981.  
  2982. if (armor != null && legs != null)
  2983. {
  2984. - if ((L2ArmorType)legs.getItemType() == L2ArmorType.MAGIC
  2985. - && ((L2ArmorType)armor.getItemType() == L2ArmorType.MAGIC))
  2986. + if ((L2ArmorType) legs.getItemType() == L2ArmorType.MAGIC && ((L2ArmorType) armor.getItemType() == L2ArmorType.MAGIC))
  2987. return true;
  2988. }
  2989. if (armor != null)
  2990. {
  2991. - if ((getInventory().getPaperdollItem(Inventory.PAPERDOLL_CHEST).getItem().getBodyPart() == L2Item.SLOT_FULL_ARMOR
  2992. - && (L2ArmorType)armor.getItemType() == L2ArmorType.MAGIC))
  2993. + if ((getInventory().getPaperdollItem(Inventory.PAPERDOLL_CHEST).getItem().getBodyPart() == L2Item.SLOT_FULL_ARMOR && (L2ArmorType) armor.getItemType() == L2ArmorType.MAGIC))
  2994. return true;
  2995. }
  2996. return false;
  2997. @@ -5202,7 +5242,7 @@
  2998. return _engagerequest;
  2999. }
  3000.  
  3001. - public void setEngageRequest(boolean state,int playerid)
  3002. + public void setEngageRequest(boolean state, int playerid)
  3003. {
  3004. _engagerequest = state;
  3005. _engageid = playerid;
  3006. @@ -5255,15 +5295,15 @@
  3007.  
  3008. public void engageAnswer(int answer)
  3009. {
  3010. - if(_engagerequest==false)
  3011. + if (_engagerequest == false)
  3012. return;
  3013. - else if(_engageid==0)
  3014. + else if (_engageid == 0)
  3015. return;
  3016. else
  3017. {
  3018. L2PcInstance ptarget = L2World.getInstance().getPlayer(_engageid);
  3019. - setEngageRequest(false,0);
  3020. - if(ptarget!=null)
  3021. + setEngageRequest(false, 0);
  3022. + if (ptarget != null)
  3023. {
  3024. if (answer == 1)
  3025. {
  3026. @@ -5299,7 +5339,6 @@
  3027. return null;
  3028. }
  3029.  
  3030. -
  3031. /**
  3032. *
  3033. * Kill the L2Character, Apply Death Penalty, Manage gain/loss Karma and Item Drop.<BR><BR>
  3034. @@ -5327,6 +5366,7 @@
  3035.  
  3036. if (isMounted())
  3037. stopFeed();
  3038. +
  3039. synchronized (this)
  3040. {
  3041. if (isFakeDeath())
  3042. @@ -5339,6 +5379,8 @@
  3043.  
  3044. TvTEvent.onKill(killer, this);
  3045.  
  3046. + PlayerKill.getInstance().onKill(this, killer);
  3047. +
  3048. if (L2Event.isParticipant(pk) && pk != null)
  3049. pk.getEventStatus().kills.add(this);
  3050.  
  3051. @@ -5371,7 +5413,7 @@
  3052. Announcements.getInstance().announceToAll(msg);
  3053. }
  3054. }
  3055. -
  3056. +
  3057. broadcastStatusUpdate();
  3058. // Clear resurrect xp calculation
  3059. setExpBeforeDeath(0);
  3060. @@ -5407,10 +5449,9 @@
  3061.  
  3062. if (!(isInsideZone(ZONE_PVP) && !isInsideZone(ZONE_SIEGE)))
  3063. {
  3064. - if (pk != null && pk.getClan() != null && getClan() != null && !isAcademyMember() && !(pk.isAcademyMember()) )
  3065. + if (pk != null && pk.getClan() != null && getClan() != null && !isAcademyMember() && !(pk.isAcademyMember()))
  3066. {
  3067. - if ((_clan.isAtWarWith(pk.getClanId()) && pk.getClan().isAtWarWith(_clan.getClanId()))
  3068. - || (isInSiege() && pk.isInSiege()))
  3069. + if ((_clan.isAtWarWith(pk.getClanId()) && pk.getClan().isAtWarWith(_clan.getClanId())) || (isInSiege() && pk.isInSiege()))
  3070. {
  3071. if (AntiFeedManager.getInstance().check(killer, this))
  3072. {
  3073. @@ -5492,13 +5533,9 @@
  3074. return;
  3075.  
  3076. L2PcInstance pk = killer.getActingPlayer();
  3077. - if (getKarma() <= 0 && pk != null
  3078. - && pk.getClan() != null && getClan() != null
  3079. - && (
  3080. - pk.getClan().isAtWarWith(getClanId())
  3081. - // || this.getClan().isAtWarWith(((L2PcInstance)killer).getClanId())
  3082. - )
  3083. - )
  3084. + if (getKarma() <= 0 && pk != null && pk.getClan() != null && getClan() != null && (pk.getClan().isAtWarWith(getClanId())
  3085. + // || this.getClan().isAtWarWith(((L2PcInstance)killer).getClanId())
  3086. + ))
  3087. return;
  3088.  
  3089. if ((!isInsideZone(ZONE_PVP) || pk == null) && (!isGM() || Config.KARMA_DROP_GM))
  3090. @@ -5507,11 +5544,11 @@
  3091. boolean isKillerNpc = (killer instanceof L2Npc);
  3092. int pkLimit = Config.KARMA_PK_LIMIT;
  3093.  
  3094. - int dropEquip = 0;
  3095. - int dropEquipWeapon = 0;
  3096. - int dropItem = 0;
  3097. - int dropLimit = 0;
  3098. - int dropPercent = 0;
  3099. + int dropEquip = 0;
  3100. + int dropEquipWeapon = 0;
  3101. + int dropItem = 0;
  3102. + int dropLimit = 0;
  3103. + int dropPercent = 0;
  3104.  
  3105. if (getKarma() > 0 && getPkKills() >= pkLimit)
  3106. {
  3107. @@ -5540,16 +5577,15 @@
  3108. for (L2ItemInstance itemDrop : getInventory().getItems())
  3109. {
  3110. // Don't drop
  3111. - if (
  3112. - itemDrop.isShadowItem() || // Dont drop Shadow Items
  3113. - itemDrop.isTimeLimitedItem() || // Dont drop Time Limited Items
  3114. - !itemDrop.isDropable() ||
  3115. - itemDrop.getItemId() == 57 || // Adena
  3116. - itemDrop.getItem().getType2() == L2Item.TYPE2_QUEST || // Quest Items
  3117. - getPet() != null && getPet().getControlObjectId() == itemDrop.getItemId() || // Control Item of active pet
  3118. - Arrays.binarySearch(Config.KARMA_LIST_NONDROPPABLE_ITEMS, itemDrop.getItemId()) >= 0 || // Item listed in the non droppable item list
  3119. - Arrays.binarySearch(Config.KARMA_LIST_NONDROPPABLE_PET_ITEMS, itemDrop.getItemId()) >= 0 // Item listed in the non droppable pet item list
  3120. - ) continue;
  3121. + if (itemDrop.isShadowItem() || // Dont drop Shadow Items
  3122. + itemDrop.isTimeLimitedItem() || // Dont drop Time Limited Items
  3123. + !itemDrop.isDropable() || itemDrop.getItemId() == 57 || // Adena
  3124. + itemDrop.getItem().getType2() == L2Item.TYPE2_QUEST || // Quest Items
  3125. + getPet() != null && getPet().getControlObjectId() == itemDrop.getItemId() || // Control Item of active pet
  3126. + Arrays.binarySearch(Config.KARMA_LIST_NONDROPPABLE_ITEMS, itemDrop.getItemId()) >= 0 || // Item listed in the non droppable item list
  3127. + Arrays.binarySearch(Config.KARMA_LIST_NONDROPPABLE_PET_ITEMS, itemDrop.getItemId()) >= 0 // Item listed in the non droppable pet item list
  3128. + )
  3129. + continue;
  3130.  
  3131. if (itemDrop.isEquipped())
  3132. {
  3133. @@ -5557,8 +5593,9 @@
  3134. itemDropPercent = itemDrop.getItem().getType2() == L2Item.TYPE2_WEAPON ? dropEquipWeapon : dropEquip;
  3135. getInventory().unEquipItemInSlot(itemDrop.getLocationSlot());
  3136. }
  3137. - else itemDropPercent = dropItem; // Item in inventory
  3138. -
  3139. + else
  3140. + itemDropPercent = dropItem; // Item in inventory
  3141. +
  3142. // NOTE: Each time an item is dropped, the chance of another item being dropped gets lesser (dropCount * 2)
  3143. if (Rnd.get(100) < itemDropPercent)
  3144. {
  3145. @@ -5580,7 +5617,7 @@
  3146. private void onDieUpdateKarma()
  3147. {
  3148. // Karma lose for server that does not allow delevel
  3149. - if ( getKarma() > 0 )
  3150. + if (getKarma() > 0)
  3151. {
  3152. // this formula seems to work relatively well:
  3153. // baseKarma * thisLVL * (thisLVL/100)
  3154. @@ -5589,23 +5626,28 @@
  3155. karmaLost *= getLevel(); // multiply by char lvl
  3156. karmaLost *= (getLevel() / 100.0); // divide by 0.charLVL
  3157. karmaLost = Math.round(karmaLost);
  3158. - if ( karmaLost < 0 ) karmaLost = 1;
  3159. + if (karmaLost < 0)
  3160. + karmaLost = 1;
  3161.  
  3162. // Decrease Karma of the L2PcInstance and Send it a Server->Client StatusUpdate packet with Karma and PvP Flag if necessary
  3163. - setKarma(getKarma() - (int)karmaLost);
  3164. + setKarma(getKarma() - (int) karmaLost);
  3165. }
  3166. }
  3167.  
  3168. public void onKillUpdatePvPKarma(L2Character target)
  3169. {
  3170. - if (target == null) return;
  3171. - if (!(target instanceof L2Playable)) return;
  3172. + if (target == null)
  3173. + return;
  3174. + if (!(target instanceof L2Playable))
  3175. + return;
  3176.  
  3177. L2PcInstance targetPlayer = target.getActingPlayer();
  3178.  
  3179. - if (targetPlayer == null) return; // Target player is null
  3180. - if (targetPlayer == this) return; // Target player is self
  3181. -
  3182. + if (targetPlayer == null)
  3183. + return; // Target player is null
  3184. + if (targetPlayer == this)
  3185. + return; // Target player is self
  3186. +
  3187. if (isCursedWeaponEquipped())
  3188. {
  3189. CursedWeaponsManager.getInstance().increaseKills(_cursedWeaponEquippedId);
  3190. @@ -5620,33 +5662,26 @@
  3191. }
  3192.  
  3193. // If in duel and you kill (only can kill l2summon), do nothing
  3194. - if (isInDuel() && targetPlayer.isInDuel()) return;
  3195. + if (isInDuel() && targetPlayer.isInDuel())
  3196. + return;
  3197.  
  3198. // If in Arena, do nothing
  3199. if (isInsideZone(ZONE_PVP) || targetPlayer.isInsideZone(ZONE_PVP))
  3200. return;
  3201.  
  3202. // Check if it's pvp
  3203. - if (
  3204. - (
  3205. - checkIfPvP(target) && // Can pvp and
  3206. - targetPlayer.getPvpFlag() != 0 // Target player has pvp flag set
  3207. - ) || // or
  3208. - (
  3209. - isInsideZone(ZONE_PVP) && // Player is inside pvp zone and
  3210. - targetPlayer.isInsideZone(ZONE_PVP) // Target player is inside pvp zone
  3211. - )
  3212. - )
  3213. + if ((checkIfPvP(target) && // Can pvp and
  3214. + targetPlayer.getPvpFlag() != 0 // Target player has pvp flag set
  3215. + ) || // or
  3216. + (isInsideZone(ZONE_PVP) && // Player is inside pvp zone and
  3217. + targetPlayer.isInsideZone(ZONE_PVP) // Target player is inside pvp zone
  3218. + ))
  3219. increasePvpKills(target);
  3220. else
  3221. - // Target player doesn't have pvp flag set
  3222. + // Target player doesn't have pvp flag set
  3223. {
  3224. // check about wars
  3225. - if (targetPlayer.getClan() != null && getClan() != null
  3226. - && getClan().isAtWarWith(targetPlayer.getClanId())
  3227. - && targetPlayer.getClan().isAtWarWith(getClanId())
  3228. - && targetPlayer.getPledgeType() != L2Clan.SUBUNIT_ACADEMY
  3229. - && getPledgeType() != L2Clan.SUBUNIT_ACADEMY)
  3230. + if (targetPlayer.getClan() != null && getClan() != null && getClan().isAtWarWith(targetPlayer.getClanId()) && targetPlayer.getClan().isAtWarWith(getClanId()) && targetPlayer.getPledgeType() != L2Clan.SUBUNIT_ACADEMY && getPledgeType() != L2Clan.SUBUNIT_ACADEMY)
  3231. {
  3232. // 'Both way war' -> 'PvP Kill'
  3233. increasePvpKills(target);
  3234. @@ -5654,12 +5689,12 @@
  3235. }
  3236.  
  3237. // 'No war' or 'One way war' -> 'Normal PK'
  3238. - if (targetPlayer.getKarma() > 0) // Target player has karma
  3239. + if (targetPlayer.getKarma() > 0) // Target player has karma
  3240. {
  3241. if (Config.KARMA_AWARD_PK_KILL)
  3242. increasePvpKills(target);
  3243. }
  3244. - else if (targetPlayer.getPvpFlag() == 0) // Target player doesn't have karma
  3245. + else if (targetPlayer.getPvpFlag() == 0) // Target player doesn't have karma
  3246. {
  3247. increasePkKillsAndKarma(target);
  3248. //Unequip adventurer items
  3249. @@ -5674,8 +5709,7 @@
  3250. */
  3251. public void increasePvpKills(L2Character target)
  3252. {
  3253. - if (target instanceof L2PcInstance
  3254. - && AntiFeedManager.getInstance().check(this, target))
  3255. + if (target instanceof L2PcInstance && AntiFeedManager.getInstance().check(this, target))
  3256. {
  3257. // Add karma to attacker and increase its PK counter
  3258. setPvpKills(getPvpKills() + 1);
  3259. @@ -5694,14 +5728,14 @@
  3260. */
  3261. public void increasePkKillsAndKarma(L2Character target)
  3262. {
  3263. - int baseKarma = Config.KARMA_MIN_KARMA;
  3264. - int newKarma = baseKarma;
  3265. - int karmaLimit = Config.KARMA_MAX_KARMA;
  3266. + int baseKarma = Config.KARMA_MIN_KARMA;
  3267. + int newKarma = baseKarma;
  3268. + int karmaLimit = Config.KARMA_MAX_KARMA;
  3269.  
  3270. - int pkLVL = getLevel();
  3271. - int pkPKCount = getPkKills();
  3272. + int pkLVL = getLevel();
  3273. + int pkPKCount = getPkKills();
  3274.  
  3275. - int targLVL = target.getLevel();
  3276. + int targLVL = target.getLevel();
  3277.  
  3278. int lvlDiffMulti = 0;
  3279. int pkCountMulti = 0;
  3280. @@ -5740,8 +5774,7 @@
  3281.  
  3282. // Add karma to attacker and increase its PK counter
  3283. setKarma(getKarma() + newKarma);
  3284. - if (target instanceof L2PcInstance
  3285. - && AntiFeedManager.getInstance().check(this, target))
  3286. + if (target instanceof L2PcInstance && AntiFeedManager.getInstance().check(this, target))
  3287. setPkKills(getPkKills() + 1);
  3288.  
  3289. // Send a Server->Client UserInfo packet to attacker with its Karma and PK Counter
  3290. @@ -5765,17 +5798,20 @@
  3291. if (expGained > Integer.MAX_VALUE)
  3292. karmaLost = Integer.MAX_VALUE;
  3293. else
  3294. - karmaLost = (int)expGained;
  3295. + karmaLost = (int) expGained;
  3296.  
  3297. - if (karmaLost < Config.KARMA_LOST_BASE) karmaLost = Config.KARMA_LOST_BASE;
  3298. - if (karmaLost > getKarma()) karmaLost = getKarma();
  3299. + if (karmaLost < Config.KARMA_LOST_BASE)
  3300. + karmaLost = Config.KARMA_LOST_BASE;
  3301. + if (karmaLost > getKarma())
  3302. + karmaLost = getKarma();
  3303.  
  3304. return karmaLost;
  3305. }
  3306.  
  3307. public void updatePvPStatus()
  3308. {
  3309. - if (isInsideZone(ZONE_PVP)) return;
  3310. + if (isInsideZone(ZONE_PVP))
  3311. + return;
  3312. setPvpFlagLasts(System.currentTimeMillis() + Config.PVP_NORMAL_TIME);
  3313.  
  3314. if (getPvpFlag() == 0)
  3315. @@ -5789,7 +5825,8 @@
  3316. if (player_target == null)
  3317. return;
  3318.  
  3319. - if ((isInDuel() && player_target.getDuelId() == getDuelId())) return;
  3320. + if ((isInDuel() && player_target.getDuelId() == getDuelId()))
  3321. + return;
  3322. if ((!isInsideZone(ZONE_PVP) || !player_target.isInsideZone(ZONE_PVP)) && player_target.getKarma() == 0)
  3323. {
  3324. if (checkIfPvP(player_target))
  3325. @@ -5882,7 +5919,7 @@
  3326. }
  3327.  
  3328. //The death steal you some Exp
  3329. - double percentLost = Config.PLAYER_XP_PERCENT_LOST[getLevel()]*clan_luck_modificator;
  3330. + double percentLost = Config.PLAYER_XP_PERCENT_LOST[getLevel()] * clan_luck_modificator;
  3331.  
  3332. if (getKarma() > 0)
  3333. percentLost *= Config.RATE_KARMA_EXP_LOST;
  3334. @@ -5894,9 +5931,9 @@
  3335. long lostExp = 0;
  3336. if (!L2Event.isParticipant(this))
  3337. if (lvl < ExperienceTable.getInstance().getMaxLevel())
  3338. - lostExp = Math.round((getStat().getExpForLevel(lvl+1) - getStat().getExpForLevel(lvl)) * percentLost /100);
  3339. + lostExp = Math.round((getStat().getExpForLevel(lvl + 1) - getStat().getExpForLevel(lvl)) * percentLost / 100);
  3340. else
  3341. - lostExp = Math.round((getStat().getExpForLevel(ExperienceTable.getInstance().getMaxLevel()) - getStat().getExpForLevel(ExperienceTable.getInstance().getMaxLevel() - 1)) * percentLost /100);
  3342. + lostExp = Math.round((getStat().getExpForLevel(ExperienceTable.getInstance().getMaxLevel()) - getStat().getExpForLevel(ExperienceTable.getInstance().getMaxLevel() - 1)) * percentLost / 100);
  3343.  
  3344. // Get the Experience before applying penalty
  3345. setExpBeforeDeath(getExp());
  3346. @@ -6001,11 +6038,11 @@
  3347. {
  3348. _summon = summon;
  3349. // update attack element value display
  3350. - if ((_summon == null || _summon instanceof L2SummonInstance)
  3351. - && getClassId().isSummoner() && getAttackElement() != Elementals.NONE)
  3352. + if ((_summon == null || _summon instanceof L2SummonInstance) && getClassId().isSummoner() && getAttackElement() != Elementals.NONE)
  3353. sendPacket(new UserInfo(this));
  3354.  
  3355. }
  3356. +
  3357. /**
  3358. * Set the L2Decoy of the L2PcInstance.<BR><BR>
  3359. */
  3360. @@ -6198,7 +6235,8 @@
  3361. return;
  3362.  
  3363. L2PcInstance partner = _activeTradeList.getPartner();
  3364. - if (partner != null) partner.onTradeCancel(this);
  3365. + if (partner != null)
  3366. + partner.onTradeCancel(this);
  3367. onTradeCancel(this);
  3368. }
  3369.  
  3370. @@ -6223,7 +6261,8 @@
  3371. */
  3372. public TradeList getSellList()
  3373. {
  3374. - if (_sellList == null) _sellList = new TradeList(this);
  3375. + if (_sellList == null)
  3376. + _sellList = new TradeList(this);
  3377. return _sellList;
  3378. }
  3379.  
  3380. @@ -6232,7 +6271,8 @@
  3381. */
  3382. public TradeList getBuyList()
  3383. {
  3384. - if (_buyList == null) _buyList = new TradeList(this);
  3385. + if (_buyList == null)
  3386. + _buyList = new TradeList(this);
  3387. return _buyList;
  3388. }
  3389.  
  3390. @@ -6348,20 +6388,20 @@
  3391. _boltItem = null;
  3392. else
  3393. _arrowItem = null;
  3394. - sendPacket(new ItemList(this,false));
  3395. + sendPacket(new ItemList(this, false));
  3396. return;
  3397. }
  3398.  
  3399. // Adjust item quantity
  3400. if (arrows.getCount() > 1)
  3401. {
  3402. - synchronized(arrows)
  3403. + synchronized (arrows)
  3404. {
  3405. arrows.changeCountWithoutTrace(-1, this, null);
  3406. arrows.setLastChange(L2ItemInstance.MODIFIED);
  3407.  
  3408. // could do also without saving, but let's save approx 1 of 10
  3409. - if(GameTimeController.getGameTicks() % 10 == 0)
  3410. + if (GameTimeController.getGameTicks() % 10 == 0)
  3411. arrows.updateDatabase();
  3412. _inventory.refreshWeight();
  3413. }
  3414. @@ -6377,8 +6417,9 @@
  3415. else
  3416. _arrowItem = null;
  3417.  
  3418. - if (Config.DEBUG) _log.fine("removed arrows count");
  3419. - sendPacket(new ItemList(this,false));
  3420. + if (Config.DEBUG)
  3421. + _log.fine("removed arrows count");
  3422. + sendPacket(new ItemList(this, false));
  3423. return;
  3424. }
  3425.  
  3426. @@ -6388,7 +6429,8 @@
  3427. iu.addModifiedItem(arrows);
  3428. sendPacket(iu);
  3429. }
  3430. - else sendPacket(new ItemList(this, false));
  3431. + else
  3432. + sendPacket(new ItemList(this, false));
  3433. }
  3434.  
  3435. /**
  3436. @@ -6452,16 +6494,19 @@
  3437.  
  3438. return _boltItem != null;
  3439. }
  3440. +
  3441. /**
  3442. * Disarm the player's weapon.<BR><BR>
  3443. */
  3444. public boolean disarmWeapons()
  3445. {
  3446. // Don't allow disarming a cursed weapon
  3447. - if (isCursedWeaponEquipped()) return false;
  3448. + if (isCursedWeaponEquipped())
  3449. + return false;
  3450.  
  3451. // Don't allow disarming a Combat Flag or Territory Ward
  3452. - if (isCombatFlagEquipped()) return false;
  3453. + if (isCombatFlagEquipped())
  3454. + return false;
  3455.  
  3456. // Unequip the weapon
  3457. L2ItemInstance wpn = getInventory().getPaperdollItem(Inventory.PAPERDOLL_RHAND);
  3458. @@ -6469,7 +6514,7 @@
  3459. {
  3460. L2ItemInstance[] unequiped = getInventory().unEquipItemInBodySlotAndRecord(wpn.getItem().getBodyPart());
  3461. InventoryUpdate iu = new InventoryUpdate();
  3462. - for (L2ItemInstance itm: unequiped)
  3463. + for (L2ItemInstance itm : unequiped)
  3464. iu.addModifiedItem(itm);
  3465. sendPacket(iu);
  3466.  
  3467. @@ -6507,7 +6552,7 @@
  3468. {
  3469. L2ItemInstance[] unequiped = getInventory().unEquipItemInBodySlotAndRecord(sld.getItem().getBodyPart());
  3470. InventoryUpdate iu = new InventoryUpdate();
  3471. - for (L2ItemInstance itm: unequiped)
  3472. + for (L2ItemInstance itm : unequiped)
  3473. iu.addModifiedItem(itm);
  3474. sendPacket(iu);
  3475.  
  3476. @@ -6560,7 +6605,7 @@
  3477. return true;
  3478. }
  3479.  
  3480. - public boolean mount(int npcId, int controlItemObjId,boolean useFood)
  3481. + public boolean mount(int npcId, int controlItemObjId, boolean useFood)
  3482. {
  3483. if (!disarmWeapons())
  3484. return false;
  3485. @@ -6717,7 +6762,8 @@
  3486. public boolean isUsingDualWeapon()
  3487. {
  3488. L2Weapon weaponItem = getActiveWeaponItem();
  3489. - if (weaponItem == null) return false;
  3490. + if (weaponItem == null)
  3491. + return false;
  3492.  
  3493. if (weaponItem.getItemType() == L2WeaponType.DUAL)
  3494. return true;
  3495. @@ -6736,7 +6782,7 @@
  3496.  
  3497. public long getUptime()
  3498. {
  3499. - return System.currentTimeMillis()-_uptime;
  3500. + return System.currentTimeMillis() - _uptime;
  3501. }
  3502.  
  3503. /**
  3504. @@ -6779,7 +6825,6 @@
  3505. }
  3506. }
  3507.  
  3508. -
  3509. /**
  3510. * Manage the Leave Party task of the L2PcInstance.<BR><BR>
  3511. */
  3512. @@ -6817,7 +6862,7 @@
  3513. {
  3514. if (level == AccessLevels._masterAccessLevelNum)
  3515. {
  3516. - _log.warning( "Master access level set for character " + getName() + "! Just a warning to be careful ;)" );
  3517. + _log.warning("Master access level set for character " + getName() + "! Just a warning to be careful ;)");
  3518. _accessLevel = AccessLevels._masterAccessLevel;
  3519. }
  3520. else if (level == AccessLevels._userAccessLevelNum)
  3521. @@ -6835,7 +6880,7 @@
  3522. }
  3523. else
  3524. {
  3525. - _log.warning( "Tryed to set unregistered access level " + level + " to character " + getName() + ". Setting access level without privileges!" );
  3526. + _log.warning("Tryed to set unregistered access level " + level + " to character " + getName() + ". Setting access level without privileges!");
  3527. _accessLevel = AccessLevels._userAccessLevel;
  3528. }
  3529. }
  3530. @@ -6852,7 +6897,7 @@
  3531.  
  3532. public void setAccountAccesslevel(int level)
  3533. {
  3534. - LoginServerThread.getInstance().sendAccessLevel(getAccountName(),level);
  3535. + LoginServerThread.getInstance().sendAccessLevel(getAccountName(), level);
  3536. }
  3537.  
  3538. /**
  3539. @@ -6862,7 +6907,7 @@
  3540. {
  3541. if (Config.EVERYBODY_HAS_ADMIN_RIGHTS)
  3542. return AccessLevels._masterAccessLevel;
  3543. - else if ( _accessLevel == null ) /* This is here because inventory etc. is loaded before access level on login, so it is not null */
  3544. + else if (_accessLevel == null) /* This is here because inventory etc. is loaded before access level on login, so it is not null */
  3545. setAccessLevel(AccessLevels._userAccessLevelNum);
  3546.  
  3547. return _accessLevel;
  3548. @@ -6887,7 +6932,8 @@
  3549. sendPacket(new UserInfo(this));
  3550. sendPacket(new ExBrExtraUserInfo(this));
  3551. }
  3552. - if (broadcastType == 2) broadcastUserInfo();
  3553. + if (broadcastType == 2)
  3554. + broadcastUserInfo();
  3555. }
  3556.  
  3557. /**
  3558. @@ -6998,7 +7044,7 @@
  3559. statement.setInt(11, getAppearance().getFace());
  3560. statement.setInt(12, getAppearance().getHairStyle());
  3561. statement.setInt(13, getAppearance().getHairColor());
  3562. - statement.setInt(14, getAppearance().getSex()? 1 : 0);
  3563. + statement.setInt(14, getAppearance().getSex() ? 1 : 0);
  3564. statement.setLong(15, getExp());
  3565. statement.setInt(16, getSp());
  3566. statement.setInt(17, getKarma());
  3567. @@ -7019,9 +7065,9 @@
  3568. statement.setInt(32, getWantsPeace());
  3569. statement.setInt(33, getBaseClass());
  3570. statement.setInt(34, getNewbie());
  3571. - statement.setInt(35, isNoble() ? 1 :0);
  3572. + statement.setInt(35, isNoble() ? 1 : 0);
  3573. statement.setLong(36, 0);
  3574. - statement.setLong(37,getCreateTime());
  3575. + statement.setLong(37, getCreateTime());
  3576.  
  3577. statement.executeUpdate();
  3578. statement.close();
  3579. @@ -7073,7 +7119,7 @@
  3580. while (rset.next())
  3581. {
  3582. final int activeClassId = rset.getInt("classid");
  3583. - final boolean female = rset.getInt("sex")!=0;
  3584. + final boolean female = rset.getInt("sex") != 0;
  3585. final L2PcTemplate template = CharTemplateTable.getInstance().getTemplate(activeClassId);
  3586. PcAppearance app = new PcAppearance(rset.getByte("face"), rset.getByte("hairColor"), rset.getByte("hairStyle"), female);
  3587.  
  3588. @@ -7096,7 +7142,7 @@
  3589. player.setPkKills(rset.getInt("pkkills"));
  3590. player.setOnlineTime(rset.getLong("onlinetime"));
  3591. player.setNewbie(rset.getInt("newbie"));
  3592. - player.setNoble(rset.getInt("nobless")==1);
  3593. + player.setNoble(rset.getInt("nobless") == 1);
  3594.  
  3595. player.setClanJoinExpiryTime(rset.getLong("clan_join_expiry_time"));
  3596. if (player.getClanJoinExpiryTime() < System.currentTimeMillis())
  3597. @@ -7109,8 +7155,8 @@
  3598. player.setClanCreateExpiryTime(0);
  3599. }
  3600.  
  3601. - int clanId = rset.getInt("clanid");
  3602. - player.setPowerGrade((int)rset.getLong("power_grade"));
  3603. + int clanId = rset.getInt("clanid");
  3604. + player.setPowerGrade((int) rset.getLong("power_grade"));
  3605. player.setPledgeType(rset.getInt("subpledge"));
  3606. //player.setApprentice(rset.getInt("apprentice"));
  3607.  
  3608. @@ -7152,7 +7198,7 @@
  3609. }
  3610.  
  3611. player.setDeleteTimer(rset.getLong("deletetime"));
  3612. -
  3613. +
  3614. player.setTitle(rset.getString("title"));
  3615. player.getAppearance().setTitleColor(rset.getInt("title_color"));
  3616. player.setAccessLevel(rset.getInt("accesslevel"));
  3617. @@ -7162,10 +7208,16 @@
  3618. currentHp = rset.getDouble("curHp");
  3619. currentCp = rset.getDouble("curCp");
  3620. currentMp = rset.getDouble("curMp");
  3621. -
  3622. +
  3623. player._classIndex = 0;
  3624. - try { player.setBaseClass(rset.getInt("base_class")); }
  3625. - catch (Exception e) { player.setBaseClass(activeClassId); }
  3626. + try
  3627. + {
  3628. + player.setBaseClass(rset.getInt("base_class"));
  3629. + }
  3630. + catch (Exception e)
  3631. + {
  3632. + player.setBaseClass(activeClassId);
  3633. + }
  3634.  
  3635. // Restore Subclass Data (cannot be done earlier in function)
  3636. if (restoreSubClassData(player))
  3637. @@ -7183,9 +7235,10 @@
  3638. // a possible restart-while-modifysubclass cheat has been attempted.
  3639. // Switching to use base class
  3640. player.setClassId(player.getBaseClass());
  3641. - _log.warning("Player "+player.getName()+" reverted to base class. Possibly has tried a relogin exploit while subclassing.");
  3642. + _log.warning("Player " + player.getName() + " reverted to base class. Possibly has tried a relogin exploit while subclassing.");
  3643. }
  3644. - else player._activeClass = activeClassId;
  3645. + else
  3646. + player._activeClass = activeClassId;
  3647.  
  3648. player.setApprentice(rset.getInt("apprentice"));
  3649. player.setSponsor(rset.getInt("sponsor"));
  3650. @@ -7248,7 +7301,7 @@
  3651. // Retrieve from the database all skills of this L2PcInstance and add them to _skills
  3652. // Retrieve from the database all items of this L2PcInstance and add them to _inventory
  3653. player.getInventory().restore();
  3654. - player.getFreight().restore();
  3655. + player.getFreight().restore();
  3656. if (!Config.WAREHOUSE_CACHE)
  3657. player.getWarehouse();
  3658.  
  3659. @@ -7267,7 +7320,8 @@
  3660. player.setCurrentHp(currentHp);
  3661. player.setCurrentMp(currentMp);
  3662.  
  3663. - if (currentHp < 0.5) {
  3664. + if (currentHp < 0.5)
  3665. + {
  3666. player.setIsDead(true);
  3667. player.stopHpMpRegeneration();
  3668. }
  3669. @@ -7310,7 +7364,7 @@
  3670.  
  3671. if (_forumMail == null)
  3672. {
  3673. - ForumsBBSManager.getInstance().createNewForum(getName(),ForumsBBSManager.getInstance().getForumByName("MailRoot"),Forum.MAIL,Forum.OWNERONLY,getObjectId());
  3674. + ForumsBBSManager.getInstance().createNewForum(getName(), ForumsBBSManager.getInstance().getForumByName("MailRoot"), Forum.MAIL, Forum.OWNERONLY, getObjectId());
  3675. setMail(ForumsBBSManager.getInstance().getForumByName("MailRoot").getChildByName(getName()));
  3676. }
  3677. }
  3678. @@ -7420,7 +7474,7 @@
  3679. restoreRecipeBook(true);
  3680.  
  3681. // Restore Recipe Shop list
  3682. - if(Config.STORE_RECIPE_SHOPLIST)
  3683. + if (Config.STORE_RECIPE_SHOPLIST)
  3684. restoreRecipeShopList();
  3685.  
  3686. // Load Premium Item List
  3687. @@ -7437,10 +7491,10 @@
  3688. {
  3689. Connection con = null;
  3690.  
  3691. - try {
  3692. + try
  3693. + {
  3694. con = L2DatabaseFactory.getInstance().getConnection();
  3695. - String sql = loadCommon ? "SELECT id, type, classIndex FROM character_recipebook WHERE charId=?" :
  3696. - "SELECT id FROM character_recipebook WHERE charId=? AND classIndex=? AND type = 1";
  3697. + String sql = loadCommon ? "SELECT id, type, classIndex FROM character_recipebook WHERE charId=?" : "SELECT id FROM character_recipebook WHERE charId=? AND classIndex=? AND type = 1";
  3698. PreparedStatement statement = con.prepareStatement(sql);
  3699. statement.setInt(1, getObjectId());
  3700. if (!loadCommon)
  3701. @@ -7450,7 +7504,8 @@
  3702. _dwarvenRecipeBook.clear();
  3703.  
  3704. L2RecipeList recipe;
  3705. - while (rset.next()) {
  3706. + while (rset.next())
  3707. + {
  3708. recipe = RecipeController.getInstance().getRecipeList(rset.getInt("id"));
  3709.  
  3710. if (loadCommon)
  3711. @@ -7508,7 +7563,7 @@
  3712. }
  3713. catch (Exception e)
  3714. {
  3715. - _log.log(Level.SEVERE, "Could not restore premium items: "+ e.getMessage(), e);
  3716. + _log.log(Level.SEVERE, "Could not restore premium items: " + e.getMessage(), e);
  3717. }
  3718. finally
  3719. {
  3720. @@ -7531,7 +7586,7 @@
  3721. }
  3722. catch (Exception e)
  3723. {
  3724. - _log.log(Level.SEVERE, "Could not update premium items: "+ e.getMessage(), e);
  3725. + _log.log(Level.SEVERE, "Could not update premium items: " + e.getMessage(), e);
  3726. }
  3727. finally
  3728. {
  3729. @@ -7574,7 +7629,7 @@
  3730. storeCharSub();
  3731. storeEffect(storeActiveEffects);
  3732. transformInsertInfo();
  3733. - if(Config.STORE_RECIPE_SHOPLIST)
  3734. + if (Config.STORE_RECIPE_SHOPLIST)
  3735. storeRecipeShopList();
  3736. if (Config.STORE_UI_SETTINGS)
  3737. storeUISettings();
  3738. @@ -7596,9 +7651,9 @@
  3739. // Get the exp, level, and sp of base class to store in base table
  3740. int currentClassIndex = getClassIndex();
  3741. _classIndex = 0;
  3742. - long exp = getStat().getExp();
  3743. - int level = getStat().getLevel();
  3744. - int sp = getStat().getSp();
  3745. + long exp = getStat().getExp();
  3746. + int level = getStat().getLevel();
  3747. + int sp = getStat().getSp();
  3748. _classIndex = currentClassIndex;
  3749.  
  3750. con = L2DatabaseFactory.getInstance().getConnection();
  3751. @@ -7615,7 +7670,7 @@
  3752. statement.setInt(8, getAppearance().getFace());
  3753. statement.setInt(9, getAppearance().getHairStyle());
  3754. statement.setInt(10, getAppearance().getHairColor());
  3755. - statement.setInt(11, getAppearance().getSex()? 1 : 0);
  3756. + statement.setInt(11, getAppearance().getSex() ? 1 : 0);
  3757. statement.setInt(12, getHeading());
  3758. statement.setInt(13, _observerMode ? _lastX : getX());
  3759. statement.setInt(14, _observerMode ? _lastY : getY());
  3760. @@ -7643,7 +7698,7 @@
  3761. long totalOnlineTime = _onlineTime;
  3762.  
  3763. if (_onlineBeginTime > 0)
  3764. - totalOnlineTime += (System.currentTimeMillis()-_onlineBeginTime)/1000;
  3765. + totalOnlineTime += (System.currentTimeMillis() - _onlineBeginTime) / 1000;
  3766.  
  3767. statement.setLong(35, totalOnlineTime);
  3768. statement.setInt(36, getPunishLevel().value());
  3769. @@ -7652,9 +7707,9 @@
  3770. statement.setInt(39, isNoble() ? 1 : 0);
  3771. statement.setLong(40, getPowerGrade());
  3772. statement.setInt(41, getPledgeType());
  3773. - statement.setInt(42,getLvlJoinedAcademy());
  3774. - statement.setLong(43,getApprentice());
  3775. - statement.setLong(44,getSponsor());
  3776. + statement.setInt(42, getLvlJoinedAcademy());
  3777. + statement.setLong(43, getApprentice());
  3778. + statement.setLong(44, getSponsor());
  3779. statement.setInt(45, getAllianceWithVarkaKetra());
  3780. statement.setLong(46, getClanJoinExpiryTime());
  3781. statement.setLong(47, getClanCreateExpiryTime());
  3782. @@ -7670,7 +7725,7 @@
  3783. }
  3784. catch (Exception e)
  3785. {
  3786. - _log.log(Level.WARNING, "Could not store char base data: "+this+" - " + e.getMessage(), e);
  3787. + _log.log(Level.WARNING, "Could not store char base data: " + this + " - " + e.getMessage(), e);
  3788. }
  3789. finally
  3790. {
  3791. @@ -7723,7 +7778,6 @@
  3792. {
  3793. con = L2DatabaseFactory.getInstance().getConnection();
  3794.  
  3795. -
  3796. // Delete all current stored effects for char to avoid dupe
  3797. PreparedStatement statement = con.prepareStatement(DELETE_SKILL_SAVE);
  3798.  
  3799. @@ -7762,8 +7816,7 @@
  3800.  
  3801. storedSkills.add(skill.getReuseHashCode());
  3802.  
  3803. - if (!effect.isHerbEffect() && effect.getInUse()
  3804. - && !skill.isToggle())
  3805. + if (!effect.isHerbEffect() && effect.getInUse() && !skill.isToggle())
  3806. {
  3807.  
  3808. statement.setInt(1, getObjectId());
  3809. @@ -8045,8 +8098,7 @@
  3810. {
  3811. if (!SkillTreesData.getInstance().isSkillAllowed(this, skill))
  3812. {
  3813. - Util.handleIllegalPlayerAction(this, "Player " + getName() + " has invalid skill " + skill.getName() +
  3814. - " ("+skill.getId() + "/" + skill.getLevel() + "), class:" + getTemplate().className, 1);
  3815. + Util.handleIllegalPlayerAction(this, "Player " + getName() + " has invalid skill " + skill.getName() + " (" + skill.getId() + "/" + skill.getLevel() + "), class:" + getTemplate().className, 1);
  3816. if (Config.SKILL_CHECK_REMOVE)
  3817. removeSkill(skill);
  3818. }
  3819. @@ -8150,7 +8202,7 @@
  3820. }
  3821. catch (Exception e)
  3822. {
  3823. - _log.log(Level.WARNING, "Could not restore "+this+" active effect data: " + e.getMessage(), e);
  3824. + _log.log(Level.WARNING, "Could not restore " + this + " active effect data: " + e.getMessage(), e);
  3825. }
  3826. finally
  3827. {
  3828. @@ -8173,14 +8225,14 @@
  3829. statement.setInt(2, getClassIndex());
  3830. ResultSet rset = statement.executeQuery();
  3831.  
  3832. - for (int i=0;i<3;i++)
  3833. - _henna[i]=null;
  3834. + for (int i = 0; i < 3; i++)
  3835. + _henna[i] = null;
  3836.  
  3837. while (rset.next())
  3838. {
  3839. int slot = rset.getInt("slot");
  3840.  
  3841. - if (slot<1 || slot>3)
  3842. + if (slot < 1 || slot > 3)
  3843. continue;
  3844.  
  3845. int symbol_id = rset.getInt("symbol_id");
  3846. @@ -8194,7 +8246,7 @@
  3847. if (tpl != null)
  3848. {
  3849. sym = new L2HennaInstance(tpl);
  3850. - _henna[slot-1] = sym;
  3851. + _henna[slot - 1] = sym;
  3852. }
  3853. }
  3854. }
  3855. @@ -8204,7 +8256,7 @@
  3856. }
  3857. catch (Exception e)
  3858. {
  3859. - _log.log(Level.SEVERE, "Failed restoing character "+this+" hennas.", e);
  3860. + _log.log(Level.SEVERE, "Failed restoing character " + this + " hennas.", e);
  3861. }
  3862. finally
  3863. {
  3864. @@ -8262,7 +8314,7 @@
  3865. PreparedStatement statement = con.prepareStatement(DELETE_CHAR_HENNA);
  3866.  
  3867. statement.setInt(1, getObjectId());
  3868. - statement.setInt(2, slot+1);
  3869. + statement.setInt(2, slot + 1);
  3870. statement.setInt(3, getClassIndex());
  3871.  
  3872. statement.execute();
  3873. @@ -8324,7 +8376,7 @@
  3874.  
  3875. statement.setInt(1, getObjectId());
  3876. statement.setInt(2, henna.getSymbolId());
  3877. - statement.setInt(3, i+1);
  3878. + statement.setInt(3, i + 1);
  3879. statement.setInt(4, getClassIndex());
  3880.  
  3881. statement.execute();
  3882. @@ -8364,9 +8416,10 @@
  3883. _hennaWIT = 0;
  3884. _hennaDEX = 0;
  3885.  
  3886. - for (int i=0;i<3;i++)
  3887. + for (int i = 0; i < 3; i++)
  3888. {
  3889. - if (_henna[i]==null)continue;
  3890. + if (_henna[i] == null)
  3891. + continue;
  3892. _hennaINT += _henna[i].getStatINT();
  3893. _hennaSTR += _henna[i].getStatSTR();
  3894. _hennaMEN += _henna[i].getStatMEM();
  3895. @@ -8375,12 +8428,18 @@
  3896. _hennaDEX += _henna[i].getStatDEX();
  3897. }
  3898.  
  3899. - if (_hennaINT>5)_hennaINT=5;
  3900. - if (_hennaSTR>5)_hennaSTR=5;
  3901. - if (_hennaMEN>5)_hennaMEN=5;
  3902. - if (_hennaCON>5)_hennaCON=5;
  3903. - if (_hennaWIT>5)_hennaWIT=5;
  3904. - if (_hennaDEX>5)_hennaDEX=5;
  3905. + if (_hennaINT > 5)
  3906. + _hennaINT = 5;
  3907. + if (_hennaSTR > 5)
  3908. + _hennaSTR = 5;
  3909. + if (_hennaMEN > 5)
  3910. + _hennaMEN = 5;
  3911. + if (_hennaCON > 5)
  3912. + _hennaCON = 5;
  3913. + if (_hennaWIT > 5)
  3914. + _hennaWIT = 5;
  3915. + if (_hennaDEX > 5)
  3916. + _hennaDEX = 5;
  3917. }
  3918.  
  3919. /**
  3920. @@ -8470,8 +8529,9 @@
  3921. return false;
  3922.  
  3923. // Check if the attacker is in olympia and olympia start
  3924. - if (attacker instanceof L2PcInstance && ((L2PcInstance)attacker).isInOlympiadMode() ){
  3925. - if (isInOlympiadMode() && isOlympiadStart() && ((L2PcInstance)attacker).getOlympiadGameId()==getOlympiadGameId())
  3926. + if (attacker instanceof L2PcInstance && ((L2PcInstance) attacker).isInOlympiadMode())
  3927. + {
  3928. + if (isInOlympiadMode() && isOlympiadStart() && ((L2PcInstance) attacker).getOlympiadGameId() == getOlympiadGameId())
  3929. return true;
  3930. else
  3931. return false;
  3932. @@ -8485,7 +8545,7 @@
  3933. if (getClan() != null && attacker != null && getClan().isMember(attacker.getObjectId()))
  3934. return false;
  3935.  
  3936. - if(attacker instanceof L2Playable && isInsideZone(ZONE_PEACE))
  3937. + if (attacker instanceof L2Playable && isInsideZone(ZONE_PEACE))
  3938. return false;
  3939.  
  3940. // Check if the L2PcInstance has Karma
  3941. @@ -8499,8 +8559,7 @@
  3942. L2PcInstance cha = attacker.getActingPlayer();
  3943.  
  3944. // is AutoAttackable if both players are in the same duel and the duel is still going on
  3945. - if ( getDuelState() == Duel.DUELSTATE_DUELLING
  3946. - && getDuelId() == cha.getDuelId())
  3947. + if (getDuelState() == Duel.DUELSTATE_DUELLING && getDuelId() == cha.getDuelId())
  3948. return true;
  3949. // Check if the L2PcInstance is in an arena or a siege area
  3950. if (isInsideZone(ZONE_PVP) && cha.isInsideZone(ZONE_PVP))
  3951. @@ -8512,23 +8571,16 @@
  3952. if (siege != null)
  3953. {
  3954. // Check if a siege is in progress and if attacker and the L2PcInstance aren't in the Defender clan
  3955. - if (siege.checkIsDefender(cha.getClan()) &&
  3956. - siege.checkIsDefender(getClan()))
  3957. + if (siege.checkIsDefender(cha.getClan()) && siege.checkIsDefender(getClan()))
  3958. return false;
  3959.  
  3960. // Check if a siege is in progress and if attacker and the L2PcInstance aren't in the Attacker clan
  3961. - if (siege.checkIsAttacker(cha.getClan()) &&
  3962. - siege.checkIsAttacker(getClan()))
  3963. + if (siege.checkIsAttacker(cha.getClan()) && siege.checkIsAttacker(getClan()))
  3964. return false;
  3965. }
  3966.  
  3967. // Check if clan is at war
  3968. - if (getClan() != null && cha.getClan() != null
  3969. - && getClan().isAtWarWith(cha.getClanId())
  3970. - && cha.getClan().isAtWarWith(getClanId())
  3971. - && getWantsPeace() == 0
  3972. - && cha.getWantsPeace() == 0
  3973. - && !isAcademyMember())
  3974. + if (getClan() != null && cha.getClan() != null && getClan().isAtWarWith(cha.getClanId()) && cha.getClan().isAtWarWith(getClanId()) && getWantsPeace() == 0 && cha.getWantsPeace() == 0 && !isAcademyMember())
  3975. return true;
  3976. }
  3977. }
  3978. @@ -8544,7 +8596,6 @@
  3979. return false;
  3980. }
  3981.  
  3982. -
  3983. /**
  3984. * Check if the active L2Skill can be casted.<BR><BR>
  3985. *
  3986. @@ -8617,7 +8668,7 @@
  3987. L2Object target = null;
  3988. switch (skill.getTargetType())
  3989. {
  3990. - case TARGET_AURA: // AURA, SELF should be cast even if no target has been found
  3991. + case TARGET_AURA: // AURA, SELF should be cast even if no target has been found
  3992. case TARGET_FRONT_AURA:
  3993. case TARGET_BEHIND_AURA:
  3994. case TARGET_GROUND:
  3995. @@ -8626,7 +8677,7 @@
  3996. target = this;
  3997. break;
  3998. default:
  3999. -
  4000. +
  4001. // Get the first target of the list
  4002. target = skill.getFirstOfTargetList(this);
  4003. break;
  4004. @@ -8658,8 +8709,7 @@
  4005. return false;
  4006. }
  4007.  
  4008. - if (isFishing() && (sklType != L2SkillType.PUMPING &&
  4009. - sklType != L2SkillType.REELING && sklType != L2SkillType.FISHING))
  4010. + if (isFishing() && (sklType != L2SkillType.PUMPING && sklType != L2SkillType.REELING && sklType != L2SkillType.FISHING))
  4011. {
  4012. //Only fishing skills are available
  4013. sendPacket(SystemMessage.getSystemMessage(SystemMessageId.ONLY_FISHING_SKILLS_NOW));
  4014. @@ -8718,7 +8768,7 @@
  4015.  
  4016. if (sklTargetType == SkillTargetType.TARGET_GROUND && worldPosition == null)
  4017. {
  4018. - _log.info("WorldPosition is null for skill: "+skill.getName() + ", player: " + getName() + ".");
  4019. + _log.info("WorldPosition is null for skill: " + skill.getName() + ", player: " + getName() + ".");
  4020. sendPacket(ActionFailed.STATIC_PACKET);
  4021. return false;
  4022. }
  4023. @@ -8756,16 +8806,11 @@
  4024. }
  4025.  
  4026. // skills can be used on Walls and Doors only during siege
  4027. - if(target instanceof L2DoorInstance )
  4028. + if (target instanceof L2DoorInstance)
  4029. {
  4030. - boolean isCastle = (((L2DoorInstance) target).getCastle() != null
  4031. - && ((L2DoorInstance) target).getCastle().getCastleId() > 0
  4032. - && ((L2DoorInstance) target).getCastle().getSiege().getIsInProgress());
  4033. - boolean isFort = (((L2DoorInstance) target).getFort() != null
  4034. - && ((L2DoorInstance) target).getFort().getFortId() > 0
  4035. - && ((L2DoorInstance) target).getFort().getSiege().getIsInProgress()
  4036. - && !((L2DoorInstance) target).getIsCommanderDoor());
  4037. - if ((!isCastle && !isFort)&&(((L2DoorInstance) target).isUnlockable() && skill.getSkillType() != L2SkillType.UNLOCK))
  4038. + boolean isCastle = (((L2DoorInstance) target).getCastle() != null && ((L2DoorInstance) target).getCastle().getCastleId() > 0 && ((L2DoorInstance) target).getCastle().getSiege().getIsInProgress());
  4039. + boolean isFort = (((L2DoorInstance) target).getFort() != null && ((L2DoorInstance) target).getFort().getFortId() > 0 && ((L2DoorInstance) target).getFort().getSiege().getIsInProgress() && !((L2DoorInstance) target).getIsCommanderDoor());
  4040. + if ((!isCastle && !isFort) && (((L2DoorInstance) target).isUnlockable() && skill.getSkillType() != L2SkillType.UNLOCK))
  4041. return false;
  4042. }
  4043.  
  4044. @@ -8790,9 +8835,7 @@
  4045.  
  4046. // Check if it's ok to summon
  4047. // siege golem (13), Wild Hog Cannon (299), Swoop Cannon (448)
  4048. - if ((skill.getId() == 13 || skill.getId() == 299 || skill.getId() == 448)
  4049. - && ((!SiegeManager.getInstance().checkIfOkToSummon(this, false)
  4050. - && !FortSiegeManager.getInstance().checkIfOkToSummon(this, false))||(SevenSigns.getInstance().checkSummonConditions(this))))
  4051. + if ((skill.getId() == 13 || skill.getId() == 299 || skill.getId() == 448) && ((!SiegeManager.getInstance().checkIfOkToSummon(this, false) && !FortSiegeManager.getInstance().checkIfOkToSummon(this, false)) || (SevenSigns.getInstance().checkSummonConditions(this))))
  4052. return false;
  4053.  
  4054. // Check if this skill is enabled (ex : reuse time)
  4055. @@ -8802,10 +8845,10 @@
  4056.  
  4057. if (_reuseTimeStamps.containsKey(skill.getReuseHashCode()))
  4058. {
  4059. - int remainingTime = (int)(_reuseTimeStamps.get(skill.getReuseHashCode()).getRemaining()/1000);
  4060. - int hours = remainingTime/3600;
  4061. - int minutes = (remainingTime%3600)/60;
  4062. - int seconds = (remainingTime%60);
  4063. + int remainingTime = (int) (_reuseTimeStamps.get(skill.getReuseHashCode()).getRemaining() / 1000);
  4064. + int hours = remainingTime / 3600;
  4065. + int minutes = (remainingTime % 3600) / 60;
  4066. + int seconds = (remainingTime % 60);
  4067. if (hours > 0)
  4068. {
  4069. sm = SystemMessage.getSystemMessage(SystemMessageId.S2_HOURS_S3_MINUTES_S4_SECONDS_REMAINING_FOR_REUSE_S1);
  4070. @@ -8872,15 +8915,14 @@
  4071. return false;
  4072. }
  4073.  
  4074. - if (isInOlympiadMode() && !isOlympiadStart()){
  4075. + if (isInOlympiadMode() && !isOlympiadStart())
  4076. + {
  4077. // if L2PcInstance is in Olympia and the match isn't already start, send a Server->Client packet ActionFailed
  4078. sendPacket(ActionFailed.STATIC_PACKET);
  4079. return false;
  4080. }
  4081.  
  4082. - if (target.getActingPlayer() != null && getSiegeState() > 0 && isInsideZone(L2Character.ZONE_SIEGE)
  4083. - && target.getActingPlayer().getSiegeState() == getSiegeState()
  4084. - && target.getActingPlayer() != this && target.getActingPlayer().getSiegeSide() == getSiegeSide())
  4085. + if (target.getActingPlayer() != null && getSiegeState() > 0 && isInsideZone(L2Character.ZONE_SIEGE) && target.getActingPlayer().getSiegeState() == getSiegeState() && target.getActingPlayer() != this && target.getActingPlayer().getSiegeSide() == getSiegeSide())
  4086. {
  4087. //
  4088. if (TerritoryWarManager.getInstance().isTWInProgress())
  4089. @@ -8899,7 +8941,7 @@
  4090. return false;
  4091. }
  4092. // Check for Event Mob's
  4093. - if (target instanceof L2EventMonsterInstance && ((L2EventMonsterInstance)target).eventSkillAttackBlocked())
  4094. + if (target instanceof L2EventMonsterInstance && ((L2EventMonsterInstance) target).eventSkillAttackBlocked())
  4095. {
  4096. sendPacket(ActionFailed.STATIC_PACKET);
  4097. return false;
  4098. @@ -8934,7 +8976,7 @@
  4099. // Calculate the distance between the L2PcInstance and the target
  4100. if (sklTargetType == SkillTargetType.TARGET_GROUND)
  4101. {
  4102. - if (!isInsideRadius(worldPosition.getX(), worldPosition.getY(), worldPosition.getZ(), skill.getCastRange()+getTemplate().collisionRadius, false, false))
  4103. + if (!isInsideRadius(worldPosition.getX(), worldPosition.getY(), worldPosition.getZ(), skill.getCastRange() + getTemplate().collisionRadius, false, false))
  4104. {
  4105. // Send a System Message to the caster
  4106. sendPacket(SystemMessage.getSystemMessage(SystemMessageId.TARGET_TOO_FAR));
  4107. @@ -8944,7 +8986,7 @@
  4108. return false;
  4109. }
  4110. }
  4111. - else if (skill.getCastRange() > 0 && !isInsideRadius(target, skill.getCastRange()+getTemplate().collisionRadius, false, false))
  4112. + else if (skill.getCastRange() > 0 && !isInsideRadius(target, skill.getCastRange() + getTemplate().collisionRadius, false, false))
  4113. {
  4114. // Send a System Message to the caster
  4115. sendPacket(SystemMessage.getSystemMessage(SystemMessageId.TARGET_TOO_FAR));
  4116. @@ -8956,10 +8998,10 @@
  4117. }
  4118. }
  4119.  
  4120. - if(skill.getSkillType() == L2SkillType.INSTANT_JUMP)
  4121. + if (skill.getSkillType() == L2SkillType.INSTANT_JUMP)
  4122. {
  4123. // You cannot jump while rooted right ;)
  4124. - if(isMovementDisabled())
  4125. + if (isMovementDisabled())
  4126. {
  4127. // Sends message that skill cannot be used...
  4128. SystemMessage sm = SystemMessage.getSystemMessage(SystemMessageId.S1_CANNOT_BE_USED);
  4129. @@ -8972,7 +9014,7 @@
  4130. return false;
  4131. }
  4132. // And this skill cannot be used in peace zone, not even on NPCs!
  4133. - if(this.isInsideZone(L2Character.ZONE_PEACE))
  4134. + if (this.isInsideZone(L2Character.ZONE_PEACE))
  4135. {
  4136. //Sends a sys msg to client
  4137. sendPacket(SystemMessage.getSystemMessage(SystemMessageId.TARGET_IN_PEACEZONE));
  4138. @@ -9054,9 +9096,9 @@
  4139. switch (sklTargetType)
  4140. {
  4141. case TARGET_PARTY:
  4142. - case TARGET_ALLY: // For such skills, checkPvpSkill() is called from L2Skill.getTargetList()
  4143. - case TARGET_CLAN: // For such skills, checkPvpSkill() is called from L2Skill.getTargetList()
  4144. - case TARGET_PARTY_CLAN: // For such skills, checkPvpSkill() is called from L2Skill.getTargetList()
  4145. + case TARGET_ALLY: // For such skills, checkPvpSkill() is called from L2Skill.getTargetList()
  4146. + case TARGET_CLAN: // For such skills, checkPvpSkill() is called from L2Skill.getTargetList()
  4147. + case TARGET_PARTY_CLAN: // For such skills, checkPvpSkill() is called from L2Skill.getTargetList()
  4148. case TARGET_AURA:
  4149. case TARGET_FRONT_AURA:
  4150. case TARGET_BEHIND_AURA:
  4151. @@ -9076,11 +9118,7 @@
  4152. }
  4153.  
  4154. // TODO: Unhardcode skillId 844 which is the outpost construct skill
  4155. - if ((sklTargetType == SkillTargetType.TARGET_HOLY && !checkIfOkToCastSealOfRule(CastleManager.getInstance().getCastle(this), false, skill))
  4156. - || (sklTargetType == SkillTargetType.TARGET_FLAGPOLE && !checkIfOkToCastFlagDisplay(FortManager.getInstance().getFort(this), false, skill))
  4157. - || (sklType == L2SkillType.SIEGEFLAG && !L2SkillSiegeFlag.checkIfOkToPlaceFlag(this, false, skill.getId() == 844))
  4158. - || (sklType == L2SkillType.STRSIEGEASSAULT && !checkIfOkToUseStriderSiegeAssault())
  4159. - || (sklType == L2SkillType.SUMMON_FRIEND && !(checkSummonerStatus(this) && checkSummonTargetStatus(target, this))))
  4160. + if ((sklTargetType == SkillTargetType.TARGET_HOLY && !checkIfOkToCastSealOfRule(CastleManager.getInstance().getCastle(this), false, skill)) || (sklTargetType == SkillTargetType.TARGET_FLAGPOLE && !checkIfOkToCastFlagDisplay(FortManager.getInstance().getFort(this), false, skill)) || (sklType == L2SkillType.SIEGEFLAG && !L2SkillSiegeFlag.checkIfOkToPlaceFlag(this, false, skill.getId() == 844)) || (sklType == L2SkillType.STRSIEGEASSAULT && !checkIfOkToUseStriderSiegeAssault()) || (sklType == L2SkillType.SUMMON_FRIEND && !(checkSummonerStatus(this) && checkSummonTargetStatus(target, this))))
  4161. {
  4162. sendPacket(ActionFailed.STATIC_PACKET);
  4163. abortCast();
  4164. @@ -9206,7 +9244,7 @@
  4165. return false;
  4166. }
  4167.  
  4168. - public boolean checkIfOkToCastFlagDisplay(Fort fort, boolean isCheckOnly,L2Skill skill)
  4169. + public boolean checkIfOkToCastFlagDisplay(Fort fort, boolean isCheckOnly, L2Skill skill)
  4170. {
  4171. SystemMessage sm;
  4172.  
  4173. @@ -9236,7 +9274,7 @@
  4174. else
  4175. {
  4176. if (!isCheckOnly)
  4177. - fort.getSiege().announceToPlayer(SystemMessage.getSystemMessage(SystemMessageId.S1_TRYING_RAISE_FLAG),getClan().getName());
  4178. + fort.getSiege().announceToPlayer(SystemMessage.getSystemMessage(SystemMessageId.S1_TRYING_RAISE_FLAG), getClan().getName());
  4179. return true;
  4180. }
  4181.  
  4182. @@ -9279,43 +9317,39 @@
  4183. public boolean checkPvpSkill(L2Object target, L2Skill skill, boolean srcIsSummon)
  4184. {
  4185. // check for PC->PC Pvp status
  4186. - if(target instanceof L2Summon)
  4187. + if (target instanceof L2Summon)
  4188. target = target.getActingPlayer();
  4189. - if (
  4190. - target != null && // target not null and
  4191. - target != this && // target is not self and
  4192. - target instanceof L2PcInstance && // target is L2PcInstance and
  4193. - !(isInDuel() && ((L2PcInstance)target).getDuelId() == getDuelId()) && // self is not in a duel and attacking opponent
  4194. - !isInsideZone(ZONE_PVP) && // Pc is not in PvP zone
  4195. - !((L2PcInstance)target).isInsideZone(ZONE_PVP) // target is not in PvP zone
  4196. + if (target != null && // target not null and
  4197. + target != this && // target is not self and
  4198. + target instanceof L2PcInstance && // target is L2PcInstance and
  4199. + !(isInDuel() && ((L2PcInstance) target).getDuelId() == getDuelId()) && // self is not in a duel and attacking opponent
  4200. + !isInsideZone(ZONE_PVP) && // Pc is not in PvP zone
  4201. + !((L2PcInstance) target).isInsideZone(ZONE_PVP) // target is not in PvP zone
  4202. )
  4203. {
  4204. SkillDat skilldat = getCurrentSkill();
  4205. SkillDat skilldatpet = getCurrentPetSkill();
  4206. - if(skill.isPvpSkill()) // pvp skill
  4207. + if (skill.isPvpSkill()) // pvp skill
  4208. {
  4209. - if(getClan() != null && ((L2PcInstance)target).getClan() != null)
  4210. + if (getClan() != null && ((L2PcInstance) target).getClan() != null)
  4211. {
  4212. - if(getClan().isAtWarWith(((L2PcInstance)target).getClan().getClanId()) && ((L2PcInstance)target).getClan().isAtWarWith(getClan().getClanId()))
  4213. + if (getClan().isAtWarWith(((L2PcInstance) target).getClan().getClanId()) && ((L2PcInstance) target).getClan().isAtWarWith(getClan().getClanId()))
  4214. return true; // in clan war player can attack whites even with sleep etc.
  4215. }
  4216. - if (
  4217. - ((L2PcInstance)target).getPvpFlag() == 0 && // target's pvp flag is not set and
  4218. - ((L2PcInstance)target).getKarma() == 0 // target has no karma
  4219. + if (((L2PcInstance) target).getPvpFlag() == 0 && // target's pvp flag is not set and
  4220. + ((L2PcInstance) target).getKarma() == 0 // target has no karma
  4221. )
  4222. return false;
  4223. }
  4224. - else if ((skilldat != null && !skilldat.isCtrlPressed() && skill.isOffensive() && !srcIsSummon)
  4225. - || (skilldatpet != null && !skilldatpet.isCtrlPressed() && skill.isOffensive() && srcIsSummon))
  4226. + else if ((skilldat != null && !skilldat.isCtrlPressed() && skill.isOffensive() && !srcIsSummon) || (skilldatpet != null && !skilldatpet.isCtrlPressed() && skill.isOffensive() && srcIsSummon))
  4227. {
  4228. - if(getClan() != null && ((L2PcInstance)target).getClan() != null)
  4229. + if (getClan() != null && ((L2PcInstance) target).getClan() != null)
  4230. {
  4231. - if(getClan().isAtWarWith(((L2PcInstance)target).getClan().getClanId()) && ((L2PcInstance)target).getClan().isAtWarWith(getClan().getClanId()))
  4232. + if (getClan().isAtWarWith(((L2PcInstance) target).getClan().getClanId()) && ((L2PcInstance) target).getClan().isAtWarWith(getClan().getClanId()))
  4233. return true; // in clan war player can attack whites even without ctrl
  4234. }
  4235. - if (
  4236. - ((L2PcInstance)target).getPvpFlag() == 0 && // target's pvp flag is not set and
  4237. - ((L2PcInstance)target).getKarma() == 0 // target has no karma
  4238. + if (((L2PcInstance) target).getPvpFlag() == 0 && // target's pvp flag is not set and
  4239. + ((L2PcInstance) target).getKarma() == 0 // target has no karma
  4240. )
  4241. return false;
  4242. }
  4243. @@ -9332,7 +9366,6 @@
  4244. return getClassId().isMage();
  4245. }
  4246.  
  4247. -
  4248. public boolean isMounted()
  4249. {
  4250. return _mountType > 0;
  4251. @@ -9347,13 +9380,11 @@
  4252. if (isInsideZone(ZONE_NOLANDING))
  4253. return true;
  4254. else
  4255. - // if this is a castle that is currently being sieged, and the rider is NOT a castle owner
  4256. - // he cannot land.
  4257. - // castle owner is the leader of the clan that owns the castle where the pc is
  4258. - if (isInsideZone(ZONE_SIEGE) && !(getClan()!= null &&
  4259. - CastleManager.getInstance().getCastle(this) == CastleManager.getInstance().getCastleByOwner(getClan()) &&
  4260. - this == getClan().getLeader().getPlayerInstance()))
  4261. - return true;
  4262. + // if this is a castle that is currently being sieged, and the rider is NOT a castle owner
  4263. + // he cannot land.
  4264. + // castle owner is the leader of the clan that owns the castle where the pc is
  4265. + if (isInsideZone(ZONE_SIEGE) && !(getClan() != null && CastleManager.getInstance().getCastle(this) == CastleManager.getInstance().getCastleByOwner(getClan()) && this == getClan().getLeader().getPlayerInstance()))
  4266. + return true;
  4267.  
  4268. return false;
  4269. }
  4270. @@ -9361,7 +9392,7 @@
  4271. // returns false if the change of mount type fails.
  4272. public boolean setMount(int npcId, int npcLevel, int mountType)
  4273. {
  4274. - switch(mountType)
  4275. + switch (mountType)
  4276. {
  4277. case 0:
  4278. setIsFlying(false);
  4279. @@ -9373,7 +9404,7 @@
  4280. break; //Dismounted
  4281. case 1:
  4282. setIsRidingStrider(true);
  4283. - if(isNoble())
  4284. + if (isNoble())
  4285. {
  4286. L2Skill striderAssaultSkill = SkillTable.FrequentSkill.STRIDER_SIEGE_ASSAULT.getSkill();
  4287. addSkill(striderAssaultSkill, false); // not saved to DB
  4288. @@ -9497,7 +9528,7 @@
  4289. */
  4290. public void tempInventoryDisable()
  4291. {
  4292. - _inventoryDisable = true;
  4293. + _inventoryDisable = true;
  4294.  
  4295. ThreadPoolManager.getInstance().scheduleGeneral(new InventoryEnable(), 1500);
  4296. }
  4297. @@ -9624,15 +9655,30 @@
  4298. {
  4299. if (!summon)
  4300. {
  4301. - switch(itemId)
  4302. + switch (itemId)
  4303. {
  4304. - case 2509: case 2510: case 2511: case 2512:
  4305. - case 2513: case 2514: case 3947:
  4306. - case 3948: case 3949: case 3950:
  4307. - case 3951: case 3952: case 5790:
  4308. - case 22072: case 22073: case 22074:
  4309. - case 22075: case 22076: case 22077:
  4310. - case 22078: case 22079: case 22080:
  4311. + case 2509:
  4312. + case 2510:
  4313. + case 2511:
  4314. + case 2512:
  4315. + case 2513:
  4316. + case 2514:
  4317. + case 3947:
  4318. + case 3948:
  4319. + case 3949:
  4320. + case 3950:
  4321. + case 3951:
  4322. + case 3952:
  4323. + case 5790:
  4324. + case 22072:
  4325. + case 22073:
  4326. + case 22074:
  4327. + case 22075:
  4328. + case 22076:
  4329. + case 22077:
  4330. + case 22078:
  4331. + case 22079:
  4332. + case 22080:
  4333. case 22081:
  4334. handler = ItemHandler.getInstance().getItemHandler(item.getEtcItem());
  4335.  
  4336. @@ -9644,10 +9690,12 @@
  4337. }
  4338. else
  4339. {
  4340. - switch(itemId)
  4341. + switch (itemId)
  4342. {
  4343. - case 6646: case 6647:
  4344. - case 20333: case 20334:
  4345. + case 6646:
  4346. + case 6647:
  4347. + case 20333:
  4348. + case 20334:
  4349. handler = ItemHandler.getInstance().getItemHandler(item.getEtcItem());
  4350.  
  4351. if (handler != null)
  4352. @@ -9661,13 +9709,21 @@
  4353. {
  4354. if (!summon)
  4355. {
  4356. - switch(itemId)
  4357. + switch (itemId)
  4358. {
  4359. - case 1463: case 1464: case 1465:
  4360. - case 1466: case 1467: case 1835:
  4361. - case 5789: case 22082: case 22083:
  4362. - case 22084: case 22085: case 22086:
  4363. -
  4364. + case 1463:
  4365. + case 1464:
  4366. + case 1465:
  4367. + case 1466:
  4368. + case 1467:
  4369. + case 1835:
  4370. + case 5789:
  4371. + case 22082:
  4372. + case 22083:
  4373. + case 22084:
  4374. + case 22085:
  4375. + case 22086:
  4376. +
  4377. handler = ItemHandler.getInstance().getItemHandler(item.getEtcItem());
  4378.  
  4379. if (handler != null)
  4380. @@ -9696,7 +9752,7 @@
  4381. }
  4382. catch (NullPointerException npe)
  4383. {
  4384. - _log.log(Level.WARNING, toString() , npe);
  4385. + _log.log(Level.WARNING, toString(), npe);
  4386. }
  4387. }
  4388.  
  4389. @@ -9732,7 +9788,8 @@
  4390. sendPacket(sm);
  4391. return true;
  4392. }
  4393. - else return false;
  4394. + else
  4395. + return false;
  4396. }
  4397.  
  4398. /**
  4399. @@ -9781,15 +9838,15 @@
  4400. @Override
  4401. public void run()
  4402. {
  4403. - double reduceHp = getMaxHp()/100.0;
  4404. + double reduceHp = getMaxHp() / 100.0;
  4405.  
  4406. if (reduceHp < 1)
  4407. reduceHp = 1;
  4408.  
  4409. - reduceCurrentHp(reduceHp,L2PcInstance.this,false, false, null);
  4410. + reduceCurrentHp(reduceHp, L2PcInstance.this, false, false, null);
  4411. //reduced hp, becouse not rest
  4412. SystemMessage sm = SystemMessage.getSystemMessage(SystemMessageId.DROWN_DAMAGE_S1);
  4413. - sm.addNumber((int)reduceHp);
  4414. + sm.addNumber((int) reduceHp);
  4415. sendPacket(sm);
  4416.  
  4417. }
  4418. @@ -9813,14 +9870,15 @@
  4419. @Override
  4420. public void run()
  4421. {
  4422. - if (System.currentTimeMillis() >= _endTaskTime) {
  4423. + if (System.currentTimeMillis() >= _endTaskTime)
  4424. + {
  4425. endFishing(false);
  4426. return;
  4427. }
  4428. if (_fishType == -1)
  4429. return;
  4430. int check = Rnd.get(1000);
  4431. - if(_fishGutsCheck > check)
  4432. + if (_fishGutsCheck > check)
  4433. {
  4434. stopLookingForFishTask();
  4435. startFishCombat(_isNoob, _isUpperGrade);
  4436. @@ -10153,7 +10211,8 @@
  4437. _OlympiadStart = b;
  4438. }
  4439.  
  4440. - public boolean isOlympiadStart(){
  4441. + public boolean isOlympiadStart()
  4442. + {
  4443. return _OlympiadStart;
  4444. }
  4445.  
  4446. @@ -10232,14 +10291,46 @@
  4447. */
  4448. public boolean canDuel()
  4449. {
  4450. - if (isInCombat() || getPunishLevel() == PunishLevel.JAIL) { _noDuelReason = SystemMessageId.C1_CANNOT_DUEL_BECAUSE_C1_IS_CURRENTLY_ENGAGED_IN_BATTLE; return false; }
  4451. - if (isDead() || isAlikeDead() || (getCurrentHp() < getMaxHp()/2 || getCurrentMp() < getMaxMp()/2)) { _noDuelReason = SystemMessageId.C1_CANNOT_DUEL_BECAUSE_C1_HP_OR_MP_IS_BELOW_50_PERCENT; return false; }
  4452. - if (isInDuel()) { _noDuelReason = SystemMessageId.C1_CANNOT_DUEL_BECAUSE_C1_IS_ALREADY_ENGAGED_IN_A_DUEL; return false;}
  4453. - if (isInOlympiadMode()) { _noDuelReason = SystemMessageId.C1_CANNOT_DUEL_BECAUSE_C1_IS_PARTICIPATING_IN_THE_OLYMPIAD; return false; }
  4454. - if (isCursedWeaponEquipped()) { _noDuelReason = SystemMessageId.C1_CANNOT_DUEL_BECAUSE_C1_IS_IN_A_CHAOTIC_STATE; return false; }
  4455. - if (getPrivateStoreType() != STORE_PRIVATE_NONE) { _noDuelReason = SystemMessageId.C1_CANNOT_DUEL_BECAUSE_C1_IS_CURRENTLY_ENGAGED_IN_A_PRIVATE_STORE_OR_MANUFACTURE; return false; }
  4456. - if (isMounted() || isInBoat()) { _noDuelReason = SystemMessageId.C1_CANNOT_DUEL_BECAUSE_C1_IS_CURRENTLY_RIDING_A_BOAT_WYVERN_OR_STRIDER; return false; }
  4457. - if (isFishing()) { _noDuelReason = SystemMessageId.C1_CANNOT_DUEL_BECAUSE_C1_IS_CURRENTLY_FISHING; return false; }
  4458. + if (isInCombat() || getPunishLevel() == PunishLevel.JAIL)
  4459. + {
  4460. + _noDuelReason = SystemMessageId.C1_CANNOT_DUEL_BECAUSE_C1_IS_CURRENTLY_ENGAGED_IN_BATTLE;
  4461. + return false;
  4462. + }
  4463. + if (isDead() || isAlikeDead() || (getCurrentHp() < getMaxHp() / 2 || getCurrentMp() < getMaxMp() / 2))
  4464. + {
  4465. + _noDuelReason = SystemMessageId.C1_CANNOT_DUEL_BECAUSE_C1_HP_OR_MP_IS_BELOW_50_PERCENT;
  4466. + return false;
  4467. + }
  4468. + if (isInDuel())
  4469. + {
  4470. + _noDuelReason = SystemMessageId.C1_CANNOT_DUEL_BECAUSE_C1_IS_ALREADY_ENGAGED_IN_A_DUEL;
  4471. + return false;
  4472. + }
  4473. + if (isInOlympiadMode())
  4474. + {
  4475. + _noDuelReason = SystemMessageId.C1_CANNOT_DUEL_BECAUSE_C1_IS_PARTICIPATING_IN_THE_OLYMPIAD;
  4476. + return false;
  4477. + }
  4478. + if (isCursedWeaponEquipped())
  4479. + {
  4480. + _noDuelReason = SystemMessageId.C1_CANNOT_DUEL_BECAUSE_C1_IS_IN_A_CHAOTIC_STATE;
  4481. + return false;
  4482. + }
  4483. + if (getPrivateStoreType() != STORE_PRIVATE_NONE)
  4484. + {
  4485. + _noDuelReason = SystemMessageId.C1_CANNOT_DUEL_BECAUSE_C1_IS_CURRENTLY_ENGAGED_IN_A_PRIVATE_STORE_OR_MANUFACTURE;
  4486. + return false;
  4487. + }
  4488. + if (isMounted() || isInBoat())
  4489. + {
  4490. + _noDuelReason = SystemMessageId.C1_CANNOT_DUEL_BECAUSE_C1_IS_CURRENTLY_RIDING_A_BOAT_WYVERN_OR_STRIDER;
  4491. + return false;
  4492. + }
  4493. + if (isFishing())
  4494. + {
  4495. + _noDuelReason = SystemMessageId.C1_CANNOT_DUEL_BECAUSE_C1_IS_CURRENTLY_FISHING;
  4496. + return false;
  4497. + }
  4498. if (isInsideZone(ZONE_PVP) || isInsideZone(ZONE_PEACE) || isInsideZone(ZONE_SIEGE))
  4499. {
  4500. _noDuelReason = SystemMessageId.C1_CANNOT_MAKE_A_CHALLANGE_TO_A_DUEL_BECAUSE_C1_IS_CURRENTLY_IN_A_DUEL_PROHIBITED_AREA;
  4501. @@ -10426,7 +10517,8 @@
  4502. statement.execute();
  4503. statement.close();
  4504. }
  4505. - catch (Exception e) {
  4506. + catch (Exception e)
  4507. + {
  4508. _log.log(Level.WARNING, "WARNING: Could not add character sub class for " + getName() + ": " + e.getMessage(), e);
  4509. return false;
  4510. }
  4511. @@ -10598,7 +10690,7 @@
  4512.  
  4513. if (t == null)
  4514. {
  4515. - _log.severe("Missing template for classId: "+classId);
  4516. + _log.severe("Missing template for classId: " + classId);
  4517. throw new Error();
  4518. }
  4519.  
  4520. @@ -10694,7 +10786,7 @@
  4521. * 8. Restore shortcut data related to this class.
  4522. * 9. Resend a class change animation effect to broadcast to all nearby players.
  4523. */
  4524. -
  4525. +
  4526. for (L2Skill oldSkill : getAllSkills())
  4527. super.removeSkill(oldSkill);
  4528.  
  4529. @@ -10784,10 +10876,10 @@
  4530. if (_taskRentPet != null)
  4531. {
  4532. // if the rent of a wyvern expires while over a flying zone, tp to down before unmounting
  4533. - if (checkLandingState() && getMountType()==2)
  4534. + if (checkLandingState() && getMountType() == 2)
  4535. teleToLocation(MapRegionTable.TeleportWhereType.Town);
  4536.  
  4537. - if (this.dismount()) // this should always be true now, since we teleported already
  4538. + if (this.dismount()) // this should always be true now, since we teleported already
  4539. {
  4540. _taskRentPet.cancel(true);
  4541. _taskRentPet = null;
  4542. @@ -10824,7 +10916,7 @@
  4543. {
  4544. if (!isDead() && _taskWater == null)
  4545. {
  4546. - int timeinwater = (int)calcStat(Stats.BREATH, 60000, this, null);
  4547. + int timeinwater = (int) calcStat(Stats.BREATH, 60000, this, null);
  4548.  
  4549. sendPacket(new SetupGauge(2, timeinwater));
  4550. _taskWater = ThreadPoolManager.getInstance().scheduleEffectAtFixedRate(new WaterTask(), timeinwater, 1000);
  4551. @@ -10894,7 +10986,7 @@
  4552. {
  4553. return _lastAccess;
  4554. }
  4555. -
  4556. +
  4557. @Override
  4558. public void doRevive()
  4559. {
  4560. @@ -10943,18 +11035,18 @@
  4561. }
  4562. return;
  4563. }
  4564. - if((Pet && getPet() != null && getPet().isDead()) || (!Pet && isDead()))
  4565. + if ((Pet && getPet() != null && getPet().isDead()) || (!Pet && isDead()))
  4566. {
  4567. _reviveRequested = 1;
  4568. int restoreExp = 0;
  4569. if (isPhoenixBlessed())
  4570. - _revivePower=100;
  4571. + _revivePower = 100;
  4572. else if (isAffected(CharEffectList.EFFECT_FLAG_CHARM_OF_COURAGE))
  4573. - _revivePower=0;
  4574. + _revivePower = 0;
  4575. else
  4576. _revivePower = Formulas.calculateSkillResurrectRestorePercent(skill.getPower(), Reviver);
  4577.  
  4578. - restoreExp = (int)Math.round((getExpBeforeDeath() - getExp()) * _revivePower / 100);
  4579. + restoreExp = (int) Math.round((getExpBeforeDeath() - getExp()) * _revivePower / 100);
  4580.  
  4581. _revivePet = Pet;
  4582.  
  4583. @@ -10969,6 +11061,8 @@
  4584. dlg.addPcName(Reviver);
  4585. dlg.addString(String.valueOf(restoreExp));
  4586. sendPacket(dlg);
  4587. + if (CharacterAchievementSystem.checkOk(this))
  4588. + this.getCAS().onResRequest();
  4589. }
  4590. }
  4591.  
  4592. @@ -11079,7 +11173,7 @@
  4593. // Trained beast is after teleport lost
  4594. if (getTrainedBeasts() != null)
  4595. {
  4596. - for(L2TamedBeastInstance tamedBeast : getTrainedBeasts())
  4597. + for (L2TamedBeastInstance tamedBeast : getTrainedBeasts())
  4598. tamedBeast.deleteMe();
  4599. getTrainedBeasts().clear();
  4600. }
  4601. @@ -11090,7 +11184,7 @@
  4602. {
  4603. pet.setFollowStatus(false);
  4604. pet.teleToLocation(getPosition().getX(), getPosition().getY(), getPosition().getZ(), false);
  4605. - ((L2SummonAI)pet.getAI()).setStartFollowController(true);
  4606. + ((L2SummonAI) pet.getAI()).setStartFollowController(true);
  4607. pet.setFollowStatus(true);
  4608. pet.updateAndBroadcastStatus(0);
  4609. }
  4610. @@ -11113,7 +11207,7 @@
  4611. {
  4612. if ((_teleportWatchdog == null) && (Config.TELEPORT_WATCHDOG_TIMEOUT > 0))
  4613. {
  4614. - synchronized(this)
  4615. + synchronized (this)
  4616. {
  4617. if (_teleportWatchdog == null)
  4618. _teleportWatchdog = ThreadPoolManager.getInstance().scheduleGeneral(new TeleportWatchdog(), Config.TELEPORT_WATCHDOG_TIMEOUT * 1000);
  4619. @@ -11154,7 +11248,7 @@
  4620.  
  4621. public void setLastServerPosition(int x, int y, int z)
  4622. {
  4623. - _lastServerPosition.setXYZ(x,y,z);
  4624. + _lastServerPosition.setXYZ(x, y, z);
  4625. }
  4626.  
  4627. public Point3D getLastServerPosition()
  4628. @@ -11164,7 +11258,7 @@
  4629.  
  4630. public boolean checkLastServerPosition(int x, int y, int z)
  4631. {
  4632. - return _lastServerPosition.equals(x,y,z);
  4633. + return _lastServerPosition.equals(x, y, z);
  4634. }
  4635.  
  4636. public int getLastServerDistance(int x, int y, int z)
  4637. @@ -11173,7 +11267,7 @@
  4638. double dy = (y - _lastServerPosition.getY());
  4639. double dz = (z - _lastServerPosition.getZ());
  4640.  
  4641. - return (int)Math.sqrt(dx*dx + dy*dy + dz*dz);
  4642. + return (int) Math.sqrt(dx * dx + dy * dy + dz * dz);
  4643. }
  4644.  
  4645. @Override
  4646. @@ -11204,18 +11298,18 @@
  4647. getStatus().reduceHp(value, attacker, awake, isDOT, skill.isToggle(), skill.getDmgDirectlyToHP());
  4648. else
  4649. getStatus().reduceHp(value, attacker, awake, isDOT, false, false);
  4650. -
  4651. +
  4652. // notify the tamed beast of attacks
  4653. - if (getTrainedBeasts() != null )
  4654. - for(L2TamedBeastInstance tamedBeast : getTrainedBeasts())
  4655. + if (getTrainedBeasts() != null)
  4656. + for (L2TamedBeastInstance tamedBeast : getTrainedBeasts())
  4657. tamedBeast.onOwnerGotAttacked(attacker);
  4658. }
  4659.  
  4660. public void broadcastSnoop(int type, String name, String _text)
  4661. {
  4662. - if(!_snoopListener.isEmpty())
  4663. + if (!_snoopListener.isEmpty())
  4664. {
  4665. - Snoop sn = new Snoop(getObjectId(),getName(),type,name,_text);
  4666. + Snoop sn = new Snoop(getObjectId(), getName(), type, name, _text);
  4667.  
  4668. for (L2PcInstance pci : _snoopListener)
  4669. if (pci != null)
  4670. @@ -11223,32 +11317,33 @@
  4671. }
  4672. }
  4673.  
  4674. - public void addSnooper(L2PcInstance pci )
  4675. + public void addSnooper(L2PcInstance pci)
  4676. {
  4677. - if(!_snoopListener.contains(pci))
  4678. + if (!_snoopListener.contains(pci))
  4679. _snoopListener.add(pci);
  4680. }
  4681.  
  4682. - public void removeSnooper(L2PcInstance pci )
  4683. + public void removeSnooper(L2PcInstance pci)
  4684. {
  4685. _snoopListener.remove(pci);
  4686. }
  4687.  
  4688. - public void addSnooped(L2PcInstance pci )
  4689. + public void addSnooped(L2PcInstance pci)
  4690. {
  4691. - if(!_snoopedPlayer.contains(pci))
  4692. + if (!_snoopedPlayer.contains(pci))
  4693. _snoopedPlayer.add(pci);
  4694. }
  4695.  
  4696. - public void removeSnooped(L2PcInstance pci )
  4697. + public void removeSnooped(L2PcInstance pci)
  4698. {
  4699. _snoopedPlayer.remove(pci);
  4700. }
  4701.  
  4702. public void addBypass(String bypass)
  4703. {
  4704. - if (bypass == null) return;
  4705. - synchronized(_validBypass)
  4706. + if (bypass == null)
  4707. + return;
  4708. + synchronized (_validBypass)
  4709. {
  4710. _validBypass.add(bypass);
  4711. }
  4712. @@ -11257,8 +11352,9 @@
  4713.  
  4714. public void addBypass2(String bypass)
  4715. {
  4716. - if (bypass == null) return;
  4717. - synchronized(_validBypass2)
  4718. + if (bypass == null)
  4719. + return;
  4720. + synchronized (_validBypass2)
  4721. {
  4722. _validBypass2.add(bypass);
  4723. }
  4724. @@ -11295,7 +11391,7 @@
  4725. return true;
  4726. }
  4727. }
  4728. - _log.warning("[L2PcInstance] player ["+getName()+"] sent invalid bypass '"+cmd+"'.");
  4729. + _log.warning("[L2PcInstance] player [" + getName() + "] sent invalid bypass '" + cmd + "'.");
  4730. return false;
  4731. }
  4732.  
  4733. @@ -11319,7 +11415,7 @@
  4734.  
  4735. if (item == null || item.getOwnerId() != getObjectId())
  4736. {
  4737. - _log.finest(getObjectId()+": player tried to " + action + " item he is not owner of");
  4738. + _log.finest(getObjectId() + ": player tried to " + action + " item he is not owner of");
  4739. return false;
  4740. }
  4741.  
  4742. @@ -11327,15 +11423,15 @@
  4743. if (getPet() != null && getPet().getControlObjectId() == objectId || getMountObjectID() == objectId)
  4744. {
  4745. if (Config.DEBUG)
  4746. - _log.finest(getObjectId()+": player tried to " + action + " item controling pet");
  4747. + _log.finest(getObjectId() + ": player tried to " + action + " item controling pet");
  4748.  
  4749. return false;
  4750. }
  4751.  
  4752. - if(getActiveEnchantItem() != null && getActiveEnchantItem().getObjectId() == objectId)
  4753. + if (getActiveEnchantItem() != null && getActiveEnchantItem().getObjectId() == objectId)
  4754. {
  4755. if (Config.DEBUG)
  4756. - _log.finest(getObjectId()+":player tried to " + action + " an enchant scroll he was using");
  4757. + _log.finest(getObjectId() + ":player tried to " + action + " an enchant scroll he was using");
  4758.  
  4759. return false;
  4760. }
  4761. @@ -11374,7 +11470,7 @@
  4762. */
  4763. public L2BoatInstance getBoat()
  4764. {
  4765. - return (L2BoatInstance)_vehicle;
  4766. + return (L2BoatInstance) _vehicle;
  4767. }
  4768.  
  4769. /**
  4770. @@ -11458,7 +11554,7 @@
  4771. try
  4772. {
  4773. if (!isOnline())
  4774. - _log.log(Level.SEVERE, "deleteMe() called on offline character "+this, new RuntimeException());
  4775. + _log.log(Level.SEVERE, "deleteMe() called on offline character " + this, new RuntimeException());
  4776. setOnlineStatus(false, true);
  4777. }
  4778. catch (Exception e)
  4779. @@ -11466,12 +11562,12 @@
  4780. _log.log(Level.SEVERE, "deleteMe()", e);
  4781. }
  4782.  
  4783. - try
  4784. - {
  4785. - if(Config.ENABLE_BLOCK_CHECKER_EVENT && getBlockCheckerArena() != -1)
  4786. + try
  4787. + {
  4788. + if (Config.ENABLE_BLOCK_CHECKER_EVENT && getBlockCheckerArena() != -1)
  4789. HandysBlockCheckerManager.getInstance().onDisconnect(this);
  4790. }
  4791. - catch(Exception e)
  4792. + catch (Exception e)
  4793. {
  4794. _log.log(Level.SEVERE, "deleteMe()", e);
  4795. }
  4796. @@ -11545,7 +11641,7 @@
  4797.  
  4798. try
  4799. {
  4800. - CommunityServerThread.getInstance().sendPacket(new WorldInfo(this, null,WorldInfo.TYPE_UPDATE_PLAYER_STATUS));
  4801. + CommunityServerThread.getInstance().sendPacket(new WorldInfo(this, null, WorldInfo.TYPE_UPDATE_PLAYER_STATUS));
  4802. }
  4803. catch (Exception e)
  4804. {
  4805. @@ -11778,6 +11874,9 @@
  4806. _log.log(Level.SEVERE, "deleteMe()", e);
  4807. }
  4808.  
  4809. + if (CharacterAchievementSystem.checkOk(this))
  4810. + getCAS().saveData();
  4811. +
  4812. // Update database with items in its inventory and remove them from the world
  4813. try
  4814. {
  4815. @@ -11800,15 +11899,14 @@
  4816. if (Config.WAREHOUSE_CACHE)
  4817. WarehouseCacheManager.getInstance().remCacheTask(this);
  4818.  
  4819. - try
  4820. - {
  4821. - getFreight().deleteMe();
  4822. - }
  4823. - catch (Exception e)
  4824. - {
  4825. - _log.log(Level.SEVERE, "deleteMe()", e);
  4826. - }
  4827. -
  4828. + try
  4829. + {
  4830. + getFreight().deleteMe();
  4831. + }
  4832. + catch (Exception e)
  4833. + {
  4834. + _log.log(Level.SEVERE, "deleteMe()", e);
  4835. + }
  4836.  
  4837. try
  4838. {
  4839. @@ -11915,10 +12013,11 @@
  4840. if (!GameTimeController.getInstance().isNowNight() && _lure.isNightLure())
  4841. _fish.setType(-1);
  4842. //sendMessage("Hook x,y: " + _x + "," + _y + " - Water Z, Player Z:" + _z + ", " + getZ()); //debug line, uncoment to show coordinates used in fishing.
  4843. - broadcastPacket(new ExFishingStart(this,_fish.getType(),_x,_y,_z,_lure.isNightLure()));
  4844. + broadcastPacket(new ExFishingStart(this, _fish.getType(), _x, _y, _z, _lure.isNightLure()));
  4845. sendPacket(new PlaySound(1, "SF_P_01", 0, 0, 0, 0, 0));
  4846. startLookingForFishTask();
  4847. }
  4848. +
  4849. public void stopLookingForFishTask()
  4850. {
  4851. if (_taskforfish != null)
  4852. @@ -11927,6 +12026,7 @@
  4853. _taskforfish = null;
  4854. }
  4855. }
  4856. +
  4857. public void startLookingForFishTask()
  4858. {
  4859. if (!isDead() && _taskforfish == null)
  4860. @@ -11941,11 +12041,11 @@
  4861. isNoob = _fish.getGroup() == 0;
  4862. isUpperGrade = _fish.getGroup() == 2;
  4863. if (lureid == 6519 || lureid == 6522 || lureid == 6525 || lureid == 8505 || lureid == 8508 || lureid == 8511) //low grade
  4864. - checkDelay = Math.round((float)(_fish.getGutsCheckTime() * (1.33)));
  4865. + checkDelay = Math.round((float) (_fish.getGutsCheckTime() * (1.33)));
  4866. else if (lureid == 6520 || lureid == 6523 || lureid == 6526 || (lureid >= 8505 && lureid <= 8513) || (lureid >= 7610 && lureid <= 7613) || (lureid >= 7807 && lureid <= 7809) || (lureid >= 8484 && lureid <= 8486)) //medium grade, beginner, prize-winning & quest special bait
  4867. - checkDelay = Math.round((float)(_fish.getGutsCheckTime() * (1.00)));
  4868. + checkDelay = Math.round((float) (_fish.getGutsCheckTime() * (1.00)));
  4869. else if (lureid == 6521 || lureid == 6524 || lureid == 6527 || lureid == 8507 || lureid == 8510 || lureid == 8513) //high grade
  4870. - checkDelay = Math.round((float)(_fish.getGutsCheckTime() * (0.66)));
  4871. + checkDelay = Math.round((float) (_fish.getGutsCheckTime() * (0.66)));
  4872. }
  4873. _taskforfish = ThreadPoolManager.getInstance().scheduleEffectAtFixedRate(new LookingForFishTask(_fish.getWaitTime(), _fish.getFishGuts(), _fish.getType(), isNoob, isUpperGrade), 10000, checkDelay);
  4874. }
  4875. @@ -11953,7 +12053,8 @@
  4876.  
  4877. private int GetRandomGroup()
  4878. {
  4879. - switch (_lure.getItemId()) {
  4880. + switch (_lure.getItemId())
  4881. + {
  4882. case 7807: //green for beginners
  4883. case 7808: //purple for beginners
  4884. case 7809: //yellow for beginners
  4885. @@ -11968,13 +12069,16 @@
  4886. return 1;
  4887. }
  4888. }
  4889. +
  4890. private int GetRandomFishType(int group)
  4891. {
  4892. int check = Rnd.get(100);
  4893. int type = 1;
  4894. - switch (group) {
  4895. - case 0: //fish for novices
  4896. - switch (_lure.getItemId()) {
  4897. + switch (group)
  4898. + {
  4899. + case 0: //fish for novices
  4900. + switch (_lure.getItemId())
  4901. + {
  4902. case 7807: //green lure, preferred by fast-moving (nimble) fish (type 5)
  4903. if (check <= 54)
  4904. type = 5;
  4905. @@ -11999,7 +12103,7 @@
  4906. else
  4907. type = 4;
  4908. break;
  4909. - case 8486: //prize-winning fishing lure for beginners
  4910. + case 8486: //prize-winning fishing lure for beginners
  4911. if (check <= 33)
  4912. type = 4;
  4913. else if (check <= 66)
  4914. @@ -12009,15 +12113,16 @@
  4915. break;
  4916. }
  4917. break;
  4918. - case 1: //normal fish
  4919. - switch (_lure.getItemId()) {
  4920. + case 1: //normal fish
  4921. + switch (_lure.getItemId())
  4922. + {
  4923. case 7610:
  4924. case 7611:
  4925. case 7612:
  4926. case 7613:
  4927. type = 3;
  4928. break;
  4929. - case 6519: //all theese lures (green) are prefered by fast-moving (nimble) fish (type 1)
  4930. + case 6519: //all theese lures (green) are prefered by fast-moving (nimble) fish (type 1)
  4931. case 8505:
  4932. case 6520:
  4933. case 6521:
  4934. @@ -12031,7 +12136,7 @@
  4935. else
  4936. type = 3;
  4937. break;
  4938. - case 6522: //all theese lures (purple) are prefered by fat fish (type 0)
  4939. + case 6522: //all theese lures (purple) are prefered by fat fish (type 0)
  4940. case 8508:
  4941. case 6523:
  4942. case 6524:
  4943. @@ -12045,7 +12150,7 @@
  4944. else
  4945. type = 3;
  4946. break;
  4947. - case 6525: //all theese lures (yellow) are prefered by ugly fish (type 2)
  4948. + case 6525: //all theese lures (yellow) are prefered by ugly fish (type 2)
  4949. case 8511:
  4950. case 6526:
  4951. case 6527:
  4952. @@ -12059,7 +12164,7 @@
  4953. else
  4954. type = 3;
  4955. break;
  4956. - case 8484: //prize-winning fishing lure
  4957. + case 8484: //prize-winning fishing lure
  4958. if (check <= 33)
  4959. type = 0;
  4960. else if (check <= 66)
  4961. @@ -12069,8 +12174,9 @@
  4962. break;
  4963. }
  4964. break;
  4965. - case 2: //upper grade fish, luminous lure
  4966. - switch (_lure.getItemId()) {
  4967. + case 2: //upper grade fish, luminous lure
  4968. + switch (_lure.getItemId())
  4969. + {
  4970. case 8506: //green lure, preferred by fast-moving (nimble) fish (type 8)
  4971. if (check <= 54)
  4972. type = 8;
  4973. @@ -12107,13 +12213,15 @@
  4974. }
  4975. return type;
  4976. }
  4977. +
  4978. private int GetRandomFishLvl()
  4979. {
  4980. int skilllvl = getSkillLevel(1315);
  4981. final L2Effect e = getFirstEffect(2274);
  4982. if (e != null)
  4983. - skilllvl = (int)e.getSkill().getPower();
  4984. - if (skilllvl <= 0) return 1;
  4985. + skilllvl = (int) e.getSkill().getPower();
  4986. + if (skilllvl <= 0)
  4987. + return 1;
  4988. int randomlvl;
  4989. int check = Rnd.get(100);
  4990.  
  4991. @@ -12132,14 +12240,16 @@
  4992. else
  4993. {
  4994. randomlvl = skilllvl + 1;
  4995. - if (randomlvl > 27) randomlvl = 27;
  4996. + if (randomlvl > 27)
  4997. + randomlvl = 27;
  4998. }
  4999.  
  5000. return randomlvl;
  5001. }
  5002. +
  5003. public void startFishCombat(boolean isNoob, boolean isUpperGrade)
  5004. {
  5005. - _fishCombat = new L2Fishing (this, _fish, isNoob, isUpperGrade);
  5006. + _fishCombat = new L2Fishing(this, _fish, isNoob, isUpperGrade);
  5007. }
  5008.  
  5009. public void endFishing(boolean win)
  5010. @@ -12180,7 +12290,7 @@
  5011. return _fishz;
  5012. }
  5013.  
  5014. - public void setLure (L2ItemInstance lure)
  5015. + public void setLure(L2ItemInstance lure)
  5016. {
  5017. _lure = lure;
  5018. }
  5019. @@ -12199,7 +12309,7 @@
  5020. ivlim = Config.INVENTORY_MAXIMUM_DWARF;
  5021. else
  5022. ivlim = Config.INVENTORY_MAXIMUM_NO_DWARF;
  5023. - ivlim += (int)getStat().calcStat(Stats.INV_LIM, 0, null, null);
  5024. + ivlim += (int) getStat().calcStat(Stats.INV_LIM, 0, null, null);
  5025.  
  5026. return ivlim;
  5027. }
  5028. @@ -12212,7 +12322,7 @@
  5029. else
  5030. whlim = Config.WAREHOUSE_SLOTS_NO_DWARF;
  5031.  
  5032. - whlim += (int)getStat().calcStat(Stats.WH_LIM, 0, null, null);
  5033. + whlim += (int) getStat().calcStat(Stats.WH_LIM, 0, null, null);
  5034.  
  5035. return whlim;
  5036. }
  5037. @@ -12226,7 +12336,7 @@
  5038. else
  5039. pslim = Config.MAX_PVTSTORESELL_SLOTS_OTHER;
  5040.  
  5041. - pslim += (int)getStat().calcStat(Stats.P_SELL_LIM, 0, null, null);
  5042. + pslim += (int) getStat().calcStat(Stats.P_SELL_LIM, 0, null, null);
  5043.  
  5044. return pslim;
  5045. }
  5046. @@ -12239,7 +12349,7 @@
  5047. pblim = Config.MAX_PVTSTOREBUY_SLOTS_DWARF;
  5048. else
  5049. pblim = Config.MAX_PVTSTOREBUY_SLOTS_OTHER;
  5050. - pblim += (int)getStat().calcStat(Stats.P_BUY_LIM, 0, null, null);
  5051. + pblim += (int) getStat().calcStat(Stats.P_BUY_LIM, 0, null, null);
  5052.  
  5053. return pblim;
  5054. }
  5055. @@ -12247,14 +12357,14 @@
  5056. public int getDwarfRecipeLimit()
  5057. {
  5058. int recdlim = Config.DWARF_RECIPE_LIMIT;
  5059. - recdlim += (int)getStat().calcStat(Stats.REC_D_LIM, 0, null, null);
  5060. + recdlim += (int) getStat().calcStat(Stats.REC_D_LIM, 0, null, null);
  5061. return recdlim;
  5062. }
  5063.  
  5064. public int getCommonRecipeLimit()
  5065. {
  5066. int recclim = Config.COMMON_RECIPE_LIMIT;
  5067. - recclim += (int)getStat().calcStat(Stats.REC_C_LIM, 0, null, null);
  5068. + recclim += (int) getStat().calcStat(Stats.REC_C_LIM, 0, null, null);
  5069. return recclim;
  5070. }
  5071.  
  5072. @@ -12296,13 +12406,11 @@
  5073. return _currentSkill;
  5074. }
  5075.  
  5076. -
  5077. /**
  5078. * Create a new SkillDat object and set the player _currentSkill.<BR><BR>
  5079. *
  5080. */
  5081. - public void setCurrentSkill(L2Skill currentSkill, boolean ctrlPressed,
  5082. - boolean shiftPressed)
  5083. + public void setCurrentSkill(L2Skill currentSkill, boolean ctrlPressed, boolean shiftPressed)
  5084. {
  5085. if (currentSkill == null)
  5086. {
  5087. @@ -12349,13 +12457,11 @@
  5088. _currentPetSkill = new SkillDat(currentSkill, ctrlPressed, shiftPressed);
  5089. }
  5090.  
  5091. -
  5092. public SkillDat getQueuedSkill()
  5093. {
  5094. return _queuedSkill;
  5095. }
  5096.  
  5097. -
  5098. /**
  5099. * Create a new SkillDat object and queue it in the player _queuedSkill.<BR><BR>
  5100. *
  5101. @@ -12404,28 +12510,29 @@
  5102.  
  5103. public void setPunishLevel(int state)
  5104. {
  5105. - switch (state){
  5106. - case 0 :
  5107. + switch (state)
  5108. + {
  5109. + case 0:
  5110. {
  5111. _punishLevel = PunishLevel.NONE;
  5112. break;
  5113. }
  5114. - case 1 :
  5115. + case 1:
  5116. {
  5117. _punishLevel = PunishLevel.CHAT;
  5118. break;
  5119. }
  5120. - case 2 :
  5121. + case 2:
  5122. {
  5123. _punishLevel = PunishLevel.JAIL;
  5124. break;
  5125. }
  5126. - case 3 :
  5127. + case 3:
  5128. {
  5129. _punishLevel = PunishLevel.CHAR;
  5130. break;
  5131. }
  5132. - case 4 :
  5133. + case 4:
  5134. {
  5135. _punishLevel = PunishLevel.ACC;
  5136. break;
  5137. @@ -12468,7 +12575,7 @@
  5138. htmlMsg.setHtml("<html><body>You are free for now, respect server rules!</body></html>");
  5139. sendPacket(htmlMsg);
  5140. stopPunishTask(true);
  5141. - teleToLocation(17836, 170178, -3507, true); // Floran
  5142. + teleToLocation(17836, 170178, -3507, true); // Floran
  5143. break;
  5144. }
  5145. }
  5146. @@ -12491,7 +12598,7 @@
  5147.  
  5148. // start the countdown
  5149. _punishTask = ThreadPoolManager.getInstance().scheduleGeneral(new PunishTask(), _punishTimer);
  5150. - sendMessage("You are chat banned for "+delayInMinutes+" minutes.");
  5151. + sendMessage("You are chat banned for " + delayInMinutes + " minutes.");
  5152. }
  5153. else
  5154. sendMessage("You have been chat banned");
  5155. @@ -12511,7 +12618,7 @@
  5156.  
  5157. // start the countdown
  5158. _punishTask = ThreadPoolManager.getInstance().scheduleGeneral(new PunishTask(), _punishTimer);
  5159. - sendMessage("You are in jail for "+delayInMinutes+" minutes.");
  5160. + sendMessage("You are in jail for " + delayInMinutes + " minutes.");
  5161. }
  5162.  
  5163. if (!TvTEvent.isInactive() && TvTEvent.isPlayerParticipant(getObjectId()))
  5164. @@ -12530,7 +12637,7 @@
  5165. setInstanceId(0);
  5166. setIsIn7sDungeon(false);
  5167.  
  5168. - teleToLocation(-114356, -249645, -2984, false); // Jail
  5169. + teleToLocation(-114356, -249645, -2984, false); // Jail
  5170. break;
  5171. }
  5172. case CHAR: // Ban Character
  5173. @@ -12574,13 +12681,13 @@
  5174. if (_punishTimer > 0)
  5175. {
  5176. _punishTask = ThreadPoolManager.getInstance().scheduleGeneral(new PunishTask(), _punishTimer);
  5177. - sendMessage("You are still "+getPunishLevel().string()+" for "+Math.round(_punishTimer/60000f)+" minutes.");
  5178. + sendMessage("You are still " + getPunishLevel().string() + " for " + Math.round(_punishTimer / 60000f) + " minutes.");
  5179. }
  5180. if (getPunishLevel() == PunishLevel.JAIL)
  5181. {
  5182. // If player escaped, put him back in jail
  5183. if (!isInsideZone(ZONE_JAIL))
  5184. - teleToLocation(-114356,-249645,-2984, true);
  5185. + teleToLocation(-114356, -249645, -2984, true);
  5186. }
  5187. }
  5188. }
  5189. @@ -12610,6 +12717,7 @@
  5190. L2PcInstance.this.setPunishLevel(PunishLevel.NONE, 0);
  5191. }
  5192. }
  5193. +
  5194. public void startFameTask(long delay, int fameFixRate)
  5195. {
  5196. if (getLevel() < 40 || getClassId().level() < 2)
  5197. @@ -12734,7 +12842,7 @@
  5198.  
  5199. public boolean isCombatFlagEquipped()
  5200. {
  5201. - return _combatFlagEquippedId ;
  5202. + return _combatFlagEquippedId;
  5203. }
  5204.  
  5205. public void setCombatFlagEquipped(boolean value)
  5206. @@ -12846,7 +12954,7 @@
  5207. */
  5208. private void restartSoulTask()
  5209. {
  5210. - synchronized(this)
  5211. + synchronized (this)
  5212. {
  5213. if (_soulTask != null)
  5214. {
  5215. @@ -12892,7 +13000,7 @@
  5216. _shortBuffTask.cancel(false);
  5217. _shortBuffTask = null;
  5218. }
  5219. - _shortBuffTask = ThreadPoolManager.getInstance().scheduleGeneral(new ShortBuffTask(), time*1000);
  5220. + _shortBuffTask = ThreadPoolManager.getInstance().scheduleGeneral(new ShortBuffTask(), time * 1000);
  5221. setShortBuffTaskSkillId(magicId);
  5222.  
  5223. sendPacket(new ShortBuffStatusUpdate(magicId, level, time));
  5224. @@ -12902,6 +13010,7 @@
  5225. {
  5226. _shortBuffTaskSkillId = id;
  5227. }
  5228. +
  5229. public int getDeathPenaltyBuffLevel()
  5230. {
  5231. return _deathPenaltyBuffLevel;
  5232. @@ -12914,27 +13023,21 @@
  5233.  
  5234. public void calculateDeathPenaltyBuffLevel(L2Character killer)
  5235. {
  5236. - if((getKarma() > 0 || Rnd.get(1,100) <= Config.DEATH_PENALTY_CHANCE)
  5237. - && !(killer instanceof L2PcInstance) && !(this.isGM())
  5238. - && !(this.getCharmOfLuck() && killer.isRaid())
  5239. - && !isPhoenixBlessed()
  5240. - && !isLucky()
  5241. - && !(TvTEvent.isStarted() && TvTEvent.isPlayerParticipant(getObjectId()))
  5242. - && !(this.isInsideZone(L2Character.ZONE_PVP)||this.isInsideZone(L2Character.ZONE_SIEGE)))
  5243. + if ((getKarma() > 0 || Rnd.get(1, 100) <= Config.DEATH_PENALTY_CHANCE) && !(killer instanceof L2PcInstance) && !(this.isGM()) && !(this.getCharmOfLuck() && killer.isRaid()) && !isPhoenixBlessed() && !isLucky() && !(TvTEvent.isStarted() && TvTEvent.isPlayerParticipant(getObjectId())) && !(this.isInsideZone(L2Character.ZONE_PVP) || this.isInsideZone(L2Character.ZONE_SIEGE)))
  5244.  
  5245. increaseDeathPenaltyBuffLevel();
  5246. }
  5247.  
  5248. public void increaseDeathPenaltyBuffLevel()
  5249. {
  5250. - if(getDeathPenaltyBuffLevel() >= 15) //maximum level reached
  5251. + if (getDeathPenaltyBuffLevel() >= 15) //maximum level reached
  5252. return;
  5253.  
  5254. - if(getDeathPenaltyBuffLevel() != 0)
  5255. + if (getDeathPenaltyBuffLevel() != 0)
  5256. {
  5257. L2Skill skill = SkillTable.getInstance().getInfo(5076, getDeathPenaltyBuffLevel());
  5258.  
  5259. - if(skill != null)
  5260. + if (skill != null)
  5261. removeSkill(skill, true);
  5262. }
  5263.  
  5264. @@ -12949,17 +13052,17 @@
  5265.  
  5266. public void reduceDeathPenaltyBuffLevel()
  5267. {
  5268. - if(getDeathPenaltyBuffLevel() <= 0)
  5269. + if (getDeathPenaltyBuffLevel() <= 0)
  5270. return;
  5271.  
  5272. L2Skill skill = SkillTable.getInstance().getInfo(5076, getDeathPenaltyBuffLevel());
  5273.  
  5274. - if(skill != null)
  5275. + if (skill != null)
  5276. removeSkill(skill, true);
  5277.  
  5278. _deathPenaltyBuffLevel--;
  5279.  
  5280. - if(getDeathPenaltyBuffLevel() > 0)
  5281. + if (getDeathPenaltyBuffLevel() > 0)
  5282. {
  5283. addSkill(SkillTable.getInstance().getInfo(5076, getDeathPenaltyBuffLevel()), false);
  5284. sendPacket(new EtcStatusUpdate(this));
  5285. @@ -12976,7 +13079,7 @@
  5286.  
  5287. public void restoreDeathPenaltyBuffLevel()
  5288. {
  5289. - if(getDeathPenaltyBuffLevel() > 0)
  5290. + if (getDeathPenaltyBuffLevel() > 0)
  5291. addSkill(SkillTable.getInstance().getInfo(5076, getDeathPenaltyBuffLevel()), false);
  5292. }
  5293.  
  5294. @@ -13013,7 +13116,7 @@
  5295. _skillId = skill.getId();
  5296. _skillLvl = skill.getLevel();
  5297. _reuse = reuse;
  5298. - _stamp = System.currentTimeMillis()+ reuse;
  5299. + _stamp = System.currentTimeMillis() + reuse;
  5300. }
  5301.  
  5302. public TimeStamp(L2Skill skill, long reuse, long systime)
  5303. @@ -13110,20 +13213,17 @@
  5304. sendPacket(SystemMessage.getSystemMessage(SystemMessageId.C1_HAD_CRITICAL_HIT).addPcName(this));
  5305. if (target instanceof L2Npc && getSkillLevel(467) > 0)
  5306. {
  5307. - L2Skill skill = SkillTable.getInstance().getInfo(467,getSkillLevel(467));
  5308. + L2Skill skill = SkillTable.getInstance().getInfo(467, getSkillLevel(467));
  5309. if (Rnd.get(100) < skill.getCritChance())
  5310. {
  5311. - absorbSoul(skill,((L2Npc)target));
  5312. + absorbSoul(skill, ((L2Npc) target));
  5313. }
  5314. }
  5315. }
  5316. if (mcrit)
  5317. sendPacket(SystemMessage.getSystemMessage(SystemMessageId.CRITICAL_HIT_MAGIC));
  5318.  
  5319. - if (isInOlympiadMode() &&
  5320. - target instanceof L2PcInstance &&
  5321. - ((L2PcInstance)target).isInOlympiadMode() &&
  5322. - ((L2PcInstance)target).getOlympiadGameId() == getOlympiadGameId())
  5323. + if (isInOlympiadMode() && target instanceof L2PcInstance && ((L2PcInstance) target).isInOlympiadMode() && ((L2PcInstance) target).getOlympiadGameId() == getOlympiadGameId())
  5324. {
  5325. OlympiadGameManager.getInstance().notifyCompetitorDamage(this, damage);
  5326. }
  5327. @@ -13150,7 +13250,6 @@
  5328. sendPacket(sm);
  5329. }
  5330.  
  5331. -
  5332. /**
  5333. *
  5334. * @param npcId
  5335. @@ -13405,8 +13504,7 @@
  5336. for (int i = 0; i < Inventory.PAPERDOLL_TOTALSLOTS; i++)
  5337. {
  5338. L2ItemInstance equippedItem = getInventory().getPaperdollItem(i);
  5339. - if (equippedItem != null && (!equippedItem.getItem().checkCondition(this, this, false)
  5340. - || (isInOlympiadMode() && equippedItem.isOlyRestrictedItem())))
  5341. + if (equippedItem != null && (!equippedItem.getItem().checkCondition(this, this, false) || (isInOlympiadMode() && equippedItem.isOlyRestrictedItem())))
  5342. {
  5343. getInventory().unEquipItemInSlot(i);
  5344.  
  5345. @@ -13471,7 +13569,7 @@
  5346. if (getCurrentFeed() > getFeedConsume())
  5347. {
  5348. // eat
  5349. - setCurrentFeed(getCurrentFeed()-getFeedConsume());
  5350. + setCurrentFeed(getCurrentFeed() - getFeedConsume());
  5351. }
  5352. else
  5353. {
  5354. @@ -13479,6 +13577,7 @@
  5355. setCurrentFeed(0);
  5356. stopFeed();
  5357. dismount();
  5358. + setKillsInRow(0);
  5359. sendPacket(SystemMessage.getSystemMessage(SystemMessageId.OUT_OF_FEED_MOUNT_CANCELED));
  5360. }
  5361.  
  5362. @@ -13508,7 +13607,7 @@
  5363. }
  5364. catch (Exception e)
  5365. {
  5366. - _log.log(Level.SEVERE, "Mounted Pet [NpcId: "+getMountNpcId()+"] a feed task error has occurred", e);
  5367. + _log.log(Level.SEVERE, "Mounted Pet [NpcId: " + getMountNpcId() + "] a feed task error has occurred", e);
  5368. }
  5369. }
  5370. }
  5371. @@ -13522,7 +13621,7 @@
  5372. {
  5373. setCurrentFeed(((L2PetInstance) getPet()).getCurrentFed());
  5374. _controlItemId = getPet().getControlObjectId();
  5375. - sendPacket(new SetupGauge(3, getCurrentFeed()*10000/getFeedConsume(), getMaxFeed()*10000/getFeedConsume()));
  5376. + sendPacket(new SetupGauge(3, getCurrentFeed() * 10000 / getFeedConsume(), getMaxFeed() * 10000 / getFeedConsume()));
  5377. if (!isDead())
  5378. {
  5379. _mountFeedTask = ThreadPoolManager.getInstance().scheduleGeneralAtFixedRate(new FeedTask(), 10000, 10000);
  5380. @@ -13531,7 +13630,7 @@
  5381. else if (_canFeed)
  5382. {
  5383. setCurrentFeed(getMaxFeed());
  5384. - SetupGauge sg = new SetupGauge(3, getCurrentFeed()*10000/getFeedConsume(), getMaxFeed()*10000/getFeedConsume());
  5385. + SetupGauge sg = new SetupGauge(3, getCurrentFeed() * 10000 / getFeedConsume(), getMaxFeed() * 10000 / getFeedConsume());
  5386. sendPacket(sg);
  5387. if (!isDead())
  5388. {
  5389. @@ -13547,7 +13646,8 @@
  5390. _mountFeedTask.cancel(false);
  5391. //ThreadPoolManager.getInstance().removeGeneral((Runnable)_mountFeedTask);
  5392. _mountFeedTask = null;
  5393. - if (Config.DEBUG) _log.fine("Pet [#"+_mountNpcId+"] feed task stop");
  5394. + if (Config.DEBUG)
  5395. + _log.fine("Pet [#" + _mountNpcId + "] feed task stop");
  5396. }
  5397. }
  5398.  
  5399. @@ -13570,7 +13670,10 @@
  5400. return _leveldata;
  5401. }
  5402.  
  5403. - public int getCurrentFeed() { return _curFeed; }
  5404. + public int getCurrentFeed()
  5405. + {
  5406. + return _curFeed;
  5407. + }
  5408.  
  5409. private int getFeedConsume()
  5410. {
  5411. @@ -13584,7 +13687,7 @@
  5412. public void setCurrentFeed(int num)
  5413. {
  5414. _curFeed = num > getMaxFeed() ? getMaxFeed() : num;
  5415. - SetupGauge sg = new SetupGauge(3, getCurrentFeed()*10000/getFeedConsume(), getMaxFeed()*10000/getFeedConsume());
  5416. + SetupGauge sg = new SetupGauge(3, getCurrentFeed() * 10000 / getFeedConsume(), getMaxFeed() * 10000 / getFeedConsume());
  5417. sendPacket(sg);
  5418. }
  5419.  
  5420. @@ -13595,7 +13698,7 @@
  5421.  
  5422. private boolean isHungry()
  5423. {
  5424. - return _canFeed ? (getCurrentFeed() < (getPetData(getMountNpcId()).getHungry_limit() / 100f * getPetLevelData(getMountNpcId()).getPetMaxFeed())):false;
  5425. + return _canFeed ? (getCurrentFeed() < (getPetData(getMountNpcId()).getHungry_limit() / 100f * getPetLevelData(getMountNpcId()).getPetMaxFeed())) : false;
  5426. }
  5427.  
  5428. private class Dismount implements Runnable
  5429. @@ -13647,7 +13750,7 @@
  5430. }
  5431. catch (Exception e)
  5432. {
  5433. - _log.log(Level.SEVERE, "Failed to store Pet [NpcId: "+petId+"] data", e);
  5434. + _log.log(Level.SEVERE, "Failed to store Pet [NpcId: " + petId + "] data", e);
  5435. }
  5436. finally
  5437. {
  5438. @@ -13655,6 +13758,7 @@
  5439. }
  5440. }
  5441. }
  5442. +
  5443. /** End of section for mounted pets */
  5444.  
  5445. @Override
  5446. @@ -13674,7 +13778,7 @@
  5447. */
  5448. public int getEventEffectId()
  5449. {
  5450. - return _eventEffectId ;
  5451. + return _eventEffectId;
  5452. }
  5453.  
  5454. public void startEventEffect(AbnormalEffect mask)
  5455. @@ -13809,8 +13913,8 @@
  5456.  
  5457. public static class TeleportBookmark
  5458. {
  5459. - public int _id,_x,_y,_z,_icon;
  5460. - public String _name,_tag;
  5461. + public int _id, _x, _y, _z, _icon;
  5462. + public String _name, _tag;
  5463.  
  5464. TeleportBookmark(int id, int x, int y, int z, int icon, String tag, String name)
  5465. {
  5466. @@ -13829,9 +13933,9 @@
  5467. {
  5468. int count = 0;
  5469. int size = tpbookmark.size();
  5470. - while(size > count)
  5471. + while (size > count)
  5472. {
  5473. - if(tpbookmark.get(count)._id==Id)
  5474. + if (tpbookmark.get(count)._id == Id)
  5475. {
  5476. tpbookmark.get(count)._icon = icon;
  5477. tpbookmark.get(count)._tag = tag;
  5478. @@ -13898,9 +14002,9 @@
  5479. int count = 0;
  5480. int size = tpbookmark.size();
  5481.  
  5482. - while(size > count)
  5483. + while (size > count)
  5484. {
  5485. - if(tpbookmark.get(count)._id == Id)
  5486. + if (tpbookmark.get(count)._id == Id)
  5487. {
  5488. tpbookmark.remove(count);
  5489. break;
  5490. @@ -13913,7 +14017,7 @@
  5491.  
  5492. public void teleportBookmarkGo(int Id)
  5493. {
  5494. - if(!teleportBookmarkCondition(0) || this == null)
  5495. + if (!teleportBookmarkCondition(0) || this == null)
  5496. return;
  5497. if (getInventory().getInventoryItemCount(13016, 0) == 0)
  5498. {
  5499. @@ -13925,9 +14029,9 @@
  5500. sendPacket(sm);
  5501. int count = 0;
  5502. int size = tpbookmark.size();
  5503. - while(size > count)
  5504. + while (size > count)
  5505. {
  5506. - if(tpbookmark.get(count)._id == Id)
  5507. + if (tpbookmark.get(count)._id == Id)
  5508. {
  5509. destroyItem("Consume", getInventory().getItemByItemId(13016).getObjectId(), 1, null, false);
  5510. this.teleToLocation(tpbookmark.get(count)._x, tpbookmark.get(count)._y, tpbookmark.get(count)._z);
  5511. @@ -13940,7 +14044,7 @@
  5512.  
  5513. public boolean teleportBookmarkCondition(int type)
  5514. {
  5515. - if(this.isInCombat())
  5516. + if (this.isInCombat())
  5517. {
  5518. sendPacket(SystemMessage.getSystemMessage(SystemMessageId.YOU_CANNOT_USE_MY_TELEPORTS_DURING_A_BATTLE));
  5519. return false;
  5520. @@ -13982,7 +14086,7 @@
  5521. }
  5522. else if (this.isInBoat() || this.isInAirShip() || this.isInJail() || this.isInsideZone(ZONE_NOSUMMONFRIEND))
  5523. {
  5524. - if(type == 0)
  5525. + if (type == 0)
  5526. sendPacket(SystemMessage.getSystemMessage(SystemMessageId.YOU_CANNOT_USE_MY_TELEPORTS_IN_THIS_AREA));
  5527. else if (type == 1)
  5528. sendPacket(SystemMessage.getSystemMessage(SystemMessageId.YOU_CANNOT_USE_MY_TELEPORTS_TO_REACH_THIS_AREA));
  5529. @@ -14000,38 +14104,38 @@
  5530. }
  5531. else if (isInsideZone(ZONE_NOBOOKMARK))
  5532. {
  5533. - if(type == 0)
  5534. + if (type == 0)
  5535. sendPacket(SystemMessage.getSystemMessage(SystemMessageId.YOU_CANNOT_USE_MY_TELEPORTS_IN_THIS_AREA));
  5536. else if (type == 1)
  5537. sendPacket(SystemMessage.getSystemMessage(SystemMessageId.YOU_CANNOT_USE_MY_TELEPORTS_TO_REACH_THIS_AREA));
  5538. return false;
  5539. }
  5540. /* TODO: Instant Zone still not implement
  5541. - else if (this.isInsideZone(ZONE_INSTANT))
  5542. - {
  5543. - sendPacket(SystemMessage.getSystemMessage(2357));
  5544. - return;
  5545. - }
  5546. + else if (this.isInsideZone(ZONE_INSTANT))
  5547. + {
  5548. + sendPacket(SystemMessage.getSystemMessage(2357));
  5549. + return;
  5550. + }
  5551. */
  5552. else
  5553. return true;
  5554. }
  5555.  
  5556. - public void teleportBookmarkAdd(int x,int y,int z,int icon, String tag, String name)
  5557. + public void teleportBookmarkAdd(int x, int y, int z, int icon, String tag, String name)
  5558. {
  5559. - if(this == null)
  5560. + if (this == null)
  5561. return;
  5562.  
  5563. - if(!teleportBookmarkCondition(1))
  5564. + if (!teleportBookmarkCondition(1))
  5565. return;
  5566.  
  5567. - if(tpbookmark.size() >= _bookmarkslot)
  5568. + if (tpbookmark.size() >= _bookmarkslot)
  5569. {
  5570. sendPacket(SystemMessage.getSystemMessage(2358));
  5571. return;
  5572. }
  5573.  
  5574. - if(getInventory().getInventoryItemCount(20033, 0) == 0)
  5575. + if (getInventory().getInventoryItemCount(20033, 0) == 0)
  5576. {
  5577. sendPacket(SystemMessage.getSystemMessage(6501));
  5578. return;
  5579. @@ -14043,15 +14147,15 @@
  5580.  
  5581. int size = tpbookmark.size();
  5582.  
  5583. - while(size > count)
  5584. + while (size > count)
  5585. {
  5586. idlist.add(tpbookmark.get(count)._id);
  5587. count++;
  5588. }
  5589.  
  5590. - for(int i=1; i<10; i++)
  5591. + for (int i = 1; i < 10; i++)
  5592. {
  5593. - if(!idlist.contains(i))
  5594. + if (!idlist.contains(i))
  5595. {
  5596. id = i;
  5597. break;
  5598. @@ -14059,7 +14163,7 @@
  5599. }
  5600.  
  5601. TeleportBookmark tpadd = new TeleportBookmark(id, x, y, z, icon, tag, name);
  5602. - if(tpbookmark == null)
  5603. + if (tpbookmark == null)
  5604. tpbookmark = new FastList<TeleportBookmark>();
  5605.  
  5606. tpbookmark.add(tpadd);
  5607. @@ -14087,7 +14191,6 @@
  5608. statement.setString(7, tag);
  5609. statement.setString(8, name);
  5610.  
  5611. -
  5612. statement.execute();
  5613. statement.close();
  5614. }
  5615. @@ -14105,7 +14208,7 @@
  5616.  
  5617. public void restoreTeleportBookmark()
  5618. {
  5619. - if(tpbookmark == null)
  5620. + if (tpbookmark == null)
  5621. tpbookmark = new FastList<TeleportBookmark>();
  5622. Connection con = null;
  5623.  
  5624. @@ -14137,7 +14240,7 @@
  5625. @Override
  5626. public void sendInfo(L2PcInstance activeChar)
  5627. {
  5628. - if(isInBoat())
  5629. + if (isInBoat())
  5630. {
  5631. getPosition().setWorldPosition(getBoat().getPosition().getWorldPosition());
  5632.  
  5633. @@ -14161,7 +14264,7 @@
  5634. }
  5635. activeChar.sendPacket(new GetOnVehicle(getObjectId(), getBoat().getObjectId(), getInVehiclePosition()));
  5636. }
  5637. - else if(isInAirShip())
  5638. + else if (isInAirShip())
  5639. {
  5640. getPosition().setWorldPosition(getAirShip().getPosition().getWorldPosition());
  5641.  
  5642. @@ -14290,9 +14393,7 @@
  5643. if (birth.get(Calendar.DAY_OF_MONTH) == 29 && birth.get(Calendar.MONTH) == 1)
  5644. birth.add(Calendar.HOUR_OF_DAY, -24);
  5645.  
  5646. - if (now.get(Calendar.MONTH) == birth.get(Calendar.MONTH)
  5647. - && now.get(Calendar.DAY_OF_MONTH) == birth.get(Calendar.DAY_OF_MONTH)
  5648. - && now.get(Calendar.YEAR) != birth.get(Calendar.YEAR))
  5649. + if (now.get(Calendar.MONTH) == birth.get(Calendar.MONTH) && now.get(Calendar.DAY_OF_MONTH) == birth.get(Calendar.DAY_OF_MONTH) && now.get(Calendar.YEAR) != birth.get(Calendar.YEAR))
  5650. {
  5651. return 0;
  5652. }
  5653. @@ -14302,16 +14403,13 @@
  5654. for (i = 1; i < 6; i++)
  5655. {
  5656. now.add(Calendar.HOUR_OF_DAY, 24);
  5657. - if (now.get(Calendar.MONTH) == birth.get(Calendar.MONTH)
  5658. - && now.get(Calendar.DAY_OF_MONTH) == birth.get(Calendar.DAY_OF_MONTH)
  5659. - && now.get(Calendar.YEAR) != birth.get(Calendar.YEAR))
  5660. + if (now.get(Calendar.MONTH) == birth.get(Calendar.MONTH) && now.get(Calendar.DAY_OF_MONTH) == birth.get(Calendar.DAY_OF_MONTH) && now.get(Calendar.YEAR) != birth.get(Calendar.YEAR))
  5661. return i;
  5662. }
  5663. }
  5664. return -1;
  5665. }
  5666.  
  5667. -
  5668. /**
  5669. * list of character friends
  5670. *
  5671. @@ -14366,7 +14464,7 @@
  5672. private void notifyFriends()
  5673. {
  5674. FriendStatusPacket pkt = new FriendStatusPacket(getObjectId());
  5675. - for(int id : _friendList)
  5676. + for (int id : _friendList)
  5677. {
  5678. L2PcInstance friend = L2World.getInstance().getPlayer(id);
  5679. if (friend != null)
  5680. @@ -14444,7 +14542,6 @@
  5681. statement.setInt(1, getObjectId());
  5682. ResultSet rset = statement.executeQuery();
  5683.  
  5684. -
  5685. L2ManufactureList createList = new L2ManufactureList();
  5686. while (rset.next())
  5687. {
  5688. @@ -14456,7 +14553,7 @@
  5689. }
  5690. catch (Exception e)
  5691. {
  5692. - _log.log(Level.SEVERE, "Could not restore recipe shop list data for playerId: "+getObjectId(), e);
  5693. + _log.log(Level.SEVERE, "Could not restore recipe shop list data for playerId: " + getObjectId(), e);
  5694. }
  5695. finally
  5696. {
  5697. @@ -14484,33 +14581,40 @@
  5698. {
  5699. return _clientX;
  5700. }
  5701. +
  5702. public final int getClientY()
  5703. {
  5704. return _clientY;
  5705. }
  5706. +
  5707. public final int getClientZ()
  5708. {
  5709. return _clientZ;
  5710. }
  5711. +
  5712. public final int getClientHeading()
  5713. {
  5714. return _clientHeading;
  5715. }
  5716. +
  5717. public final void setClientX(int val)
  5718. {
  5719. - _clientX=val;
  5720. + _clientX = val;
  5721. }
  5722. +
  5723. public final void setClientY(int val)
  5724. {
  5725. - _clientY=val;
  5726. + _clientY = val;
  5727. }
  5728. +
  5729. public final void setClientZ(int val)
  5730. {
  5731. - _clientZ=val;
  5732. + _clientZ = val;
  5733. }
  5734. +
  5735. public final void setClientHeading(int val)
  5736. {
  5737. - _clientHeading=val;
  5738. + _clientHeading = val;
  5739. }
  5740.  
  5741. /**
  5742. @@ -14519,10 +14623,7 @@
  5743. */
  5744. public final boolean isFalling(int z)
  5745. {
  5746. - if (isDead()
  5747. - || isFlying()
  5748. - || isFlyingMounted()
  5749. - || isInsideZone(ZONE_WATER))
  5750. + if (isDead() || isFlying() || isFlyingMounted() || isInsideZone(ZONE_WATER))
  5751. return false;
  5752.  
  5753. if (System.currentTimeMillis() < _fallingTimestamp)
  5754. @@ -14532,7 +14633,7 @@
  5755. if (deltaZ <= getBaseTemplate().getFallHeight())
  5756. return false;
  5757.  
  5758. - final int damage = (int)Formulas.calcFallDam(this, deltaZ);
  5759. + final int damage = (int) Formulas.calcFallDam(this, deltaZ);
  5760. if (damage > 0)
  5761. {
  5762. reduceCurrentHp(Math.min(damage, getCurrentHp() - 1), null, false, true, null);
  5763. @@ -14716,24 +14817,20 @@
  5764.  
  5765. if (nextLevel == -1) // there is no lower skill
  5766. {
  5767. - _log.info("Removing skill id "+id+ " level "+getSkillLevel(id)+" from player "+this);
  5768. + _log.info("Removing skill id " + id + " level " + getSkillLevel(id) + " from player " + this);
  5769. removeSkill(_skills.get(id), true);
  5770. }
  5771. - else // replace with lower one
  5772. + else
  5773. + // replace with lower one
  5774. {
  5775. - _log.info("Decreasing skill id "+id+" from "+getSkillLevel(id)+" to "+nextLevel+" for "+this);
  5776. + _log.info("Decreasing skill id " + id + " from " + getSkillLevel(id) + " to " + nextLevel + " for " + this);
  5777. addSkill(SkillTable.getInstance().getInfo(id, nextLevel), true);
  5778. }
  5779. }
  5780.  
  5781. public boolean canMakeSocialAction()
  5782. {
  5783. - if (getPrivateStoreType() == 0 && getActiveRequester() == null
  5784. - && !isAlikeDead() && (!isAllSkillsDisabled() || isInDuel())
  5785. - && !isCastingNow() && !isCastingSimultaneouslyNow()
  5786. - && getAI().getIntention() == CtrlIntention.AI_INTENTION_IDLE
  5787. - && !AttackStanceTaskManager.getInstance().getAttackStanceTask(this)
  5788. - && !isInOlympiadMode())
  5789. + if (getPrivateStoreType() == 0 && getActiveRequester() == null && !isAlikeDead() && (!isAllSkillsDisabled() || isInDuel()) && !isCastingNow() && !isCastingSimultaneouslyNow() && getAI().getIntention() == CtrlIntention.AI_INTENTION_IDLE && !AttackStanceTaskManager.getInstance().getAttackStanceTask(this) && !isInOlympiadMode())
  5790. {
  5791. return true;
  5792. }
  5793. @@ -14777,13 +14874,13 @@
  5794.  
  5795. public boolean canAttackCharacter(L2Character cha)
  5796. {
  5797. - if(cha instanceof L2Attackable)
  5798. + if (cha instanceof L2Attackable)
  5799. {
  5800. return true;
  5801. }
  5802. - else if(cha instanceof L2Playable)
  5803. + else if (cha instanceof L2Playable)
  5804. {
  5805. - if(cha.isInsideZone(L2Character.ZONE_PVP) && !cha.isInsideZone(L2Character.ZONE_SIEGE))
  5806. + if (cha.isInsideZone(L2Character.ZONE_PVP) && !cha.isInsideZone(L2Character.ZONE_SIEGE))
  5807. return true;
  5808.  
  5809. L2PcInstance target;
  5810. @@ -14798,9 +14895,9 @@
  5811. }
  5812. else if (isInParty() && target.isInParty())
  5813. {
  5814. - if(getParty() == target.getParty())
  5815. + if (getParty() == target.getParty())
  5816. return false;
  5817. - if((getParty().getCommandChannel() != null || target.getParty().getCommandChannel() != null) && (getParty().getCommandChannel() == target.getParty().getCommandChannel()))
  5818. + if ((getParty().getCommandChannel() != null || target.getParty().getCommandChannel() != null) && (getParty().getCommandChannel() == target.getParty().getCommandChannel()))
  5819. return false;
  5820. }
  5821. else if (getClan() != null && target.getClan() != null)
  5822. @@ -14809,12 +14906,12 @@
  5823. return false;
  5824. if ((getAllyId() > 0 || target.getAllyId() > 0) && (getAllyId() == target.getAllyId()))
  5825. return false;
  5826. - if(getClan().isAtWarWith(target.getClan().getClanId()) && target.getClan().isAtWarWith(getClan().getClanId()))
  5827. + if (getClan().isAtWarWith(target.getClan().getClanId()) && target.getClan().isAtWarWith(getClan().getClanId()))
  5828. return true;
  5829. }
  5830. else if (getClan() == null || target.getClan() == null)
  5831. {
  5832. - if(target.getPvpFlag() == 0 && target.getKarma() == 0)
  5833. + if (target.getPvpFlag() == 0 && target.getKarma() == 0)
  5834. return false;
  5835. }
  5836. }
  5837. @@ -14864,25 +14961,25 @@
  5838. if (rset.next() && rset.getInt("object_id") > 0)
  5839. setPetInvItems(true);
  5840. else
  5841. - setPetInvItems(false);
  5842. + setPetInvItems(false);
  5843. rset.close();
  5844. statement.close();
  5845. }
  5846. catch (Exception e)
  5847. {
  5848. - _log.log(Level.SEVERE, "Could not check Items in Pet Inventory for playerId: "+getObjectId(), e);
  5849. + _log.log(Level.SEVERE, "Could not check Items in Pet Inventory for playerId: " + getObjectId(), e);
  5850. }
  5851. finally
  5852. {
  5853. L2DatabaseFactory.close(con);
  5854. }
  5855. }
  5856. -
  5857. +
  5858. public String getAdminConfirmCmd()
  5859. {
  5860. return _adminConfirmCmd;
  5861. }
  5862. -
  5863. +
  5864. public void setAdminConfirmCmd(String adminConfirmCmd)
  5865. {
  5866. _adminConfirmCmd = adminConfirmCmd;
  5867. @@ -14892,12 +14989,12 @@
  5868. {
  5869. _handysBlockCheckerEventArena = arena;
  5870. }
  5871. -
  5872. +
  5873. public int getBlockCheckerArena()
  5874. {
  5875. return _handysBlockCheckerEventArena;
  5876. }
  5877. -
  5878. +
  5879. /**
  5880. * Load L2PcInstance Recommendations data.<BR><BR>
  5881. */
  5882. @@ -14912,10 +15009,10 @@
  5883. statement.setInt(1, getObjectId());
  5884. ResultSet rset = statement.executeQuery();
  5885.  
  5886. - if(rset.next())
  5887. + if (rset.next())
  5888. {
  5889. setRecomHave(rset.getInt("rec_have"));
  5890. - setRecomLeft(rset.getInt("rec_left"));
  5891. + setRecomLeft(rset.getInt("rec_left"));
  5892. _time_left = rset.getLong("time_left");
  5893. }
  5894. else
  5895. @@ -14928,7 +15025,7 @@
  5896. }
  5897. catch (Exception e)
  5898. {
  5899. - _log.log(Level.SEVERE, "Could not restore Recommendations for player: "+getObjectId(), e);
  5900. + _log.log(Level.SEVERE, "Could not restore Recommendations for player: " + getObjectId(), e);
  5901. }
  5902. finally
  5903. {
  5904. @@ -14936,14 +15033,14 @@
  5905. }
  5906. return _time_left;
  5907. }
  5908. -
  5909. +
  5910. /**
  5911. * Update L2PcInstance Recommendations data.<BR><BR>
  5912. */
  5913. public void storeRecommendations()
  5914. {
  5915. long _recoTaskEnd = 0;
  5916. - if(_recoBonusTask != null)
  5917. + if (_recoBonusTask != null)
  5918. _recoTaskEnd = Math.max(0, _recoBonusTask.getDelay(TimeUnit.MILLISECONDS));
  5919.  
  5920. Connection con = null;
  5921. @@ -14964,24 +15061,24 @@
  5922. }
  5923. catch (Exception e)
  5924. {
  5925. - _log.log(Level.SEVERE, "Could not update Recommendations for player: "+getObjectId(), e);
  5926. + _log.log(Level.SEVERE, "Could not update Recommendations for player: " + getObjectId(), e);
  5927. }
  5928. finally
  5929. {
  5930. L2DatabaseFactory.close(con);
  5931. }
  5932. }
  5933. -
  5934. +
  5935. public void checkRecoBonusTask()
  5936. {
  5937. // Load data
  5938. long _task_time = loadRecommendations();
  5939.  
  5940. - if(_task_time > 0)
  5941. + if (_task_time > 0)
  5942. {
  5943. // Add 20 recos on first login
  5944. - if(_task_time == 3600000)
  5945. - setRecomLeft(getRecomLeft()+20);
  5946. + if (_task_time == 3600000)
  5947. + setRecomLeft(getRecomLeft() + 20);
  5948. // If player have some timeleft, start bonus task
  5949. _recoBonusTask = ThreadPoolManager.getInstance().scheduleGeneral(new RecoBonusTaskEnd(), _task_time);
  5950. }
  5951. @@ -15022,14 +15119,14 @@
  5952. int reco_to_give;
  5953. // 10 recommendations to give out after 2 hours of being logged in
  5954. // 1 more recommendation to give out every hour after that.
  5955. - if(_recoTwoHoursGiven)
  5956. + if (_recoTwoHoursGiven)
  5957. reco_to_give = 1;
  5958. else
  5959. reco_to_give = 10;
  5960.  
  5961. _recoTwoHoursGiven = true;
  5962.  
  5963. - setRecomLeft(getRecomLeft()+reco_to_give);
  5964. + setRecomLeft(getRecomLeft() + reco_to_give);
  5965.  
  5966. SystemMessage sm = SystemMessage.getSystemMessage(SystemMessageId.YOU_OBTAINED_S1_RECOMMENDATIONS);
  5967. sm.addNumber(reco_to_give);
  5968. @@ -15052,12 +15149,12 @@
  5969.  
  5970. public int getRecomBonusTime()
  5971. {
  5972. - if(_recoBonusTask != null)
  5973. + if (_recoBonusTask != null)
  5974. return (int) Math.max(0, _recoBonusTask.getDelay(TimeUnit.SECONDS));
  5975.  
  5976. return 0;
  5977. }
  5978. -
  5979. +
  5980. public int getRecomBonusType()
  5981. {
  5982. // Maintain = 1
  5983. @@ -15093,4 +15190,25 @@
  5984. {
  5985. return eventStatus;
  5986. }
  5987. +
  5988. + private CharacterAchievementSystem _cas = new CharacterAchievementSystem(this);
  5989. +
  5990. + public CharacterAchievementSystem getCAS()
  5991. + {
  5992. + if (_cas == null)
  5993. + _cas = new CharacterAchievementSystem(this);
  5994. + return _cas;
  5995. + }
  5996. +
  5997. + private int _killsInRow = 0;
  5998. +
  5999. + public int getKillsInRow()
  6000. + {
  6001. + return _killsInRow;
  6002. + }
  6003. +
  6004. + public void setKillsInRow(int val)
  6005. + {
  6006. + _killsInRow = val;
  6007. + }
  6008. }
  6009. Index: java/com/l2jserver/gameserver/model/olympiad/AbstractOlympiadGame.java
  6010. ===================================================================
  6011. --- java/com/l2jserver/gameserver/model/olympiad/AbstractOlympiadGame.java (revision 4769)
  6012. +++ java/com/l2jserver/gameserver/model/olympiad/AbstractOlympiadGame.java (working copy)
  6013. @@ -24,6 +24,7 @@
  6014. import com.l2jserver.gameserver.instancemanager.AntiFeedManager;
  6015. import com.l2jserver.gameserver.instancemanager.CastleManager;
  6016. import com.l2jserver.gameserver.instancemanager.FortManager;
  6017. +import com.l2jserver.gameserver.model.CharacterAchievementSystem;
  6018. import com.l2jserver.gameserver.model.L2ItemInstance;
  6019. import com.l2jserver.gameserver.model.L2Party;
  6020. import com.l2jserver.gameserver.model.L2Skill;
  6021. @@ -85,6 +86,9 @@
  6022.  
  6023. protected final void addPointsToParticipant(Participant par, int points)
  6024. {
  6025. + if (CharacterAchievementSystem.checkOk(par.player))
  6026. + par.player.getCAS().onOlyWin();
  6027. +
  6028. par.updateStat(POINTS, points);
  6029. final SystemMessage sm = SystemMessage.getSystemMessage(SystemMessageId.C1_HAS_GAINED_S2_OLYMPIAD_POINTS);
  6030. sm.addString(par.name);
  6031. @@ -374,6 +378,9 @@
  6032.  
  6033. player.teleToLocation(player.getLastX(), player.getLastY(), player.getLastZ());
  6034. player.setLastCords(0, 0, 0);
  6035. +
  6036. + if (CharacterAchievementSystem.checkOk(player))
  6037. + player.getCAS().onOlyGamePlayed();
  6038. }
  6039.  
  6040. public static final void rewardParticipant(L2PcInstance player, int[][] reward)
  6041. Index: java/com/l2jserver/gameserver/model/actor/instance/L2GrandBossInstance.java
  6042. ===================================================================
  6043. --- java/com/l2jserver/gameserver/model/actor/instance/L2GrandBossInstance.java (revision 4769)
  6044. +++ java/com/l2jserver/gameserver/model/actor/instance/L2GrandBossInstance.java (working copy)
  6045. @@ -15,6 +15,7 @@
  6046. package com.l2jserver.gameserver.model.actor.instance;
  6047.  
  6048. import com.l2jserver.gameserver.instancemanager.RaidBossPointsManager;
  6049. +import com.l2jserver.gameserver.model.CharacterAchievementSystem;
  6050. import com.l2jserver.gameserver.model.actor.L2Character;
  6051. import com.l2jserver.gameserver.model.actor.L2Summon;
  6052. import com.l2jserver.gameserver.model.entity.Hero;
  6053. @@ -65,10 +66,15 @@
  6054. {
  6055. if (!super.doDie(killer))
  6056. return false;
  6057. +
  6058. L2PcInstance player = null;
  6059.  
  6060. if (killer instanceof L2PcInstance)
  6061. + {
  6062. player = (L2PcInstance) killer;
  6063. + if (CharacterAchievementSystem.checkOk(player))
  6064. + player.getCAS().onGrandbossKill();
  6065. + }
  6066. else if (killer instanceof L2Summon)
  6067. player = ((L2Summon) killer).getOwner();
  6068.  
  6069. Index: java/com/l2jserver/gameserver/model/L2ItemInstance.java
  6070. ===================================================================
  6071. --- java/com/l2jserver/gameserver/model/L2ItemInstance.java (revision 4769)
  6072. +++ java/com/l2jserver/gameserver/model/L2ItemInstance.java (working copy)
  6073. @@ -1947,4 +1947,14 @@
  6074.  
  6075. return enchant;
  6076. }
  6077. +
  6078. + public void setIsConsumingMana(boolean val)
  6079. + {
  6080. + _consumingMana = val;
  6081. + }
  6082. +
  6083. + public void setMana(int mana)
  6084. + {
  6085. + _mana = mana;
  6086. + }
  6087. }
  6088. Index: java/config/loginserver.properties
  6089. ===================================================================
  6090. --- java/config/loginserver.properties (revision 4769)
  6091. +++ java/config/loginserver.properties (working copy)
  6092. @@ -15,7 +15,7 @@
  6093. # WARNING: <u><b><font color="red">Please don't change default IPs here if you don't know what are you doing!</font></b></u>
  6094. # WARNING: <u><b><font color="red">External/Internal IPs are now inside "ipconfig.xml" file.</font></b></u>
  6095. # Default: * (0.0.0.0)
  6096. -LoginserverHostname = *
  6097. +LoginserverHostname = 127.0.0.1
  6098.  
  6099. # Default: 2106
  6100. LoginserverPort = 2106
  6101. @@ -24,7 +24,7 @@
  6102. # WARNING: <u><b><font color="red">Please don't change default IPs here if you don't know what are you doing!</font></b></u>
  6103. # WARNING: <u><b><font color="red">External/Internal IPs are now inside "ipconfig.xml" file.</font></b></u>
  6104. # Default: * (0.0.0.0)
  6105. -LoginHostname = *
  6106. +LoginHostname = 127.0.0.1
  6107.  
  6108. # The port on which login will listen for GameServers
  6109. # Default: 9014
  6110. @@ -79,11 +79,11 @@
  6111. # URL = jdbc:mysql://localhost/l2jls (default)
  6112. # URL = jdbc:hsqldb:hsql://localhost/l2jls
  6113. # URL = jdbc:sqlserver://localhost/database = l2jls/user = sa/password =
  6114. -URL = jdbc:mysql://localhost/l2jls
  6115. +URL = jdbc:mysql://localhost/l2jdb
  6116. # Database user info (default is "root" but it's not recommended)
  6117. Login = root
  6118. # Database connection password
  6119. -Password =
  6120. +Password = root
  6121.  
  6122. # Default: 10
  6123. MaximumDbConnections = 10
  6124. Index: java/com/l2jserver/gameserver/model/quest/Quest.java
  6125. ===================================================================
  6126. --- java/com/l2jserver/gameserver/model/quest/Quest.java (revision 4769)
  6127. +++ java/com/l2jserver/gameserver/model/quest/Quest.java (working copy)
  6128. @@ -500,6 +500,7 @@
  6129. // override the default NPC dialogs when a quest defines this for the given NPC
  6130. public final boolean notifyFirstTalk(L2Npc npc, L2PcInstance player)
  6131. {
  6132. + System.out.println("notifytalk");
  6133. String res = null;
  6134. try
  6135. {
  6136. Index: java/com/l2jserver/gameserver/model/L2Fishing.java
  6137. ===================================================================
  6138. --- java/com/l2jserver/gameserver/model/L2Fishing.java (revision 4769)
  6139. +++ java/com/l2jserver/gameserver/model/L2Fishing.java (working copy)
  6140. @@ -147,6 +147,8 @@
  6141. _fisher.addItem("Fishing", _fishId, 1, null, true);
  6142. }
  6143. }
  6144. + if (CharacterAchievementSystem.checkOk(_fisher))
  6145. + _fisher.getCAS().onFishingDone(true);
  6146. _fisher.endFishing(win);
  6147. _fisher = null;
  6148. }
  6149. Index: java/com/l2jserver/gameserver/model/actor/instance/L2RaidBossInstance.java
  6150. ===================================================================
  6151. --- java/com/l2jserver/gameserver/model/actor/instance/L2RaidBossInstance.java (revision 4769)
  6152. +++ java/com/l2jserver/gameserver/model/actor/instance/L2RaidBossInstance.java (working copy)
  6153. @@ -18,6 +18,7 @@
  6154. import com.l2jserver.gameserver.ThreadPoolManager;
  6155. import com.l2jserver.gameserver.instancemanager.RaidBossPointsManager;
  6156. import com.l2jserver.gameserver.instancemanager.RaidBossSpawnManager;
  6157. +import com.l2jserver.gameserver.model.CharacterAchievementSystem;
  6158. import com.l2jserver.gameserver.model.L2Skill;
  6159. import com.l2jserver.gameserver.model.L2Spawn;
  6160. import com.l2jserver.gameserver.model.actor.L2Character;
  6161. @@ -80,7 +81,11 @@
  6162.  
  6163. L2PcInstance player = null;
  6164. if (killer instanceof L2PcInstance)
  6165. + {
  6166. player = (L2PcInstance) killer;
  6167. + if (CharacterAchievementSystem.checkOk(player))
  6168. + player.getCAS().onRaidbossKill();
  6169. + }
  6170. else if (killer instanceof L2Summon)
  6171. player = ((L2Summon) killer).getOwner();
  6172.  
  6173. Index: java/com/l2jserver/gameserver/model/CharacterAchievementSystem.java
  6174. ===================================================================
  6175. --- java/com/l2jserver/gameserver/model/CharacterAchievementSystem.java (revision 0)
  6176. +++ java/com/l2jserver/gameserver/model/CharacterAchievementSystem.java (revision 0)
  6177. @@ -0,0 +1,378 @@
  6178. +/*
  6179. + * This program is free software: you can redistribute it and/or modify it under
  6180. + * the terms of the GNU General Public License as published by the Free Software
  6181. + * Foundation, either version 3 of the License, or (at your option) any later
  6182. + * version.
  6183. + *
  6184. + * This program is distributed in the hope that it will be useful, but WITHOUT
  6185. + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  6186. + * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
  6187. + * details.
  6188. + *
  6189. + * You should have received a copy of the GNU General Public License along with
  6190. + * this program. If not, see <http://www.gnu.org/licenses/>.
  6191. + */
  6192. +package com.l2jserver.gameserver.model;
  6193. +
  6194. +import java.sql.Connection;
  6195. +import java.sql.PreparedStatement;
  6196. +import java.sql.ResultSet;
  6197. +import java.sql.SQLException;
  6198. +import java.util.logging.Level;
  6199. +import java.util.logging.Logger;
  6200. +
  6201. +import com.l2jserver.L2DatabaseFactory;
  6202. +import com.l2jserver.gameserver.datatables.SkillTable;
  6203. +import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
  6204. +
  6205. +/**
  6206. + *
  6207. + * @author Nik
  6208. + *
  6209. + */
  6210. +public class CharacterAchievementSystem
  6211. +{
  6212. + private final L2PcInstance _owner;
  6213. + private static final Logger _log = Logger.getLogger(CharacterAchievementSystem.class.getName());
  6214. + private boolean _increasePts = false;
  6215. +
  6216. + private static int evasionPts = 0;
  6217. + private static int speedPts = 0;
  6218. + private static int atkspdPts = 0;
  6219. + private static int castingspdPts = 0;
  6220. + private static int critPts = 0;
  6221. +
  6222. + private static int olyPlayedPts = 0;
  6223. + private static int olyWonPts = 0;
  6224. +
  6225. + private static int enchantFailPts = 0;
  6226. + //TODO: Lines below this comment add to mysql & getHtml()
  6227. + private static int enchantSuccessPts = 0;
  6228. + private static int grandbossKilled = 0;
  6229. + private static int raidbossKilled = 0;
  6230. + private static int playersResed = 0;
  6231. + private static int insultsSpoken = 0;
  6232. + private static int bsoesUsed = 0;
  6233. + private static int firstBlood = 0;
  6234. + private static int doubleKill = 0;
  6235. + private static int trippleKill = 0;
  6236. + private static int dominating = 0;
  6237. + private static int megaKill = 0;
  6238. + private static int monsterKill = 0;
  6239. + private static int hollyShit = 0;
  6240. + private static int ownage = 0;
  6241. + private static int rampage = 0;
  6242. + private static int unstoppable = 0;
  6243. + private static int godlike = 0;
  6244. + private static int mobsKilled = 0;
  6245. + private static int fishesDone = 0;
  6246. + private static int fishesFailed = 0;
  6247. + private static int chestsOpened = 0;
  6248. +
  6249. + public CharacterAchievementSystem(L2PcInstance owner)
  6250. + {
  6251. + _owner = owner;
  6252. + loadData();
  6253. + _increasePts = true; // They are false on load, so they dont get increased on each relogin.
  6254. + }
  6255. +
  6256. + public void onHit()
  6257. + {
  6258. + switch (_increasePts ? ++atkspdPts : atkspdPts)
  6259. + {
  6260. +
  6261. + }
  6262. + }
  6263. +
  6264. + public void onEvade()
  6265. + {
  6266. + switch (_increasePts ? ++evasionPts : evasionPts)
  6267. + {
  6268. +
  6269. + }
  6270. + }
  6271. +
  6272. + public void onMagicCast()
  6273. + {
  6274. + switch (_increasePts ? ++castingspdPts : castingspdPts)
  6275. + {
  6276. +
  6277. + }
  6278. + }
  6279. +
  6280. + public void onCrit()
  6281. + {
  6282. + switch (_increasePts ? ++critPts : critPts)
  6283. + {
  6284. +
  6285. + }
  6286. + }
  6287. +
  6288. + public void onOlyWin()
  6289. + {
  6290. + switch (_increasePts ? ++olyWonPts : olyWonPts)
  6291. + {
  6292. +
  6293. + }
  6294. + }
  6295. +
  6296. + public void onOlyGamePlayed()
  6297. + {
  6298. + switch (_increasePts ? ++olyPlayedPts : olyPlayedPts)
  6299. + {
  6300. +
  6301. + }
  6302. + }
  6303. +
  6304. + public void onEnchant(boolean success)
  6305. + {
  6306. + if (!success) // Fail
  6307. + {
  6308. + switch (_increasePts ? ++enchantFailPts : enchantFailPts)
  6309. + {
  6310. +
  6311. + }
  6312. + }
  6313. + else
  6314. + {
  6315. + switch (_increasePts ? ++enchantSuccessPts : enchantSuccessPts)
  6316. + {
  6317. +
  6318. + }
  6319. + }
  6320. + }
  6321. +
  6322. + public void onGrandbossKill()
  6323. + {
  6324. + switch (_increasePts ? ++grandbossKilled : grandbossKilled)
  6325. + {
  6326. +
  6327. + }
  6328. + }
  6329. +
  6330. + public void onRaidbossKill()
  6331. + {
  6332. + switch (_increasePts ? ++raidbossKilled : raidbossKilled)
  6333. + {
  6334. +
  6335. + }
  6336. + }
  6337. +
  6338. + public void onResRequest()
  6339. + {
  6340. + switch (_increasePts ? ++playersResed : playersResed)
  6341. + {
  6342. +
  6343. + }
  6344. + }
  6345. +
  6346. + public void onInsult(String text)
  6347. + {
  6348. + if (text.contains(""))
  6349. + {
  6350. + switch (_increasePts ? ++insultsSpoken : insultsSpoken)
  6351. + {
  6352. +
  6353. + }
  6354. +
  6355. + }
  6356. +
  6357. + }
  6358. +
  6359. + public void onBsoeUse()
  6360. + {
  6361. + switch (_increasePts ? ++bsoesUsed : bsoesUsed)
  6362. + {
  6363. +
  6364. + }
  6365. + }
  6366. +
  6367. + public void onPvPKill(int killsInRow)
  6368. + {
  6369. + switch (killsInRow)
  6370. + {
  6371. + case 1:
  6372. + firstBlood++;
  6373. + case 2:
  6374. + doubleKill++;
  6375. + case 3:
  6376. + trippleKill++;
  6377. + case 4:
  6378. + dominating++;
  6379. + case 5:
  6380. + megaKill++;
  6381. + case 6:
  6382. + monsterKill++;
  6383. + case 7:
  6384. + hollyShit++;
  6385. + case 8:
  6386. + ownage++;
  6387. + case 9:
  6388. + rampage++;
  6389. + case 10:
  6390. + unstoppable++;
  6391. + case 16:
  6392. + godlike++;
  6393. + default:
  6394. + break;
  6395. + }
  6396. + }
  6397. +
  6398. + public void onMobKill()
  6399. + {
  6400. + switch (_increasePts ? ++mobsKilled : mobsKilled)
  6401. + {
  6402. +
  6403. + }
  6404. + }
  6405. +
  6406. + public void onFishingDone(boolean win)
  6407. + {
  6408. + if (win) // Fishing was successful
  6409. + {
  6410. + switch (_increasePts ? ++fishesDone : fishesDone)
  6411. + {
  6412. +
  6413. + }
  6414. + }
  6415. + else
  6416. + {
  6417. + switch (_increasePts ? ++fishesFailed : fishesFailed)
  6418. + {
  6419. +
  6420. + }
  6421. + }
  6422. + }
  6423. +
  6424. + public void onChestOpen()
  6425. + {
  6426. + switch (_increasePts ? ++chestsOpened : chestsOpened)
  6427. + {
  6428. +
  6429. + }
  6430. + }
  6431. +
  6432. + public static String getHtml()
  6433. + {
  6434. + StringBuilder sb = new StringBuilder();
  6435. + sb.append("<html><head><body>");
  6436. + sb.append("<br1>atkspdPts=");
  6437. + sb.append(atkspdPts);
  6438. + sb.append("<br1>speedPts=");
  6439. + sb.append(speedPts);
  6440. + sb.append("<br1>evasionPts=");
  6441. + sb.append(evasionPts);
  6442. + sb.append("<br1>castingspdPts=");
  6443. + sb.append(castingspdPts);
  6444. + sb.append("<br1>critPts=");
  6445. + sb.append(critPts);
  6446. + sb.append("<br1>olyPlayedPts=");
  6447. + sb.append(olyPlayedPts);
  6448. + sb.append("<br1>olyWonPts=");
  6449. + sb.append(olyWonPts);
  6450. + sb.append("<br1>enchantFailPts=");
  6451. + sb.append(enchantFailPts);
  6452. + sb.append("<br1>bsoe=");
  6453. + sb.append(bsoesUsed);
  6454. + sb.append("</body></head></html>");
  6455. +
  6456. + return sb.toString();
  6457. + }
  6458. +
  6459. + /**
  6460. + *
  6461. + * @param player
  6462. + * @param cha - if cha is NOT NULL, the check will do "anally", dualbox checks and gearpoints check.
  6463. + * @return
  6464. + */
  6465. + public static boolean checkOk(L2PcInstance player/*, L2Character cha*/)
  6466. + {
  6467. + if (player == null || player.getCAS() == null)
  6468. + return false;
  6469. + /*
  6470. + if (cha != null)
  6471. + {
  6472. + if (player.checkDualbox(cha.getActingPlayer())) // if cha.getActingPlayer() == null it will be false, no NPE
  6473. + return false;
  6474. + else if (player.isRelated("anally", cha))
  6475. + return false;
  6476. + else if ()
  6477. + }*/
  6478. +
  6479. + return true;
  6480. + }
  6481. +
  6482. + public void saveData()
  6483. + {
  6484. + Connection con = null;
  6485. + try
  6486. + {
  6487. + con = L2DatabaseFactory.getInstance().getConnection();
  6488. +
  6489. + PreparedStatement statement = con.prepareStatement("REPLACE INTO character_achievements (charId, charName, evasionPts, speedPts, atkspdPts, castingspdPts, critPts, olyPlayedPts, olyWonPts, enchantFailPts) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)");
  6490. + statement.setInt(1, _owner.getObjectId());
  6491. + statement.setString(2, _owner.getName());
  6492. + statement.setInt(3, evasionPts);
  6493. + statement.setInt(4, speedPts);
  6494. + statement.setInt(5, atkspdPts);
  6495. + statement.setInt(6, castingspdPts);
  6496. + statement.setInt(7, critPts);
  6497. + statement.setInt(8, olyPlayedPts);
  6498. + statement.setInt(9, olyWonPts);
  6499. + statement.setInt(10, enchantFailPts);
  6500. + statement.executeUpdate();
  6501. + statement.close();
  6502. + }
  6503. + catch (SQLException e)
  6504. + {
  6505. + _log.log(Level.SEVERE, "CharacterAchievementSystem: Failed to save data for player " + _owner.getName(), e);
  6506. + }
  6507. + finally
  6508. + {
  6509. + L2DatabaseFactory.close(con);
  6510. + }
  6511. + }
  6512. +
  6513. + private void loadData()
  6514. + {
  6515. + Connection con = null;
  6516. +
  6517. + try
  6518. + {
  6519. + con = L2DatabaseFactory.getInstance().getConnection();
  6520. + PreparedStatement statement = con.prepareStatement("SELECT * FROM character_achievements WHERE charId=?");
  6521. + statement.setInt(1, _owner.getObjectId());
  6522. + ResultSet rs = statement.executeQuery();
  6523. +
  6524. + while (rs.next())
  6525. + {
  6526. + evasionPts = rs.getInt("evasionPts");
  6527. + speedPts = rs.getInt("speedPts");
  6528. + atkspdPts = rs.getInt("atkspdPts");
  6529. + castingspdPts = rs.getInt("castingspdPts");
  6530. + critPts = rs.getInt("critPts");
  6531. +
  6532. + olyPlayedPts = rs.getInt("olyPlayedPts");
  6533. + olyWonPts = rs.getInt("olyWonPts");
  6534. +
  6535. + enchantFailPts = rs.getInt("enchantFailPts");
  6536. + }
  6537. +
  6538. + rs.close();
  6539. + statement.close();
  6540. + }
  6541. + catch (Exception e)
  6542. + {
  6543. + _log.log(Level.SEVERE, "CharacterAchievementSystem: Failed loading data for player " + _owner.getName(), e);
  6544. + }
  6545. + finally
  6546. + {
  6547. + L2DatabaseFactory.close(con);
  6548. + }
  6549. + }
  6550. +
  6551. + private void addSkill(int skillId, int level)
  6552. + {
  6553. + _owner.addSkill(SkillTable.getInstance().getInfo(skillId, level));
  6554. + }
  6555. +}
  6556. Index: java/com/l2jserver/gameserver/datatables/MultiSell.java
  6557. ===================================================================
  6558. --- java/com/l2jserver/gameserver/datatables/MultiSell.java (revision 4769)
  6559. +++ java/com/l2jserver/gameserver/datatables/MultiSell.java (working copy)
  6560. @@ -64,12 +64,14 @@
  6561. {
  6562. _entries = new TIntObjectHashMap<ListContainer>();
  6563. load();
  6564. + loadCustom();
  6565. }
  6566.  
  6567. public final void reload()
  6568. {
  6569. _entries.clear();
  6570. load();
  6571. + loadCustom();
  6572. }
  6573.  
  6574. /**
  6575. @@ -152,13 +154,13 @@
  6576. switch (id)
  6577. {
  6578. case CLAN_REPUTATION:
  6579. - player.getClan().takeReputationScore((int)amount, true);
  6580. + player.getClan().takeReputationScore((int) amount, true);
  6581. SystemMessage smsg = SystemMessage.getSystemMessage(SystemMessageId.S1_DEDUCTED_FROM_CLAN_REP);
  6582. smsg.addItemNumber(amount);
  6583. player.sendPacket(smsg);
  6584. return true;
  6585. case FAME:
  6586. - player.setFame(player.getFame() - (int)amount);
  6587. + player.setFame(player.getFame() - (int) amount);
  6588. player.sendPacket(new UserInfo(player));
  6589. player.sendPacket(new ExBrExtraUserInfo(player));
  6590. return true;
  6591. @@ -171,10 +173,10 @@
  6592. switch (id)
  6593. {
  6594. case CLAN_REPUTATION:
  6595. - player.getClan().addReputationScore((int)amount, true);
  6596. + player.getClan().addReputationScore((int) amount, true);
  6597. break;
  6598. case FAME:
  6599. - player.setFame((int)(player.getFame() + amount));
  6600. + player.setFame((int) (player.getFame() + amount));
  6601. player.sendPacket(new UserInfo(player));
  6602. player.sendPacket(new ExBrExtraUserInfo(player));
  6603. break;
  6604. @@ -187,7 +189,7 @@
  6605. int id = 0;
  6606. List<File> files = new FastList<File>();
  6607. hashFiles("data/multisell", files);
  6608. - hashFiles("data/multisell/custom", files);
  6609. + //hashFiles("data/multisell/custom", files);
  6610.  
  6611. for (File f : files)
  6612. {
  6613. @@ -220,6 +222,44 @@
  6614. _log.log(Level.INFO, "MultiSell: Loaded " + _entries.size() + " lists.");
  6615. }
  6616.  
  6617. + private final void loadCustom()
  6618. + {
  6619. + Document doc = null;
  6620. + int id = 0;
  6621. + List<File> files = new FastList<File>();
  6622. + hashFiles("data/multisell/custom", files);
  6623. +
  6624. + for (File f : files)
  6625. + {
  6626. + try
  6627. + {
  6628. + id = Integer.parseInt(f.getName().replaceAll(".xml", "").split(" ")[0]);
  6629. + DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
  6630. + factory.setValidating(false);
  6631. + factory.setIgnoringComments(true);
  6632. + doc = factory.newDocumentBuilder().parse(f);
  6633. + }
  6634. + catch (Exception e)
  6635. + {
  6636. + _log.log(Level.SEVERE, "Error loading custom file " + f, e);
  6637. + continue;
  6638. + }
  6639. +
  6640. + try
  6641. + {
  6642. + ListContainer list = parseDocument(doc);
  6643. + list.setListId(id);
  6644. + _entries.put(id, list);
  6645. + }
  6646. + catch (Exception e)
  6647. + {
  6648. + _log.log(Level.SEVERE, "Error in custom file " + f, e);
  6649. + }
  6650. + }
  6651. + verify();
  6652. + _log.config("MultiSell: Loaded " + _entries.size() + " custom lists.");
  6653. + }
  6654. +
  6655. private final ListContainer parseDocument(Document doc)
  6656. {
  6657. int entryId = 1;
  6658. @@ -329,14 +369,12 @@
  6659. for (Ingredient ing : ent.getIngredients())
  6660. {
  6661. if (!verifyIngredient(ing))
  6662. - _log.warning("[MultiSell] can't find ingredient with itemId: "
  6663. - + ing.getItemId() + " in list: " + list.getListId());
  6664. + _log.warning("[MultiSell] can't find ingredient with itemId: " + ing.getItemId() + " in list: " + list.getListId());
  6665. }
  6666. for (Ingredient ing : ent.getProducts())
  6667. {
  6668. if (!verifyIngredient(ing))
  6669. - _log.warning("[MultiSell] can't find product with itemId: "
  6670. - + ing.getItemId() + " in list: " + list.getListId());
  6671. + _log.warning("[MultiSell] can't find product with itemId: " + ing.getItemId() + " in list: " + list.getListId());
  6672. }
  6673. }
  6674. }
  6675. @@ -362,4 +400,4 @@
  6676. {
  6677. protected static final MultiSell _instance = new MultiSell();
  6678. }
  6679. -}
  6680. \ No newline at end of file
  6681. +}
  6682. Index: java/config/server.properties
  6683. ===================================================================
  6684. --- java/config/server.properties (revision 4769)
  6685. +++ java/config/server.properties (working copy)
  6686. @@ -25,7 +25,7 @@
  6687. # WARNING: <u><b><font color="red">Please don't change default IPs here if you don't know what are you doing!</font></b></u>
  6688. # WARNING: <u><b><font color="red">External/Internal IPs are now inside "ipconfig.xml" file.</font></b></u>
  6689. # Default: * (0.0.0.0)
  6690. -GameserverHostname = *
  6691. +GameserverHostname = 127.0.0.1
  6692.  
  6693. # Default: 7777
  6694. GameserverPort = 7777
  6695. @@ -44,11 +44,11 @@
  6696. # URL = jdbc:mysql://localhost/l2jgs (default)
  6697. # URL = jdbc:hsqldb:hsql://localhost/l2jgs
  6698. # URL = jdbc:sqlserver://localhost/database = l2jgs/user = sa/password =
  6699. -URL = jdbc:mysql://localhost/l2jgs
  6700. +URL = jdbc:mysql://localhost/l2jdb
  6701. # Database user info (default is "root" but it's not recommended)
  6702. Login = root
  6703. # Database connection password
  6704. -Password =
  6705. +Password = root
  6706.  
  6707. # Default: 100
  6708. MaximumDbConnections = 100
  6709. Index: java/com/l2jserver/gameserver/model/ChanceSkillList.java
  6710. ===================================================================
  6711. --- java/com/l2jserver/gameserver/model/ChanceSkillList.java (revision 4769)
  6712. +++ java/com/l2jserver/gameserver/model/ChanceSkillList.java (working copy)
  6713. @@ -123,6 +123,26 @@
  6714. if (_owner.isDead())
  6715. return;
  6716.  
  6717. + if (CharacterAchievementSystem.checkOk(_owner.getActingPlayer()))
  6718. + {
  6719. + switch (event)
  6720. + {
  6721. + case ChanceCondition.EVT_HIT:
  6722. + _owner.getActingPlayer().getCAS().onHit();
  6723. + break;
  6724. + case ChanceCondition.EVT_MAGIC:
  6725. + _owner.getActingPlayer().getCAS().onMagicCast();
  6726. + break;
  6727. + case ChanceCondition.EVT_CRIT:
  6728. + _owner.getActingPlayer().getCAS().onCrit();
  6729. + break;
  6730. + case ChanceCondition.EVT_EVADED_HIT:
  6731. + _owner.getActingPlayer().getCAS().onEvade();
  6732. + break;
  6733. + }
  6734. + }
  6735. +
  6736. +
  6737. final boolean playable = target instanceof L2Playable;
  6738. for (FastMap.Entry<IChanceSkillTrigger, ChanceCondition> e = head(), end = tail(); (e = e.getNext()) != end;)
  6739. {
  6740. Index: java/com/l2jserver/gameserver/network/clientpackets/RequestEnchantItem.java
  6741. ===================================================================
  6742. --- java/com/l2jserver/gameserver/network/clientpackets/RequestEnchantItem.java (revision 4769)
  6743. +++ java/com/l2jserver/gameserver/network/clientpackets/RequestEnchantItem.java (working copy)
  6744. @@ -20,6 +20,7 @@
  6745.  
  6746. import com.l2jserver.Config;
  6747. import com.l2jserver.gameserver.datatables.SkillTable;
  6748. +import com.l2jserver.gameserver.model.CharacterAchievementSystem;
  6749. import com.l2jserver.gameserver.model.L2ItemInstance;
  6750. import com.l2jserver.gameserver.model.L2Skill;
  6751. import com.l2jserver.gameserver.model.L2World;
  6752. @@ -166,6 +167,9 @@
  6753.  
  6754. if (Rnd.get(100) < chance)
  6755. {
  6756. + if (CharacterAchievementSystem.checkOk(activeChar))
  6757. + activeChar.getCAS().onEnchant(true);
  6758. +
  6759. // success
  6760. item.setEnchantLevel(item.getEnchantLevel() + 1);
  6761. item.updateDatabase();
  6762. @@ -208,6 +212,9 @@
  6763. }
  6764. else
  6765. {
  6766. + if (CharacterAchievementSystem.checkOk(activeChar))
  6767. + activeChar.getCAS().onEnchant(false);
  6768. +
  6769. if (scrollTemplate.isSafe())
  6770. {
  6771. // safe enchant - remain old value
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!