API tools faq
paste
Advertisement
Guest User

ctf CORE

a guest
Apr 28th, 2010
342
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 101.40 KB | None | 0 0
raw download clone embed print report
  1. ### Eclipse Workspace Patch 1.0
  2. #P L2_GameServer
  3. Index: java/com/l2jserver/gameserver/model/entity/CTF.java
  4. ===================================================================
  5. --- java/com/l2jserver/gameserver/model/entity/CTF.java (revision 0)
  6. +++ java/com/l2jserver/gameserver/model/entity/CTF.java (revision 0)
  7. @@ -0,0 +1,2289 @@
  8. +/*
  9. + * This program is free software: you can redistribute it and/or modify it under
  10. + * the terms of the GNU General Public License as published by the Free Software
  11. + * Foundation, either version 3 of the License, or (at your option) any later
  12. + * version.
  13. + *
  14. + * This program is distributed in the hope that it will be useful, but WITHOUT
  15. + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  16. + * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
  17. + * details.
  18. + *
  19. + * You should have received a copy of the GNU General Public License along with
  20. + * this program. If not, see <http://www.gnu.org/licenses/>.
  21. + */
  22. +package com.l2jserver.gameserver.model.entity;
  23. +
  24. +/**
  25. + *
  26. + * @author SqueezeD & Darki699 (idea by FBIAgent)
  27. + *
  28. + */
  29. +
  30. +import java.sql.Connection;
  31. +import java.sql.PreparedStatement;
  32. +import java.sql.ResultSet;
  33. +import java.sql.SQLException;
  34. +import java.util.Vector;
  35. +
  36. +import javolution.text.TextBuilder;
  37. +
  38. +import java.util.logging.Logger;
  39. +
  40. +import com.l2jserver.Config;
  41. +import com.l2jserver.L2DatabaseFactory;
  42. +import com.l2jserver.gameserver.Announcements;
  43. +import com.l2jserver.gameserver.ThreadPoolManager;
  44. +import com.l2jserver.gameserver.datatables.ItemTable;
  45. +import com.l2jserver.gameserver.datatables.NpcTable;
  46. +import com.l2jserver.gameserver.datatables.SpawnTable;
  47. +import com.l2jserver.gameserver.model.L2Effect;
  48. +import com.l2jserver.gameserver.model.L2ItemInstance;
  49. +import com.l2jserver.gameserver.model.L2Party;
  50. +import com.l2jserver.gameserver.model.L2Radar;
  51. +import com.l2jserver.gameserver.model.L2Spawn;
  52. +import com.l2jserver.gameserver.model.actor.L2Summon;
  53. +import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
  54. +import com.l2jserver.gameserver.model.actor.instance.L2PetInstance;
  55. +import com.l2jserver.gameserver.model.itemcontainer.Inventory;
  56. +import com.l2jserver.gameserver.network.SystemMessageId;
  57. +import com.l2jserver.gameserver.network.serverpackets.ActionFailed;
  58. +import com.l2jserver.gameserver.network.serverpackets.CreatureSay;
  59. +import com.l2jserver.gameserver.network.serverpackets.InventoryUpdate;
  60. +import com.l2jserver.gameserver.network.serverpackets.ItemList;
  61. +import com.l2jserver.gameserver.network.serverpackets.MagicSkillUse;
  62. +import com.l2jserver.gameserver.network.serverpackets.NpcHtmlMessage;
  63. +import com.l2jserver.gameserver.network.serverpackets.PlaySound;
  64. +import com.l2jserver.gameserver.network.serverpackets.RadarControl;
  65. +import com.l2jserver.gameserver.network.serverpackets.SystemMessage;
  66. +import com.l2jserver.gameserver.network.serverpackets.SocialAction;
  67. +import com.l2jserver.gameserver.templates.chars.L2NpcTemplate;
  68. +import com.l2jserver.util.Rnd;
  69. +
  70. +public class CTF
  71. +{
  72. + private final static Logger _log = Logger.getLogger(CTF.class.getName());
  73. + private static int _FlagNPC = 35062,
  74. + _FLAG_IN_HAND_ITEM_ID = 6718;
  75. + public static String _eventName = new String(),
  76. + _eventDesc = new String(),
  77. + _topTeam = new String(),
  78. + _joiningLocationName = new String();
  79. + public static Vector<String> _teams = new Vector<String>(),
  80. + _savePlayers = new Vector<String>(),
  81. + _savePlayerTeams = new Vector<String>();
  82. + public static Vector<L2PcInstance> _players = new Vector<L2PcInstance>(),
  83. + _playersShuffle = new Vector<L2PcInstance>();
  84. + public static Vector<Integer> _teamPlayersCount = new Vector<Integer>(),
  85. + _teamColors = new Vector<Integer>(),
  86. + _teamsX = new Vector<Integer>(),
  87. + _teamsY = new Vector<Integer>(),
  88. + _teamsZ = new Vector<Integer>();
  89. + public static boolean _joining = false,
  90. + _teleport = false,
  91. + _started = false,
  92. + _sitForced = false;
  93. + public static L2Spawn _npcSpawn;
  94. + public static int _npcId = 0,
  95. + _npcX = 0,
  96. + _npcY = 0,
  97. + _npcZ = 0,
  98. + _npcHeading = 0,
  99. + _rewardId = 0,
  100. + _rewardAmount = 0,
  101. + _minlvl = 0,
  102. + _maxlvl = 0,
  103. + _joinTime = 0,
  104. + _eventTime = 0,
  105. + _minPlayers = 0,
  106. + _maxPlayers = 0;
  107. + public static Vector<Integer> _teamPointsCount = new Vector<Integer>();
  108. + public static Vector<Integer> _flagIds = new Vector<Integer>(),
  109. + _flagsX = new Vector<Integer>(),
  110. + _flagsY = new Vector<Integer>(),
  111. + _flagsZ = new Vector<Integer>();
  112. + public static Vector<L2Spawn> _flagSpawns = new Vector<L2Spawn>(),
  113. + _throneSpawns = new Vector<L2Spawn>();
  114. + public static Vector<Boolean> _flagsTaken = new Vector<Boolean>();
  115. + public static int _topScore = 0,
  116. + eventCenterX = 0,
  117. + eventCenterY = 0,
  118. + eventCenterZ = 0,
  119. + eventOffset = 0;
  120. +
  121. + public static void showFlagHtml(L2PcInstance eventPlayer, String objectId, String teamName)
  122. + {
  123. + if (eventPlayer == null)
  124. + return;
  125. +
  126. + try
  127. + {
  128. + NpcHtmlMessage adminReply = new NpcHtmlMessage(5);
  129. +
  130. + TextBuilder replyMSG = new TextBuilder();
  131. +
  132. + replyMSG.append("<html><body><center>");
  133. + replyMSG.append("CTF Flag<br><br>");
  134. + replyMSG.append("<font color=\"00FF00\">" + teamName + "'s Flag</font><br>");
  135. + if (eventPlayer._teamNameCTF != null && eventPlayer._teamNameCTF.equals(teamName))
  136. + replyMSG.append("<font color=\"LEVEL\">This is your Flag</font><br>");
  137. + else
  138. + replyMSG.append("<font color=\"LEVEL\">Enemy Flag!</font><br>");
  139. + if (_started)
  140. + {
  141. + processInFlagRange(eventPlayer);
  142. + }
  143. + else
  144. + replyMSG.append("CTF match is not in progress yet.<br>Wait for a GM to start the event<br>");
  145. + replyMSG.append("</center></body></html>");
  146. + adminReply.setHtml(replyMSG.toString());
  147. + eventPlayer.sendPacket(adminReply);
  148. + }
  149. + catch (Exception e)
  150. + {
  151. + _log.warning("" + "CTF Engine[showEventHtlm(" + eventPlayer.getName() + ", " + objectId + ")]: exception: " + e.getStackTrace());
  152. + }
  153. + }
  154. +
  155. + public static void CheckRestoreFlags()
  156. + {
  157. + Vector<Integer> teamsTakenFlag = new Vector<Integer>();
  158. + try
  159. + {
  160. + for (L2PcInstance player : _players)
  161. + { //if there's a player with a flag
  162. + //add the index of the team who's FLAG WAS TAKEN to the list
  163. + if (player != null)
  164. + {
  165. + if (player.isOnline() == 0 && player._haveFlagCTF)// logged off with a flag in his hands
  166. + {
  167. + AnnounceToPlayers(false, _eventName + "(CTF): " + player.getName() + " logged off with a CTF flag!");
  168. + player._haveFlagCTF = false;
  169. + if (_teams.indexOf(player._teamNameHaveFlagCTF) >= 0)
  170. + {
  171. + if (_flagsTaken.get(_teams.indexOf(player._teamNameHaveFlagCTF)))
  172. + {
  173. + _flagsTaken.set(_teams.indexOf(player._teamNameHaveFlagCTF), false);
  174. + spawnFlag(player._teamNameHaveFlagCTF);
  175. + AnnounceToPlayers(false, _eventName + "(CTF): " + player._teamNameHaveFlagCTF + " flag now returned to place.");
  176. + }
  177. + }
  178. + removeFlagFromPlayer(player);
  179. + player._teamNameHaveFlagCTF = null;
  180. + return;
  181. + }
  182. + else if (player._haveFlagCTF)
  183. + teamsTakenFlag.add(_teams.indexOf(player._teamNameHaveFlagCTF));
  184. + }
  185. + }
  186. + //Go over the list of ALL teams
  187. + for (String team : _teams)
  188. + {
  189. + if (team == null)
  190. + continue;
  191. + int index = _teams.indexOf(team);
  192. + if (!teamsTakenFlag.contains(index))
  193. + {
  194. + if (_flagsTaken.get(index))
  195. + {
  196. + _flagsTaken.set(index, false);
  197. + spawnFlag(team);
  198. + AnnounceToPlayers(false, _eventName + "(CTF): " + team + " flag returned due to player error.");
  199. + }
  200. + }
  201. + }
  202. + //Check if a player ran away from the event holding a flag:
  203. + for (L2PcInstance player : _players)
  204. + {
  205. + if (player != null && player._haveFlagCTF)
  206. + {
  207. + if (isOutsideCTFArea(player))
  208. + {
  209. + AnnounceToPlayers(false, _eventName + "(CTF): " + player.getName() + " escaped from the event holding a flag!");
  210. + player._haveFlagCTF = false;
  211. + if (_teams.indexOf(player._teamNameHaveFlagCTF) >= 0)
  212. + {
  213. + if (_flagsTaken.get(_teams.indexOf(player._teamNameHaveFlagCTF)))
  214. + {
  215. + _flagsTaken.set(_teams.indexOf(player._teamNameHaveFlagCTF), false);
  216. + spawnFlag(player._teamNameHaveFlagCTF);
  217. + AnnounceToPlayers(false, _eventName + "(CTF): " + player._teamNameHaveFlagCTF + " flag now returned to place.");
  218. + }
  219. + }
  220. + removeFlagFromPlayer(player);
  221. + player._teamNameHaveFlagCTF = null;
  222. + player.teleToLocation(_teamsX.get(_teams.indexOf(player._teamNameCTF)), _teamsY.get(_teams.indexOf(player._teamNameCTF)), _teamsZ
  223. + .get(_teams.indexOf(player._teamNameCTF)));
  224. + player.sendMessage("You have been returned to your team spawn");
  225. + return;
  226. + }
  227. + }
  228. + }
  229. + }
  230. + catch (Exception e)
  231. + {
  232. + _log.warning("CTF.restoreFlags() Error:" + e.toString());
  233. + }
  234. + }
  235. +
  236. + public static void kickPlayerFromCTf(L2PcInstance playerToKick)
  237. + {
  238. + if (playerToKick == null)
  239. + return;
  240. +
  241. + if (_joining)
  242. + {
  243. + _playersShuffle.remove(playerToKick);
  244. + _players.remove(playerToKick);
  245. + playerToKick._inEventCTF = false;
  246. + playerToKick._teamNameCTF = new String();
  247. + }
  248. + if (_started || _teleport)
  249. + {
  250. + _playersShuffle.remove(playerToKick);
  251. + playerToKick._inEventCTF = false;
  252. + removePlayer(playerToKick);
  253. + if (playerToKick.isOnline() != 0)
  254. + {
  255. + playerToKick.getAppearance().setNameColor(playerToKick._originalNameColorCTF);
  256. + playerToKick.setKarma(playerToKick._originalKarmaCTF);
  257. + playerToKick.setTitle(playerToKick._originalTitleCTF);
  258. + playerToKick.broadcastUserInfo();
  259. + playerToKick.sendMessage("You have been kicked from the CTF.");
  260. + playerToKick.teleToLocation(_npcX, _npcY, _npcZ, false);
  261. + }
  262. + }
  263. + }
  264. +
  265. + public static void AnnounceToPlayers(Boolean toall, String announce)
  266. + {
  267. + if (toall)
  268. + Announcements.getInstance().announceToAll(announce);
  269. + else
  270. + {
  271. + CreatureSay cs = new CreatureSay(0, 2, "", "Announcements : " + announce);
  272. + if (_players != null && !_players.isEmpty())
  273. + {
  274. + for (L2PcInstance player : _players)
  275. + {
  276. + if (player != null && player.isOnline() != 0)
  277. + player.sendPacket(cs);
  278. + }
  279. + }
  280. + }
  281. + }
  282. +
  283. + public static void Started(L2PcInstance player)
  284. + {
  285. + player._teamNameHaveFlagCTF = null;
  286. + player._haveFlagCTF = false;
  287. + }
  288. +
  289. + public static void StartEvent()
  290. + {
  291. + for (L2PcInstance player : _players)
  292. + {
  293. + if (player != null)
  294. + {
  295. + player._teamNameHaveFlagCTF = null;
  296. + player._haveFlagCTF = false;
  297. + }
  298. + }
  299. + AnnounceToPlayers(false, _eventName + "(CTF): Started. Go Capture the Flags!");
  300. + }
  301. +
  302. + public static void addFlagToPlayer(L2PcInstance _player)
  303. + {
  304. + //remove items from the player hands (right, left, both)
  305. + // This is NOT a BUG, I don't want them to see the icon they have 8D
  306. + L2ItemInstance wpn = _player.getInventory().getPaperdollItem(Inventory.PAPERDOLL_RHAND);
  307. + if (wpn == null)
  308. + {
  309. + wpn = _player.getInventory().getPaperdollItem(Inventory.PAPERDOLL_RHAND);
  310. + if (wpn != null)
  311. + _player.getInventory().unEquipItemInBodySlotAndRecord(Inventory.PAPERDOLL_RHAND);
  312. + }
  313. + else
  314. + {
  315. + _player.getInventory().unEquipItemInBodySlotAndRecord(Inventory.PAPERDOLL_RHAND);
  316. + wpn = _player.getInventory().getPaperdollItem(Inventory.PAPERDOLL_LHAND);
  317. + if (wpn != null)
  318. + _player.getInventory().unEquipItemInBodySlotAndRecord(Inventory.PAPERDOLL_LHAND);
  319. + }
  320. + //add the flag in his hands
  321. + _player.getInventory().equipItem(ItemTable.getInstance().createItem("", CTF._FLAG_IN_HAND_ITEM_ID, 1, _player, null));
  322. + _player.broadcastPacket(new SocialAction(_player.getObjectId(), 16)); //amazing glow
  323. + _player._haveFlagCTF = true;
  324. + _player.broadcastUserInfo();
  325. + CreatureSay cs = new CreatureSay(_player.getObjectId(), 15, ":", "You got it! Run back! ::"); // 8D
  326. + _player.sendPacket(cs);
  327. + }
  328. +
  329. + public static void removeFlagFromPlayer(L2PcInstance player)
  330. + {
  331. + L2ItemInstance wpn = player.getInventory().getPaperdollItem(Inventory.PAPERDOLL_RHAND);
  332. + player._haveFlagCTF = false;
  333. + if (wpn != null)
  334. + {
  335. + L2ItemInstance[] unequiped = player.getInventory().unEquipItemInBodySlotAndRecord(wpn.getItem().getBodyPart());
  336. + player.getInventory().destroyItemByItemId("", CTF._FLAG_IN_HAND_ITEM_ID, 1, player, null);
  337. + InventoryUpdate iu = new InventoryUpdate();
  338. + for (L2ItemInstance element : unequiped)
  339. + iu.addModifiedItem(element);
  340. + player.sendPacket(iu);
  341. + player.sendPacket(new ItemList(player, true)); // get your weapon back now ...
  342. + player.abortAttack();
  343. + player.broadcastUserInfo();
  344. + }
  345. + else
  346. + {
  347. + player.getInventory().destroyItemByItemId("", CTF._FLAG_IN_HAND_ITEM_ID, 1, player, null);
  348. + player.sendPacket(new ItemList(player, true)); // get your weapon back now ...
  349. + player.abortAttack();
  350. + player.broadcastUserInfo();
  351. + }
  352. + }
  353. +
  354. + public static void setTeamFlag(String teamName, L2PcInstance activeChar)
  355. + {
  356. + int index = _teams.indexOf(teamName);
  357. +
  358. + if (index == -1)
  359. + return;
  360. + addOrSet(_teams.indexOf(teamName), null, false, _FlagNPC, activeChar.getX(), activeChar.getY(), activeChar.getZ());
  361. + }
  362. +
  363. + public static void setTeamFlag(String teamName, int x, int y, int z)
  364. + {
  365. + int index = _teams.indexOf(teamName);
  366. +
  367. + if (index == -1)
  368. + return;
  369. + addOrSet(_teams.indexOf(teamName), null, false, _FlagNPC, x, y, z);
  370. + }
  371. +
  372. + public static void spawnAllFlags()
  373. + {
  374. + while (_flagSpawns.size() < _teams.size())
  375. + _flagSpawns.add(null);
  376. + while (_throneSpawns.size() < _teams.size())
  377. + _throneSpawns.add(null);
  378. + for (String team : _teams)
  379. + {
  380. + int index = _teams.indexOf(team);
  381. + L2NpcTemplate tmpl = NpcTable.getInstance().getTemplate(_flagIds.get(index));
  382. + L2NpcTemplate throne = NpcTable.getInstance().getTemplate(32027);
  383. + try
  384. + {
  385. + //spawn throne
  386. + _throneSpawns.set(index, new L2Spawn(throne));
  387. + _throneSpawns.get(index).setLocx(_flagsX.get(index));
  388. + _throneSpawns.get(index).setLocy(_flagsY.get(index));
  389. + _throneSpawns.get(index).setLocz(_flagsZ.get(index) - 10);
  390. + _throneSpawns.get(index).setAmount(1);
  391. + _throneSpawns.get(index).setHeading(0);
  392. + _throneSpawns.get(index).setRespawnDelay(1);
  393. + SpawnTable.getInstance().addNewSpawn(_throneSpawns.get(index), false);
  394. + _throneSpawns.get(index).init();
  395. + _throneSpawns.get(index).getLastSpawn().getStatus().setCurrentHp(999999999);
  396. + _throneSpawns.get(index).getLastSpawn().decayMe();
  397. + _throneSpawns.get(index).getLastSpawn().spawnMe(_throneSpawns.get(index).getLastSpawn().getX(), _throneSpawns.get(index).getLastSpawn().getY(), _throneSpawns.get(index).getLastSpawn().getZ());
  398. + _throneSpawns.get(index).getLastSpawn().setTitle(team + " Throne");
  399. + _throneSpawns.get(index).getLastSpawn().broadcastPacket(new MagicSkillUse(_throneSpawns.get(index).getLastSpawn(), _throneSpawns.get(index).getLastSpawn(), 1036, 1, 5500, 1));
  400. + _throneSpawns.get(index).getLastSpawn()._isCTF_throneSpawn = true;
  401. +
  402. + //spawn flag
  403. + _flagSpawns.set(index, new L2Spawn(tmpl));
  404. + _flagSpawns.get(index).setLocx(_flagsX.get(index));
  405. + _flagSpawns.get(index).setLocy(_flagsY.get(index));
  406. + _flagSpawns.get(index).setLocz(_flagsZ.get(index));
  407. + _flagSpawns.get(index).setAmount(1);
  408. + _flagSpawns.get(index).setHeading(0);
  409. + _flagSpawns.get(index).setRespawnDelay(1);
  410. + SpawnTable.getInstance().addNewSpawn(_flagSpawns.get(index), false);
  411. + _flagSpawns.get(index).init();
  412. + _flagSpawns.get(index).getLastSpawn().getStatus().setCurrentHp(999999999);
  413. + _flagSpawns.get(index).getLastSpawn().setTitle(team + "'s Flag");
  414. + _flagSpawns.get(index).getLastSpawn()._CTF_FlagTeamName = team;
  415. + _flagSpawns.get(index).getLastSpawn().decayMe();
  416. + _flagSpawns.get(index).getLastSpawn().spawnMe(_flagSpawns.get(index).getLastSpawn().getX(), _flagSpawns.get(index).getLastSpawn().getY(), _flagSpawns.get(index).getLastSpawn().getZ());
  417. + _flagSpawns.get(index).getLastSpawn()._isCTF_Flag = true;
  418. + if(index == (_teams.size() - 1))
  419. + calculateOutSideOfCTF(); // sets event boundaries so players don't run with the flag.
  420. + }
  421. + catch (Exception e)
  422. + {
  423. + _log.warning("CTF Engine[spawnAllFlags()]: exception: " + e.getStackTrace());
  424. + }
  425. + }
  426. + }
  427. +
  428. + public static void processTopTeam()
  429. + {
  430. +
  431. + _topTeam = null;
  432. + for (String team : _teams)
  433. + {
  434. + if (teamPointsCount(team) == _topScore && _topScore > 0)
  435. + _topTeam = null;
  436. + if (teamPointsCount(team) > _topScore)
  437. + {
  438. + _topTeam = team;
  439. + _topScore = teamPointsCount(team);
  440. + }
  441. + }
  442. + if (_topScore <= 0)
  443. + {
  444. + AnnounceToPlayers(true, _eventName + "(CTF): No flags taken.");
  445. + }
  446. + else
  447. + {
  448. + if (_topTeam == null)
  449. + AnnounceToPlayers(true, _eventName + "(CTF): Maximum flags taken : " + _topScore + " flags! No one won.");
  450. + else
  451. + {
  452. + AnnounceToPlayers(true, _eventName + "(CTF): Team " + _topTeam + " wins the match, with " + _topScore + " flags taken!");
  453. + rewardTeam(_topTeam);
  454. + }
  455. + }
  456. + teleportFinish();
  457. + }
  458. +
  459. + public static void unspawnAllFlags()
  460. + {
  461. + try
  462. + {
  463. + if (_throneSpawns == null || _flagSpawns == null || _teams == null)
  464. + return;
  465. + for (String team : _teams)
  466. + {
  467. + int index = _teams.indexOf(team);
  468. + if (_throneSpawns.get(index) != null)
  469. + {
  470. + _throneSpawns.get(index).getLastSpawn().deleteMe();
  471. + _throneSpawns.get(index).stopRespawn();
  472. + SpawnTable.getInstance().deleteSpawn(_throneSpawns.get(index), true);
  473. + }
  474. + if (_flagSpawns.get(index) != null)
  475. + {
  476. + _flagSpawns.get(index).getLastSpawn().deleteMe();
  477. + _flagSpawns.get(index).stopRespawn();
  478. + SpawnTable.getInstance().deleteSpawn(_flagSpawns.get(index), true);
  479. + }
  480. + }
  481. + _throneSpawns.removeAllElements();
  482. + }
  483. + catch (Throwable t)
  484. + {
  485. + _log.warning("CTF Engine[unspawnAllFlags()]: exception: " + t.getStackTrace());
  486. + }
  487. + }
  488. +
  489. + private static void unspawnFlag(String teamName)
  490. + {
  491. + int index = _teams.indexOf(teamName);
  492. +
  493. + _flagSpawns.get(index).getLastSpawn().deleteMe();
  494. + _flagSpawns.get(index).stopRespawn();
  495. + SpawnTable.getInstance().deleteSpawn(_flagSpawns.get(index), true);
  496. + }
  497. +
  498. + public static void spawnFlag(String teamName)
  499. + {
  500. + int index = _teams.indexOf(teamName);
  501. + L2NpcTemplate tmpl = NpcTable.getInstance().getTemplate(_flagIds.get(index));
  502. +
  503. + try
  504. + {
  505. + _flagSpawns.set(index, new L2Spawn(tmpl));
  506. +
  507. + _flagSpawns.get(index).setLocx(_flagsX.get(index));
  508. + _flagSpawns.get(index).setLocy(_flagsY.get(index));
  509. + _flagSpawns.get(index).setLocz(_flagsZ.get(index));
  510. + _flagSpawns.get(index).setAmount(1);
  511. + _flagSpawns.get(index).setHeading(0);
  512. + _flagSpawns.get(index).setRespawnDelay(1);
  513. +
  514. + SpawnTable.getInstance().addNewSpawn(_flagSpawns.get(index), false);
  515. +
  516. + _flagSpawns.get(index).init();
  517. + _flagSpawns.get(index).getLastSpawn().getStatus().setCurrentHp(999999999);
  518. + _flagSpawns.get(index).getLastSpawn().setTitle(teamName + "'s Flag");
  519. + _flagSpawns.get(index).getLastSpawn()._CTF_FlagTeamName = teamName;
  520. + _flagSpawns.get(index).getLastSpawn()._isCTF_Flag = true;
  521. + _flagSpawns.get(index).getLastSpawn().decayMe();
  522. + _flagSpawns.get(index).getLastSpawn().spawnMe(_flagSpawns.get(index).getLastSpawn().getX(), _flagSpawns.get(index).getLastSpawn().getY(),
  523. + _flagSpawns.get(index).getLastSpawn().getZ());
  524. + }
  525. + catch (Exception e)
  526. + {
  527. + _log.warning("CTF Engine[spawnFlag(" + teamName + ")]: exception: " + e.getStackTrace());
  528. + }
  529. + }
  530. +
  531. + public static boolean InRangeOfFlag(L2PcInstance _player, int flagIndex, int offset)
  532. + {
  533. + if (_player.getX() > CTF._flagsX.get(flagIndex) - offset && _player.getX() < CTF._flagsX.get(flagIndex) + offset
  534. + && _player.getY() > CTF._flagsY.get(flagIndex) - offset && _player.getY() < CTF._flagsY.get(flagIndex) + offset
  535. + && _player.getZ() > CTF._flagsZ.get(flagIndex) - offset && _player.getZ() < CTF._flagsZ.get(flagIndex) + offset)
  536. + return true;
  537. + return false;
  538. + }
  539. +
  540. + public static void processInFlagRange(L2PcInstance _player)
  541. + {
  542. + try
  543. + {
  544. + CheckRestoreFlags();
  545. + for (String team : _teams)
  546. + {
  547. + if (team.equals(_player._teamNameCTF))
  548. + {
  549. + int indexOwn = _teams.indexOf(_player._teamNameCTF);
  550. +
  551. + //if player is near his team flag holding the enemy flag
  552. + if (InRangeOfFlag(_player, indexOwn, 100) && !_flagsTaken.get(indexOwn) && _player._haveFlagCTF)
  553. + {
  554. + int indexEnemy = _teams.indexOf(_player._teamNameHaveFlagCTF);
  555. + //return enemy flag to place
  556. + _flagsTaken.set(indexEnemy, false);
  557. + spawnFlag(_player._teamNameHaveFlagCTF);
  558. + //remove the flag from this player
  559. + _player.broadcastPacket(new SocialAction(_player.getObjectId(), 16)); // amazing glow
  560. + _player.broadcastUserInfo();
  561. + _player.broadcastPacket(new SocialAction(_player.getObjectId(), 3)); // Victory
  562. + _player.broadcastUserInfo();
  563. + removeFlagFromPlayer(_player);
  564. + _teamPointsCount.set(indexOwn, teamPointsCount(team) + 1);
  565. + _player.broadcastPacket(new PlaySound(0, "ItemSound.quest_finish", 1, _player.getObjectId(), _player.getX(), _player.getY(), _player
  566. + .getZ()));
  567. + _player.broadcastUserInfo();
  568. + AnnounceToPlayers(false, _eventName + "(CTF): " + _player.getName() + " scores for " + _player._teamNameCTF + ".");
  569. + }
  570. + }
  571. + else
  572. + {
  573. + int indexEnemy = _teams.indexOf(team);
  574. + //if the player is near a enemy flag
  575. + if (InRangeOfFlag(_player, indexEnemy, 100) && !_flagsTaken.get(indexEnemy) && !_player._haveFlagCTF && !_player.isDead())
  576. + {
  577. + if(_player.isRidingStrider() || _player.isFlying())
  578. + {
  579. + _player.sendPacket(new SystemMessage(SystemMessageId.YOU_CANNOT_MOUNT_A_STEED_WHILE_A_PET_OR_A_SERVITOR_IS_SUMMONED));
  580. + break;
  581. + }
  582. +
  583. + _flagsTaken.set(indexEnemy, true);
  584. + unspawnFlag(team);
  585. + _player._teamNameHaveFlagCTF = team;
  586. + addFlagToPlayer(_player);
  587. + _player.broadcastUserInfo();
  588. + _player._haveFlagCTF = true;
  589. + AnnounceToPlayers(false, _eventName + "(CTF): " + team + " flag taken by " + _player.getName() + "...");
  590. + pointTeamTo(_player, team);
  591. + break;
  592. + }
  593. + }
  594. + }
  595. + }
  596. + catch (Exception e)
  597. + {
  598. + e.printStackTrace();
  599. + }
  600. + }
  601. +
  602. + public static void pointTeamTo(L2PcInstance hasFlag, String ourFlag)
  603. + {
  604. + try
  605. + {
  606. + for (L2PcInstance player : _players)
  607. + {
  608. + if (player != null && player.isOnline() != 0)
  609. + {
  610. + if (player._teamNameCTF.equals(ourFlag))
  611. + {
  612. + player.sendMessage(hasFlag.getName() + " took your flag!");
  613. + if (player._haveFlagCTF)
  614. + {
  615. + player.sendMessage("You can not return the flag to headquarters, until your flag is returned to it's place.");
  616. + player.sendPacket(new RadarControl(1, 1, player.getX(), player.getY(), player.getZ()));
  617. + }
  618. + else
  619. + {
  620. + player.sendPacket(new RadarControl(0, 1, hasFlag.getX(), hasFlag.getY(), hasFlag.getZ()));
  621. + L2Radar rdr = new L2Radar(player);
  622. + L2Radar.RadarOnPlayer radar = rdr.new RadarOnPlayer(hasFlag, player);
  623. + ThreadPoolManager.getInstance().scheduleGeneral(radar, 10000 + Rnd.get(30000));
  624. + }
  625. + }
  626. + }
  627. + }
  628. + }
  629. + catch (Throwable t)
  630. + {
  631. + }
  632. + }
  633. +
  634. + public static int teamPointsCount(String teamName)
  635. + {
  636. + int index = _teams.indexOf(teamName);
  637. +
  638. + if (index == -1)
  639. + return -1;
  640. +
  641. + return _teamPointsCount.get(index);
  642. + }
  643. +
  644. + public static void setTeamPointsCount(String teamName, int teamPointCount)
  645. + {
  646. + int index = _teams.indexOf(teamName);
  647. +
  648. + if (index == -1)
  649. + return;
  650. +
  651. + _teamPointsCount.set(index, teamPointCount);
  652. + }
  653. +
  654. + public static int teamPlayersCount(String teamName)
  655. + {
  656. + int index = _teams.indexOf(teamName);
  657. +
  658. + if (index == -1)
  659. + return -1;
  660. +
  661. + return _teamPlayersCount.get(index);
  662. + }
  663. +
  664. + public static void setTeamPlayersCount(String teamName, int teamPlayersCount)
  665. + {
  666. + int index = _teams.indexOf(teamName);
  667. +
  668. + if (index == -1)
  669. + return;
  670. +
  671. + _teamPlayersCount.set(index, teamPlayersCount);
  672. + }
  673. +
  674. + public static void setNpcPos(L2PcInstance activeChar)
  675. + {
  676. + _npcX = activeChar.getX();
  677. + _npcY = activeChar.getY();
  678. + _npcZ = activeChar.getZ();
  679. + _npcHeading = activeChar.getHeading();
  680. + }
  681. +
  682. + public static void setNpcPos(int x, int y, int z)
  683. + {
  684. + _npcX = x;
  685. + _npcY = y;
  686. + _npcZ = z;
  687. + }
  688. +
  689. + public static void addTeam(String teamName)
  690. + {
  691. + if (!checkTeamOk())
  692. + {
  693. + if (Config.DEBUG)
  694. + _log.fine("CTF Engine[addTeam(" + teamName + ")]: checkTeamOk() = false");
  695. + return;
  696. + }
  697. +
  698. + if (teamName.equals(" "))
  699. + return;
  700. +
  701. + _teams.add(teamName);
  702. + _teamPlayersCount.add(0);
  703. + _teamColors.add(0);
  704. + _teamsX.add(0);
  705. + _teamsY.add(0);
  706. + _teamsZ.add(0);
  707. + _teamPointsCount.add(0);
  708. + addOrSet(_teams.indexOf(teamName), null, false, _FlagNPC, 0, 0, 0);
  709. + }
  710. +
  711. + private static void addOrSet(int listSize, L2Spawn flagSpawn, boolean flagsTaken, int flagId, int flagX, int flagY, int flagZ)
  712. + {
  713. + while (_flagsX.size() <= listSize)
  714. + {
  715. + _flagSpawns.add(null);
  716. + _flagsTaken.add(false);
  717. + _flagIds.add(_FlagNPC);
  718. + _flagsX.add(0);
  719. + _flagsY.add(0);
  720. + _flagsZ.add(0);
  721. + }
  722. + _flagSpawns.set(listSize, flagSpawn);
  723. + _flagsTaken.set(listSize, flagsTaken);
  724. + _flagIds.set(listSize, flagId);
  725. + _flagsX.set(listSize, flagX);
  726. + _flagsY.set(listSize, flagY);
  727. + _flagsZ.set(listSize, flagZ);
  728. + }
  729. +
  730. + public static boolean checkMaxLevel(int maxlvl)
  731. + {
  732. + if (_minlvl >= maxlvl)
  733. + return false;
  734. +
  735. + return true;
  736. + }
  737. +
  738. + public static boolean checkMinLevel(int minlvl)
  739. + {
  740. + if (_maxlvl <= minlvl)
  741. + return false;
  742. +
  743. + return true;
  744. + }
  745. +
  746. + /** returns true if participated players is higher or equal then minimum needed players */
  747. + public static boolean checkMinPlayers(int players)
  748. + {
  749. + if (_minPlayers <= players)
  750. + return true;
  751. +
  752. + return false;
  753. + }
  754. +
  755. + /** returns true if max players is higher or equal then participated players */
  756. + public static boolean checkMaxPlayers(int players)
  757. + {
  758. + if (_maxPlayers > players)
  759. + return true;
  760. +
  761. + return false;
  762. + }
  763. +
  764. + public static void removeTeam(String teamName)
  765. + {
  766. + if (!checkTeamOk() || _teams.isEmpty())
  767. + {
  768. + if (Config.DEBUG)
  769. + _log.fine("CTF Engine[removeTeam(" + teamName + ")]: checkTeamOk() = false");
  770. + return;
  771. + }
  772. +
  773. + if (teamPlayersCount(teamName) > 0)
  774. + {
  775. + if (Config.DEBUG)
  776. + _log.fine("CTF Engine[removeTeam(" + teamName + ")]: teamPlayersCount(teamName) > 0");
  777. + return;
  778. + }
  779. +
  780. + int index = _teams.indexOf(teamName);
  781. +
  782. + if (index == -1)
  783. + return;
  784. +
  785. + _teamsZ.remove(index);
  786. + _teamsY.remove(index);
  787. + _teamsX.remove(index);
  788. + _teamColors.remove(index);
  789. + _teamPointsCount.remove(index);
  790. + _teamPlayersCount.remove(index);
  791. + _teams.remove(index);
  792. + _flagSpawns.remove(index);
  793. + _flagsTaken.remove(index);
  794. + _flagIds.remove(index);
  795. + _flagsX.remove(index);
  796. + _flagsY.remove(index);
  797. + _flagsZ.remove(index);
  798. + }
  799. +
  800. + public static void setTeamPos(String teamName, L2PcInstance activeChar)
  801. + {
  802. + int index = _teams.indexOf(teamName);
  803. +
  804. + if (index == -1)
  805. + return;
  806. +
  807. + _teamsX.set(index, activeChar.getX());
  808. + _teamsY.set(index, activeChar.getY());
  809. + _teamsZ.set(index, activeChar.getZ());
  810. + }
  811. +
  812. + public static void setTeamPos(String teamName, int x, int y, int z)
  813. + {
  814. + int index = _teams.indexOf(teamName);
  815. +
  816. + if (index == -1)
  817. + return;
  818. +
  819. + _teamsX.set(index, x);
  820. + _teamsY.set(index, y);
  821. + _teamsZ.set(index, z);
  822. + }
  823. +
  824. + public static void setTeamColor(String teamName, int color)
  825. + {
  826. + if (!checkTeamOk())
  827. + return;
  828. +
  829. + int index = _teams.indexOf(teamName);
  830. +
  831. + if (index == -1)
  832. + return;
  833. +
  834. + _teamColors.set(index, color);
  835. + }
  836. +
  837. + public static boolean checkTeamOk()
  838. + {
  839. + if (_started || _teleport || _joining)
  840. + return false;
  841. +
  842. + return true;
  843. + }
  844. +
  845. + public static void startJoin(L2PcInstance activeChar)
  846. + {
  847. + if (!startJoinOk())
  848. + {
  849. + activeChar.sendMessage("Event not setted propertly.");
  850. + if (Config.DEBUG)
  851. + _log.fine("CTF Engine[startJoin(" + activeChar.getName() + ")]: startJoinOk() = false");
  852. + return;
  853. + }
  854. +
  855. + _joining = true;
  856. + spawnEventNpc(activeChar);
  857. + AnnounceToPlayers(true, _eventName + " (CTF)!");
  858. + if (Config.CTF_ANNOUNCE_REWARD)
  859. + AnnounceToPlayers(true, "Reward: " + _rewardAmount + " " + ItemTable.getInstance().getTemplate(_rewardId).getName());
  860. + AnnounceToPlayers(true, "Recruiting levels " + _minlvl + " to " + _maxlvl);
  861. + AnnounceToPlayers(true, "Joinable in " + _joiningLocationName + "!");
  862. + }
  863. +
  864. + public static void startJoin()
  865. + {
  866. + if (!startJoinOk())
  867. + {
  868. + _log.warning("Event not setted propertly.");
  869. + if (Config.DEBUG)
  870. + _log.fine("CTF Engine[startJoin(startJoinOk() = false");
  871. + return;
  872. + }
  873. +
  874. + _joining = true;
  875. + spawnEventNpc();
  876. + AnnounceToPlayers(true, "Recruiting levels " + _minlvl + " to " + _maxlvl);
  877. + AnnounceToPlayers(true, "Joinable in " + _joiningLocationName + "!");
  878. + if (Config.CTF_ANNOUNCE_REWARD)
  879. + AnnounceToPlayers(true, "Reward: " + _rewardAmount + " " + ItemTable.getInstance().getTemplate(_rewardId).getName());
  880. + }
  881. +
  882. + public static boolean startAutoJoin()
  883. + {
  884. + if (!startJoinOk())
  885. + {
  886. + if (Config.DEBUG)
  887. + _log.fine("CTF Engine[startJoin]: startJoinOk() = false");
  888. + return false;
  889. + }
  890. +
  891. + _joining = true;
  892. + spawnEventNpc();
  893. + AnnounceToPlayers(true, _eventName + " (CTF)!");
  894. + if (Config.CTF_ANNOUNCE_REWARD)
  895. + AnnounceToPlayers(true, "Reward: " + _rewardAmount + " " + ItemTable.getInstance().getTemplate(_rewardId).getName());
  896. + AnnounceToPlayers(true, "Recruiting levels " + _minlvl + " to " + _maxlvl);
  897. + AnnounceToPlayers(true, "Joinable in " + _joiningLocationName + "!");
  898. + return true;
  899. + }
  900. +
  901. + public static boolean startJoinOk()
  902. + {
  903. + if (_started || _teleport || _joining || _teams.size() < 2 || _eventName.equals("") || _joiningLocationName.equals("") || _eventDesc.equals("")
  904. + || _npcId == 0 || _npcX == 0 || _npcY == 0 || _npcZ == 0 || _rewardId == 0 || _rewardAmount == 0 || _teamsX.contains(0) || _teamsY.contains(0)
  905. + || _teamsZ.contains(0))
  906. + return false;
  907. + try
  908. + {
  909. + if (_flagsX.contains(0) || _flagsY.contains(0) || _flagsZ.contains(0) || _flagIds.contains(0))
  910. + return false;
  911. + if (_flagsX.size() < _teams.size() || _flagsY.size() < _teams.size() || _flagsZ.size() < _teams.size() || _flagIds.size() < _teams.size())
  912. + return false;
  913. + }
  914. + catch (ArrayIndexOutOfBoundsException e)
  915. + {
  916. + return false;
  917. + }
  918. + return true;
  919. + }
  920. +
  921. + private static void spawnEventNpc(L2PcInstance activeChar)
  922. + {
  923. + L2NpcTemplate tmpl = NpcTable.getInstance().getTemplate(_npcId);
  924. +
  925. + try
  926. + {
  927. + _npcSpawn = new L2Spawn(tmpl);
  928. +
  929. + _npcSpawn.setLocx(_npcX);
  930. + _npcSpawn.setLocy(_npcY);
  931. + _npcSpawn.setLocz(_npcZ);
  932. + _npcSpawn.setAmount(1);
  933. + _npcSpawn.setHeading(_npcHeading);
  934. + _npcSpawn.setRespawnDelay(1);
  935. +
  936. + SpawnTable.getInstance().addNewSpawn(_npcSpawn, false);
  937. +
  938. + _npcSpawn.init();
  939. + _npcSpawn.getLastSpawn().getStatus().setCurrentHp(999999999);
  940. + _npcSpawn.getLastSpawn().setTitle(_eventName);
  941. + _npcSpawn.getLastSpawn()._isEventMobCTF = true;
  942. + _npcSpawn.getLastSpawn().isAggressive();
  943. + _npcSpawn.getLastSpawn().decayMe();
  944. + _npcSpawn.getLastSpawn().spawnMe(_npcSpawn.getLastSpawn().getX(), _npcSpawn.getLastSpawn().getY(), _npcSpawn.getLastSpawn().getZ());
  945. +
  946. + _npcSpawn.getLastSpawn().broadcastPacket(new MagicSkillUse(_npcSpawn.getLastSpawn(), _npcSpawn.getLastSpawn(), 1034, 1, 1, 1));
  947. + }
  948. + catch (Exception e)
  949. + {
  950. + _log.warning("CTF Engine[spawnEventNpc(" + activeChar.getName() + ")]: exception: " + e.getMessage());
  951. + }
  952. + }
  953. +
  954. + private static void spawnEventNpc()
  955. + {
  956. + L2NpcTemplate tmpl = NpcTable.getInstance().getTemplate(_npcId);
  957. +
  958. + try
  959. + {
  960. + _npcSpawn = new L2Spawn(tmpl);
  961. +
  962. + _npcSpawn.setLocx(_npcX);
  963. + _npcSpawn.setLocy(_npcY);
  964. + _npcSpawn.setLocz(_npcZ);
  965. + _npcSpawn.setAmount(1);
  966. + _npcSpawn.setHeading(_npcHeading);
  967. + _npcSpawn.setRespawnDelay(1);
  968. +
  969. + SpawnTable.getInstance().addNewSpawn(_npcSpawn, false);
  970. +
  971. + _npcSpawn.init();
  972. + _npcSpawn.getLastSpawn().getStatus().setCurrentHp(999999999);
  973. + _npcSpawn.getLastSpawn().setTitle(_eventName);
  974. + _npcSpawn.getLastSpawn()._isEventMobCTF = true;
  975. + _npcSpawn.getLastSpawn().isAggressive();
  976. + _npcSpawn.getLastSpawn().decayMe();
  977. + _npcSpawn.getLastSpawn().spawnMe(_npcSpawn.getLastSpawn().getX(), _npcSpawn.getLastSpawn().getY(), _npcSpawn.getLastSpawn().getZ());
  978. +
  979. + _npcSpawn.getLastSpawn().broadcastPacket(new MagicSkillUse(_npcSpawn.getLastSpawn(), _npcSpawn.getLastSpawn(), 1034, 1, 1, 1));
  980. + }
  981. + catch (Exception e)
  982. + {
  983. + _log.warning("CTF Engine[spawnEventNpc(exception: " + e.getMessage());
  984. + }
  985. + }
  986. +
  987. + public static void teleportStart()
  988. + {
  989. + if (!_joining || _started || _teleport)
  990. + return;
  991. +
  992. + if (Config.CTF_EVEN_TEAMS.equals("SHUFFLE") && checkMinPlayers(_playersShuffle.size()))
  993. + {
  994. + removeOfflinePlayers();
  995. + shuffleTeams();
  996. + }
  997. + else if (Config.CTF_EVEN_TEAMS.equals("SHUFFLE") && !checkMinPlayers(_playersShuffle.size()))
  998. + {
  999. + AnnounceToPlayers(true, "Not enough players for event. Min Requested : " + _minPlayers + ", Participating : " + _playersShuffle.size());
  1000. + return;
  1001. + }
  1002. +
  1003. + _joining = false;
  1004. + AnnounceToPlayers(true, _eventName + "(CTF): Teleport to team spot in 20 seconds!");
  1005. +
  1006. + setUserData();
  1007. + ThreadPoolManager.getInstance().scheduleGeneral(new Runnable()
  1008. + {
  1009. + public void run()
  1010. + {
  1011. + CTF.sit();
  1012. + CTF.spawnAllFlags();
  1013. + for (L2PcInstance player : _players)
  1014. + {
  1015. + if (player != null)
  1016. + {
  1017. + if (Config.CTF_ON_START_UNSUMMON_PET)
  1018. + {
  1019. + //Remove Summon's buffs
  1020. + if (player.getPet() != null)
  1021. + {
  1022. + L2Summon summon = player.getPet();
  1023. + for (L2Effect e : summon.getAllEffects())
  1024. + if (e != null)
  1025. + e.exit();
  1026. +
  1027. + if (summon instanceof L2PetInstance)
  1028. + summon.unSummon(player);
  1029. + }
  1030. + }
  1031. +
  1032. + if (Config.CTF_ON_START_REMOVE_ALL_EFFECTS)
  1033. + {
  1034. + for (L2Effect e : player.getAllEffects())
  1035. + {
  1036. + if (e != null)
  1037. + e.exit();
  1038. + }
  1039. + }
  1040. +
  1041. + //Remove player from his party
  1042. + if (player.getParty() != null)
  1043. + {
  1044. + L2Party party = player.getParty();
  1045. + party.removePartyMember(player);
  1046. + }
  1047. + player.teleToLocation(_teamsX.get(_teams.indexOf(player._teamNameCTF)), _teamsY.get(_teams.indexOf(player._teamNameCTF)), _teamsZ
  1048. + .get(_teams.indexOf(player._teamNameCTF)));
  1049. + }
  1050. + }
  1051. + }
  1052. + }, 20000);
  1053. + _teleport = true;
  1054. + }
  1055. +
  1056. + public static boolean teleportAutoStart()
  1057. + {
  1058. + if (!_joining || _started || _teleport)
  1059. + return false;
  1060. +
  1061. + if (Config.CTF_EVEN_TEAMS.equals("SHUFFLE") && checkMinPlayers(_playersShuffle.size()))
  1062. + {
  1063. + removeOfflinePlayers();
  1064. + shuffleTeams();
  1065. + }
  1066. + else if (Config.CTF_EVEN_TEAMS.equals("SHUFFLE") && !checkMinPlayers(_playersShuffle.size()))
  1067. + {
  1068. + AnnounceToPlayers(true, "Not enough players for event. Min Requested : " + _minPlayers + ", Participating : " + _playersShuffle.size());
  1069. + return false;
  1070. + }
  1071. +
  1072. + _joining = false;
  1073. + AnnounceToPlayers(false, _eventName + "(CTF): Teleport to team spot in 20 seconds!");
  1074. +
  1075. + setUserData();
  1076. + ThreadPoolManager.getInstance().scheduleGeneral(new Runnable()
  1077. + {
  1078. + public void run()
  1079. + {
  1080. + sit();
  1081. + spawnAllFlags();
  1082. +
  1083. + for (L2PcInstance player : _players)
  1084. + {
  1085. + if (player != null)
  1086. + {
  1087. + if (Config.CTF_ON_START_UNSUMMON_PET)
  1088. + {
  1089. + //Remove Summon's buffs
  1090. + if (player.getPet() != null)
  1091. + {
  1092. + L2Summon summon = player.getPet();
  1093. + for (L2Effect e : summon.getAllEffects())
  1094. + if (e != null)
  1095. + e.exit();
  1096. +
  1097. + if (summon instanceof L2PetInstance)
  1098. + summon.unSummon(player);
  1099. + }
  1100. + }
  1101. +
  1102. + if (Config.CTF_ON_START_REMOVE_ALL_EFFECTS)
  1103. + {
  1104. + for (L2Effect e : player.getAllEffects())
  1105. + {
  1106. + if (e != null)
  1107. + e.exit();
  1108. + }
  1109. + }
  1110. +
  1111. + //Remove player from his party
  1112. + if (player.getParty() != null)
  1113. + {
  1114. + L2Party party = player.getParty();
  1115. + party.removePartyMember(player);
  1116. + }
  1117. +
  1118. + player.teleToLocation(_teamsX.get(_teams.indexOf(player._teamNameCTF)), _teamsY.get(_teams.indexOf(player._teamNameCTF)), _teamsZ
  1119. + .get(_teams.indexOf(player._teamNameCTF)));
  1120. + }
  1121. + }
  1122. + }
  1123. + }, 20000);
  1124. + _teleport = true;
  1125. + return true;
  1126. + }
  1127. +
  1128. + public static void startEvent(L2PcInstance activeChar)
  1129. + {
  1130. + if (!startEventOk())
  1131. + {
  1132. + if (Config.DEBUG)
  1133. + _log.fine("CTF Engine[startEvent(" + activeChar.getName() + ")]: startEventOk() = false");
  1134. + return;
  1135. + }
  1136. +
  1137. + _teleport = false;
  1138. + sit();
  1139. + _started = true;
  1140. + StartEvent();
  1141. + }
  1142. +
  1143. + public static void setJoinTime(int time)
  1144. + {
  1145. + _joinTime = time;
  1146. + }
  1147. +
  1148. + public static void setEventTime(int time)
  1149. + {
  1150. + _eventTime = time;
  1151. + }
  1152. +
  1153. + public static boolean startAutoEvent()
  1154. + {
  1155. + if (!startEventOk())
  1156. + {
  1157. + if (Config.DEBUG)
  1158. + _log.fine("CTF Engine[startEvent]: startEventOk() = false");
  1159. + return false;
  1160. + }
  1161. +
  1162. + _teleport = false;
  1163. + sit();
  1164. + AnnounceToPlayers(true, _eventName + "(CTF): Started. Go Capture the Flags!");
  1165. + _started = true;
  1166. + return true;
  1167. + }
  1168. +
  1169. + public static synchronized void autoEvent()
  1170. + {
  1171. + if (startAutoJoin())
  1172. + {
  1173. + if (_joinTime > 0)
  1174. + waiter(_joinTime * 60 * 1000); // minutes for join event
  1175. + else if (_joinTime <= 0)
  1176. + {
  1177. + abortEvent();
  1178. + return;
  1179. + }
  1180. + if (teleportAutoStart())
  1181. + {
  1182. + waiter(1 * 30 * 1000); // 30 seconds wait time untill start fight after teleported
  1183. + if (startAutoEvent())
  1184. + {
  1185. + waiter(_eventTime * 60 * 1000); // minutes for event time
  1186. + finishEvent();
  1187. + }
  1188. + }
  1189. + else if (!teleportAutoStart())
  1190. + {
  1191. + abortEvent();
  1192. + }
  1193. + }
  1194. + }
  1195. +
  1196. + private static synchronized void waiter(long interval)
  1197. + {
  1198. + long startWaiterTime = System.currentTimeMillis();
  1199. + int seconds = (int) (interval / 1000);
  1200. +
  1201. + while (startWaiterTime + interval > System.currentTimeMillis())
  1202. + {
  1203. + seconds--; // here because we don't want to see two time announce at the same time
  1204. +
  1205. + if (_joining || _started || _teleport)
  1206. + {
  1207. + switch (seconds)
  1208. + {
  1209. + case 3600: // 1 hour left
  1210. + if (_joining)
  1211. + {
  1212. + AnnounceToPlayers(true, _eventName + "(CTF): Joinable in " + _joiningLocationName + "!");
  1213. + AnnounceToPlayers(true, "CTF Event: " + seconds / 60 / 60 + " hour(s) till registration close!");
  1214. + }
  1215. + else if (_started)
  1216. + AnnounceToPlayers(false, "CTF Event: " + seconds / 60 / 60 + " hour(s) till event finish!");
  1217. +
  1218. + break;
  1219. + case 1800: // 30 minutes left
  1220. + case 600: // 10 minutes left
  1221. + case 180: // 3 minutes left
  1222. + case 120: // 2 minutes left
  1223. + case 60: // 1 minute left
  1224. + if (_joining)
  1225. + {
  1226. + removeOfflinePlayers();
  1227. + AnnounceToPlayers(true, _eventName + "(CTF): Joinable in " + _joiningLocationName + "!");
  1228. + AnnounceToPlayers(true, "CTF Event: " + seconds / 60 + " minute(s) till registration ends!");
  1229. + }
  1230. + else if (_started)
  1231. + AnnounceToPlayers(false, "CTF Event: " + seconds / 60 + " minute(s) till event ends!");
  1232. +
  1233. + break;
  1234. + case 30: // 30 seconds left
  1235. + case 10: // 10 seconds left
  1236. + case 3: // 3 seconds left
  1237. + case 2: // 2 seconds left
  1238. + case 1: // 1 seconds left
  1239. + if (_joining)
  1240. + AnnounceToPlayers(true, "CTF Event: " + seconds + " second(s) till registration close!");
  1241. + else if (_teleport)
  1242. + AnnounceToPlayers(false, "CTF Event: " + seconds + " seconds(s) till fight starts!");
  1243. + else if (_started)
  1244. + AnnounceToPlayers(false, "CTF Event: " + seconds + " second(s) till event ends!");
  1245. +
  1246. + break;
  1247. + }
  1248. + }
  1249. +
  1250. + long startOneSecondWaiterStartTime = System.currentTimeMillis();
  1251. +
  1252. + // only the try catch with Thread.sleep(1000) give bad countdown on high wait times
  1253. + while (startOneSecondWaiterStartTime + 1000 > System.currentTimeMillis())
  1254. + {
  1255. + try
  1256. + {
  1257. + Thread.sleep(1);
  1258. + }
  1259. + catch (InterruptedException ie)
  1260. + {
  1261. + }
  1262. + }
  1263. + }
  1264. + }
  1265. +
  1266. + private static boolean startEventOk()
  1267. + {
  1268. + if (_joining || !_teleport || _started)
  1269. + return false;
  1270. +
  1271. + if (Config.CTF_EVEN_TEAMS.equals("NO") || Config.CTF_EVEN_TEAMS.equals("BALANCE"))
  1272. + {
  1273. + if (_teamPlayersCount.contains(0))
  1274. + return false;
  1275. + }
  1276. + else if (Config.CTF_EVEN_TEAMS.equals("SHUFFLE"))
  1277. + {
  1278. + Vector<L2PcInstance> playersShuffleTemp = new Vector<L2PcInstance>();
  1279. + int loopCount = 0;
  1280. +
  1281. + loopCount = _playersShuffle.size();
  1282. +
  1283. + for (int i = 0; i < loopCount; i++)
  1284. + {
  1285. + if (_playersShuffle != null)
  1286. + playersShuffleTemp.add(_playersShuffle.get(i));
  1287. + }
  1288. +
  1289. + _playersShuffle = playersShuffleTemp;
  1290. + playersShuffleTemp.clear();
  1291. +
  1292. + // if (_playersShuffle.size() < (_teams.size()*2)){
  1293. + // return false;
  1294. + // }
  1295. + }
  1296. +
  1297. + return true;
  1298. + }
  1299. +
  1300. + public static void shuffleTeams()
  1301. + {
  1302. + int teamCount = 0, playersCount = 0;
  1303. +
  1304. + for (;;)
  1305. + {
  1306. + if (_playersShuffle.isEmpty())
  1307. + break;
  1308. +
  1309. + int playerToAddIndex = Rnd.nextInt(_playersShuffle.size());
  1310. + L2PcInstance player = null;
  1311. + player = _playersShuffle.get(playerToAddIndex);
  1312. + player._originalNameColorCTF = player.getAppearance().getNameColor();
  1313. + player._originalKarmaCTF = player.getKarma();
  1314. +
  1315. + _players.add(player);
  1316. + _players.get(playersCount)._teamNameCTF = _teams.get(teamCount);
  1317. + _savePlayers.add(_players.get(playersCount).getName());
  1318. + _savePlayerTeams.add(_teams.get(teamCount));
  1319. + playersCount++;
  1320. +
  1321. + if (teamCount == _teams.size() - 1)
  1322. + teamCount = 0;
  1323. + else
  1324. + teamCount++;
  1325. +
  1326. + _playersShuffle.remove(playerToAddIndex);
  1327. + }
  1328. + }
  1329. +
  1330. + public static void setUserData()
  1331. + {
  1332. + for (L2PcInstance player : _players)
  1333. + {
  1334. + player.getAppearance().setNameColor(_teamColors.get(_teams.indexOf(player._teamNameCTF)));
  1335. + player.setKarma(0);
  1336. + player.broadcastUserInfo();
  1337. + }
  1338. + }
  1339. +
  1340. + public static void finishEvent()
  1341. + {
  1342. + if (!finishEventOk())
  1343. + {
  1344. + if (Config.DEBUG)
  1345. + _log.fine("CTF Engine[finishEvent]: finishEventOk() = false");
  1346. + return;
  1347. + }
  1348. +
  1349. + _started = false;
  1350. + unspawnEventNpc();
  1351. + unspawnAllFlags();
  1352. + processTopTeam();
  1353. +
  1354. + if (_topScore != 0)
  1355. + playKneelAnimation(_topTeam);
  1356. +
  1357. + if (Config.CTF_ANNOUNCE_TEAM_STATS)
  1358. + {
  1359. + AnnounceToPlayers(true, _eventName + " Team Statistics:");
  1360. + for (String team : _teams)
  1361. + {
  1362. + int _flags_ = teamFlagCount(team);
  1363. + AnnounceToPlayers(true, "Team: " + team + " - Flags taken: " + _flags_);
  1364. + }
  1365. + }
  1366. +
  1367. + teleportFinish();
  1368. + }
  1369. +
  1370. + //show loosers and winners animations
  1371. + public static void playKneelAnimation(String teamName)
  1372. + {
  1373. + for (L2PcInstance player : _players)
  1374. + {
  1375. + if (player != null && player.isOnline() != 0 && player._inEventCTF == true)
  1376. + {
  1377. + if (!player._teamNameCTF.equals(teamName))
  1378. + {
  1379. + player.broadcastPacket(new SocialAction(player.getObjectId(), 7));
  1380. + }
  1381. + else if (player._teamNameCTF.equals(teamName))
  1382. + {
  1383. + player.broadcastPacket(new SocialAction(player.getObjectId(), 3));
  1384. + }
  1385. + }
  1386. + }
  1387. + }
  1388. +
  1389. + private static boolean finishEventOk()
  1390. + {
  1391. + if (!_started)
  1392. + return false;
  1393. +
  1394. + return true;
  1395. + }
  1396. +
  1397. + public static void rewardTeam(String teamName)
  1398. + {
  1399. + for (L2PcInstance player : _players)
  1400. + {
  1401. + if (player != null)
  1402. + {
  1403. + if (player._teamNameCTF.equals(teamName))
  1404. + {
  1405. + player.addItem("CTF Event: " + _eventName, _rewardId, _rewardAmount, player, true);
  1406. +
  1407. + NpcHtmlMessage nhm = new NpcHtmlMessage(5);
  1408. + TextBuilder replyMSG = new TextBuilder();
  1409. +
  1410. + replyMSG.append("<html><body>Your team wins the event. Look in your inventory for the reward.</body></html>");
  1411. +
  1412. + nhm.setHtml(replyMSG.toString());
  1413. + player.sendPacket(nhm);
  1414. +
  1415. + // Send a Server->Client ActionFailed to the L2PcInstance in order to avoid that the client wait another packet
  1416. + player.sendPacket(ActionFailed.STATIC_PACKET);
  1417. + }
  1418. + }
  1419. + }
  1420. + }
  1421. +
  1422. + public static void abortEvent()
  1423. + {
  1424. + if (!_joining && !_teleport && !_started)
  1425. + return;
  1426. + if (_joining && !_teleport && !_started)
  1427. + {
  1428. + unspawnEventNpc();
  1429. + cleanCTF();
  1430. + _joining = false;
  1431. + AnnounceToPlayers(true, _eventName + "(CTF): Match aborted!");
  1432. + return;
  1433. + }
  1434. + _joining = false;
  1435. + _teleport = false;
  1436. + _started = false;
  1437. + unspawnEventNpc();
  1438. + unspawnAllFlags();
  1439. + AnnounceToPlayers(true, _eventName + "(CTF): Match aborted!");
  1440. + teleportFinish();
  1441. + }
  1442. +
  1443. + public static void sit()
  1444. + {
  1445. + if (_sitForced)
  1446. + _sitForced = false;
  1447. + else
  1448. + _sitForced = true;
  1449. +
  1450. + for (L2PcInstance player : _players)
  1451. + {
  1452. + if (player != null)
  1453. + {
  1454. + if (_sitForced)
  1455. + {
  1456. + player.stopMove(null, false);
  1457. + player.abortAttack();
  1458. + player.abortCast();
  1459. +
  1460. + if (!player.isSitting())
  1461. + player.sitDown();
  1462. + }
  1463. + else
  1464. + {
  1465. + if (player.isSitting())
  1466. + player.standUp();
  1467. + }
  1468. + }
  1469. + }
  1470. + }
  1471. +
  1472. + public static void dumpData()
  1473. + {
  1474. + _log.warning("");
  1475. + _log.warning("");
  1476. +
  1477. + if (!_joining && !_teleport && !_started)
  1478. + {
  1479. + _log.warning("<<---------------------------------->>");
  1480. + _log.warning(">> CTF Engine infos dump (INACTIVE) <<");
  1481. + _log.warning("<<--^----^^-----^----^^------^^----->>");
  1482. + }
  1483. + else if (_joining && !_teleport && !_started)
  1484. + {
  1485. + _log.warning("<<--------------------------------->>");
  1486. + _log.warning(">> CTF Engine infos dump (JOINING) <<");
  1487. + _log.warning("<<--^----^^-----^----^^------^----->>");
  1488. + }
  1489. + else if (!_joining && _teleport && !_started)
  1490. + {
  1491. + _log.warning("<<---------------------------------->>");
  1492. + _log.warning(">> CTF Engine infos dump (TELEPORT) <<");
  1493. + _log.warning("<<--^----^^-----^----^^------^^----->>");
  1494. + }
  1495. + else if (!_joining && !_teleport && _started)
  1496. + {
  1497. + _log.warning("<<--------------------------------->>");
  1498. + _log.warning(">> CTF Engine infos dump (STARTED) <<");
  1499. + _log.warning("<<--^----^^-----^----^^------^----->>");
  1500. + }
  1501. +
  1502. + _log.warning("Name: " + _eventName);
  1503. + _log.warning("Desc: " + _eventDesc);
  1504. + _log.warning("Join location: " + _joiningLocationName);
  1505. + _log.warning("Min lvl: " + _minlvl);
  1506. + _log.warning("Max lvl: " + _maxlvl);
  1507. + _log.warning("");
  1508. + _log.warning("##########################");
  1509. + _log.warning("# _teams(Vector<String>) #");
  1510. + _log.warning("##########################");
  1511. +
  1512. + for (String team : _teams)
  1513. + _log.warning(team + " Flags Taken :" + _teamPointsCount.get(_teams.indexOf(team)));
  1514. +
  1515. + if (Config.CTF_EVEN_TEAMS.equals("SHUFFLE"))
  1516. + {
  1517. + _log.warning("");
  1518. + _log.warning("#########################################");
  1519. + _log.warning("# _playersShuffle(Vector<L2PcInstance>) #");
  1520. + _log.warning("#########################################");
  1521. +
  1522. + for (L2PcInstance player : _playersShuffle)
  1523. + {
  1524. + if (player != null)
  1525. + _log.warning("Name: " + player.getName());
  1526. + }
  1527. + }
  1528. +
  1529. + _log.warning("");
  1530. + _log.warning("##################################");
  1531. + _log.warning("# _players(Vector<L2PcInstance>) #");
  1532. + _log.warning("##################################");
  1533. +
  1534. + for (L2PcInstance player : _players)
  1535. + {
  1536. + if (player != null)
  1537. + _log.warning("Name: " + player.getName() + " Team: " + player._teamNameCTF + " Flags :" + player._countCTFflags);
  1538. + }
  1539. +
  1540. + _log.warning("");
  1541. + _log.warning("#####################################################################");
  1542. + _log.warning("# _savePlayers(Vector<String>) and _savePlayerTeams(Vector<String>) #");
  1543. + _log.warning("#####################################################################");
  1544. +
  1545. + for (String player : _savePlayers)
  1546. + _log.warning("Name: " + player + " Team: " + _savePlayerTeams.get(_savePlayers.indexOf(player)));
  1547. +
  1548. + _log.warning("");
  1549. + _log.warning("");
  1550. + _log.warning("**********==CTF==************");
  1551. + _log.warning("CTF._teamPointsCount:" + _teamPointsCount.toString());
  1552. + _log.warning("CTF._flagIds:" + _flagIds.toString());
  1553. + _log.warning("CTF._flagSpawns:" + _flagSpawns.toString());
  1554. + _log.warning("CTF._throneSpawns:" + _throneSpawns.toString());
  1555. + _log.warning("CTF._flagsTaken:" + _flagsTaken.toString());
  1556. + _log.warning("CTF._flagsX:" + _flagsX.toString());
  1557. + _log.warning("CTF._flagsY:" + _flagsY.toString());
  1558. + _log.warning("CTF._flagsZ:" + _flagsZ.toString());
  1559. + _log.warning("************EOF**************");
  1560. + _log.warning("");
  1561. + }
  1562. +
  1563. + public static void loadData()
  1564. + {
  1565. + _eventName = new String();
  1566. + _eventDesc = new String();
  1567. + _topTeam = new String();
  1568. + _joiningLocationName = new String();
  1569. + _teams = new Vector<String>();
  1570. + _savePlayers = new Vector<String>();
  1571. + _savePlayerTeams = new Vector<String>();
  1572. + _players = new Vector<L2PcInstance>();
  1573. + _playersShuffle = new Vector<L2PcInstance>();
  1574. + _teamPlayersCount = new Vector<Integer>();
  1575. + _teamPointsCount = new Vector<Integer>();
  1576. + _teamColors = new Vector<Integer>();
  1577. + _teamsX = new Vector<Integer>();
  1578. + _teamsY = new Vector<Integer>();
  1579. + _teamsZ = new Vector<Integer>();
  1580. +
  1581. + _throneSpawns = new Vector<L2Spawn>();
  1582. + _flagSpawns = new Vector<L2Spawn>();
  1583. + _flagsTaken = new Vector<Boolean>();
  1584. + _flagIds = new Vector<Integer>();
  1585. + _flagsX = new Vector<Integer>();
  1586. + _flagsY = new Vector<Integer>();
  1587. + _flagsZ = new Vector<Integer>();
  1588. +
  1589. + _joining = false;
  1590. + _teleport = false;
  1591. + _started = false;
  1592. + _sitForced = false;
  1593. + _npcId = 0;
  1594. + _npcX = 0;
  1595. + _npcY = 0;
  1596. + _npcZ = 0;
  1597. + _npcHeading = 0;
  1598. + _rewardId = 0;
  1599. + _rewardAmount = 0;
  1600. + _topScore = 0;
  1601. + _minlvl = 0;
  1602. + _maxlvl = 0;
  1603. + _joinTime = 0;
  1604. + _eventTime = 0;
  1605. + _minPlayers = 0;
  1606. + _maxPlayers = 0;
  1607. +
  1608. + Connection con = null;
  1609. + try
  1610. + {
  1611. + PreparedStatement statement;
  1612. + ResultSet rs;
  1613. +
  1614. + con = L2DatabaseFactory.getInstance().getConnection();
  1615. +
  1616. + statement = con.prepareStatement("Select * from ctf");
  1617. + rs = statement.executeQuery();
  1618. +
  1619. + int teams = 0;
  1620. +
  1621. + while (rs.next())
  1622. + {
  1623. + _eventName = rs.getString("eventName");
  1624. + _eventDesc = rs.getString("eventDesc");
  1625. + _joiningLocationName = rs.getString("joiningLocation");
  1626. + _minlvl = rs.getInt("minlvl");
  1627. + _maxlvl = rs.getInt("maxlvl");
  1628. + _npcId = rs.getInt("npcId");
  1629. + _npcX = rs.getInt("npcX");
  1630. + _npcY = rs.getInt("npcY");
  1631. + _npcZ = rs.getInt("npcZ");
  1632. + _npcHeading = rs.getInt("npcHeading");
  1633. + _rewardId = rs.getInt("rewardId");
  1634. + _rewardAmount = rs.getInt("rewardAmount");
  1635. + teams = rs.getInt("teamsCount");
  1636. + _joinTime = rs.getInt("joinTime");
  1637. + _eventTime = rs.getInt("eventTime");
  1638. + _minPlayers = rs.getInt("minPlayers");
  1639. + _maxPlayers = rs.getInt("maxPlayers");
  1640. + }
  1641. + statement.close();
  1642. +
  1643. + int index = -1;
  1644. + if (teams > 0)
  1645. + index = 0;
  1646. + while (index < teams && index > -1)
  1647. + {
  1648. + statement = con.prepareStatement("Select * from ctf_teams where teamId = ?");
  1649. + statement.setInt(1, index);
  1650. + rs = statement.executeQuery();
  1651. + while (rs.next())
  1652. + {
  1653. + _teams.add(rs.getString("teamName"));
  1654. + _teamPlayersCount.add(0);
  1655. + _teamPointsCount.add(0);
  1656. + _teamColors.add(0);
  1657. + _teamsX.add(0);
  1658. + _teamsY.add(0);
  1659. + _teamsZ.add(0);
  1660. + _teamsX.set(index, rs.getInt("teamX"));
  1661. + _teamsY.set(index, rs.getInt("teamY"));
  1662. + _teamsZ.set(index, rs.getInt("teamZ"));
  1663. + _teamColors.set(index, rs.getInt("teamColor"));
  1664. + _flagsX.add(0);
  1665. + _flagsY.add(0);
  1666. + _flagsZ.add(0);
  1667. + _flagsX.set(index, rs.getInt("flagX"));
  1668. + _flagsY.set(index, rs.getInt("flagY"));
  1669. + _flagsZ.set(index, rs.getInt("flagZ"));
  1670. + _flagSpawns.add(null);
  1671. + _flagIds.add(_FlagNPC);
  1672. + _flagsTaken.add(false);
  1673. +
  1674. + }
  1675. + index++;
  1676. + statement.close();
  1677. + }
  1678. + }
  1679. + catch (Exception e)
  1680. + {
  1681. + _log.warning("Exception: CTF.loadData(): " + e.getMessage());
  1682. + }
  1683. + finally { try { if (con != null) con.close(); } catch (SQLException e) { e.printStackTrace(); } }
  1684. + }
  1685. +
  1686. + public static void saveData()
  1687. + {
  1688. + Connection con = null;
  1689. + try
  1690. + {
  1691. + con = L2DatabaseFactory.getInstance().getConnection();
  1692. + PreparedStatement statement;
  1693. +
  1694. + statement = con.prepareStatement("Delete from ctf");
  1695. + statement.execute();
  1696. + statement.close();
  1697. +
  1698. + statement = con
  1699. + .prepareStatement("INSERT INTO ctf (eventName, eventDesc, joiningLocation, minlvl, maxlvl, npcId, npcX, npcY, npcZ, npcHeading, rewardId, rewardAmount, teamsCount, joinTime, eventTime, minPlayers, maxPlayers) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)");
  1700. + statement.setString(1, _eventName);
  1701. + statement.setString(2, _eventDesc);
  1702. + statement.setString(3, _joiningLocationName);
  1703. + statement.setInt(4, _minlvl);
  1704. + statement.setInt(5, _maxlvl);
  1705. + statement.setInt(6, _npcId);
  1706. + statement.setInt(7, _npcX);
  1707. + statement.setInt(8, _npcY);
  1708. + statement.setInt(9, _npcZ);
  1709. + statement.setInt(10, _npcHeading);
  1710. + statement.setInt(11, _rewardId);
  1711. + statement.setInt(12, _rewardAmount);
  1712. + statement.setInt(13, _teams.size());
  1713. + statement.setInt(14, _joinTime);
  1714. + statement.setInt(15, _eventTime);
  1715. + statement.setInt(16, _minPlayers);
  1716. + statement.setInt(17, _maxPlayers);
  1717. + statement.execute();
  1718. + statement.close();
  1719. +
  1720. + statement = con.prepareStatement("Delete from ctf_teams");
  1721. + statement.execute();
  1722. + statement.close();
  1723. +
  1724. + for (String teamName : _teams)
  1725. + {
  1726. + int index = _teams.indexOf(teamName);
  1727. +
  1728. + if (index == -1)
  1729. + return;
  1730. + statement = con
  1731. + .prepareStatement("INSERT INTO ctf_teams (teamId ,teamName, teamX, teamY, teamZ, teamColor, flagX, flagY, flagZ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)");
  1732. + statement.setInt(1, index);
  1733. + statement.setString(2, teamName);
  1734. + statement.setInt(3, _teamsX.get(index));
  1735. + statement.setInt(4, _teamsY.get(index));
  1736. + statement.setInt(5, _teamsZ.get(index));
  1737. + statement.setInt(6, _teamColors.get(index));
  1738. + statement.setInt(7, _flagsX.get(index));
  1739. + statement.setInt(8, _flagsY.get(index));
  1740. + statement.setInt(9, _flagsZ.get(index));
  1741. + statement.execute();
  1742. + statement.close();
  1743. + }
  1744. + }
  1745. + catch (Exception e)
  1746. + {
  1747. + _log.warning("Exception: CTF.saveData(): " + e.getMessage());
  1748. + }
  1749. + finally { try { if (con != null) con.close(); } catch (SQLException e) { e.printStackTrace(); } }
  1750. + }
  1751. +
  1752. + public static void showEventHtml(L2PcInstance eventPlayer, String objectId)
  1753. + {
  1754. + try
  1755. + {
  1756. + NpcHtmlMessage adminReply = new NpcHtmlMessage(5);
  1757. + TextBuilder replyMSG = new TextBuilder();
  1758. +
  1759. + replyMSG.append("<html><body>");
  1760. + replyMSG.append("CTF Match<br><br><br>");
  1761. + replyMSG.append("Current event...<br>");
  1762. + replyMSG.append(" ... description:&nbsp;<font color=\"00FF00\">" + _eventDesc + "</font><br>");
  1763. + if (Config.CTF_ANNOUNCE_REWARD)
  1764. + replyMSG.append(" ... reward: (" + _rewardAmount + ") " + ItemTable.getInstance().getTemplate(_rewardId).getName() + "<br>");
  1765. +
  1766. + if (!_started && !_joining)
  1767. + replyMSG.append("<center>Wait till the admin/gm start the participation.</center>");
  1768. + else if (Config.CTF_EVEN_TEAMS.equals("SHUFFLE") && !checkMaxPlayers(_playersShuffle.size()))
  1769. + {
  1770. + if (!CTF._started)
  1771. + {
  1772. + replyMSG.append("<font color=\"FFFF00\">The event has reached its maximum capacity.</font><br>Keep checking, someone may crit and you can steal their spot.");
  1773. + }
  1774. + }
  1775. + else if (eventPlayer.isCursedWeaponEquipped() && !Config.CTF_JOIN_CURSED)
  1776. + {
  1777. + replyMSG.append("<font color=\"FFFF00\">You can't participate in this event with a cursed Weapon.</font><br>");
  1778. + }
  1779. + else if (!_started && _joining && eventPlayer.getLevel() >= _minlvl && eventPlayer.getLevel() <= _maxlvl)
  1780. + {
  1781. + if (_players.contains(eventPlayer) || checkShufflePlayers(eventPlayer))
  1782. + {
  1783. + if (Config.CTF_EVEN_TEAMS.equals("NO") || Config.CTF_EVEN_TEAMS.equals("BALANCE"))
  1784. + replyMSG.append("You are already participating in team <font color=\"LEVEL\">" + eventPlayer._teamNameCTF + "</font><br><br>");
  1785. + else if (Config.CTF_EVEN_TEAMS.equals("SHUFFLE"))
  1786. + replyMSG.append("You are already participating!<br><br>");
  1787. +
  1788. + replyMSG.append("<table border=\"0\"><tr>");
  1789. + replyMSG.append("<td width=\"200\">Wait till event start or</td>");
  1790. + replyMSG.append("<td width=\"60\"><center><button value=\"remove\" action=\"bypass -h npc_" + objectId + "_ctf_player_leave\" width=50 height=15 back=\"L2UI_ct1.button_df\" fore=\"L2UI_ct1.button_df\"></center></td>");
  1791. + replyMSG.append("<td width=\"100\">your participation!</td>");
  1792. + replyMSG.append("</tr></table>");
  1793. + }
  1794. + else
  1795. + {
  1796. + replyMSG.append("<td width=\"200\">Your level : <font color=\"00FF00\">" + eventPlayer.getLevel() + "</font></td><br>");
  1797. + replyMSG.append("<td width=\"200\">Min level : <font color=\"00FF00\">" + _minlvl + "</font></td><br>");
  1798. + replyMSG.append("<td width=\"200\">Max level : <font color=\"00FF00\">" + _maxlvl + "</font></td><br><br>");
  1799. +
  1800. + if (Config.CTF_EVEN_TEAMS.equals("NO") || Config.CTF_EVEN_TEAMS.equals("BALANCE"))
  1801. + {
  1802. + replyMSG.append("<center><table border=\"0\">");
  1803. +
  1804. + for (String team : _teams)
  1805. + {
  1806. + replyMSG.append("<tr><td width=\"100\"><font color=\"LEVEL\">" + team + "</font>&nbsp;(" + teamPlayersCount(team) + " joined)</td>");
  1807. + replyMSG.append("<td width=\"60\"><button value=\"Join\" action=\"bypass -h npc_" + objectId + "_ctf_player_join " + team + "\" width=50 height=15 back=\"L2UI_ct1.button_df\" fore=\"L2UI_ct1.button_df\"></td></tr>");
  1808. + }
  1809. +
  1810. + replyMSG.append("</table></center>");
  1811. + }
  1812. + else if (Config.CTF_EVEN_TEAMS.equals("SHUFFLE"))
  1813. + {
  1814. + replyMSG.append("<center><table border=\"0\">");
  1815. +
  1816. + for (String team : _teams)
  1817. + replyMSG.append("<tr><td width=\"100\"><font color=\"LEVEL\">" + team + "</font></td>");
  1818. +
  1819. + replyMSG.append("</table></center><br>");
  1820. +
  1821. + replyMSG.append("<button value=\"Join\" action=\"bypass -h npc_" + objectId + "_ctf_player_join eventShuffle\" width=50 height=15 back=\"L2UI_ct1.button_df\" fore=\"L2UI_ct1.button_df\">");
  1822. + replyMSG.append("Teams will be randomly generated!");
  1823. + }
  1824. + }
  1825. + }
  1826. + else if (_started && !_joining)
  1827. + replyMSG.append("<center>CTF match is in progress.</center>");
  1828. + else if (eventPlayer.getLevel() < _minlvl || eventPlayer.getLevel() > _maxlvl)
  1829. + {
  1830. + replyMSG.append("Your lvl : <font color=\"00FF00\">" + eventPlayer.getLevel() + "</font><br>");
  1831. + replyMSG.append("Min level : <font color=\"00FF00\">" + _minlvl + "</font><br>");
  1832. + replyMSG.append("Max level : <font color=\"00FF00\">" + _maxlvl + "</font><br><br>");
  1833. + replyMSG.append("<font color=\"FFFF00\">You can't participatein this event.</font><br>");
  1834. + }
  1835. + // Show how many players joined & how many are still needed to join
  1836. + replyMSG.append("<br>There are " + _playersShuffle.size() + " player(s) participating in this event.<br>");
  1837. + if (_joining)
  1838. + {
  1839. + if (_playersShuffle.size() < _minPlayers)
  1840. + {
  1841. + int playersNeeded = _minPlayers - _playersShuffle.size();
  1842. + replyMSG.append("The event will not start unless " + playersNeeded + " more player(s) joins!");
  1843. + }
  1844. + }
  1845. +
  1846. + replyMSG.append("</body></html>");
  1847. + adminReply.setHtml(replyMSG.toString());
  1848. + eventPlayer.sendPacket(adminReply);
  1849. +
  1850. + // Send a Server->Client ActionFailed to the L2PcInstance in order to avoid that the client wait another packet
  1851. + eventPlayer.sendPacket(ActionFailed.STATIC_PACKET);
  1852. + }
  1853. + catch (Exception e)
  1854. + {
  1855. + _log.warning("CTF Engine[showEventHtlm(" + eventPlayer.getName() + ", " + objectId + ")]: exception" + e.getMessage());
  1856. + }
  1857. + }
  1858. +
  1859. + public static void addPlayer(L2PcInstance player, String teamName)
  1860. + {
  1861. + if (!addPlayerOk(teamName, player))
  1862. + return;
  1863. +
  1864. + if (Config.CTF_EVEN_TEAMS.equals("NO") || Config.CTF_EVEN_TEAMS.equals("BALANCE"))
  1865. + {
  1866. + player._teamNameCTF = teamName;
  1867. + _players.add(player);
  1868. + setTeamPlayersCount(teamName, teamPlayersCount(teamName) + 1);
  1869. + }
  1870. + else if (Config.CTF_EVEN_TEAMS.equals("SHUFFLE"))
  1871. + _playersShuffle.add(player);
  1872. +
  1873. + player._inEventCTF = true;
  1874. + player._countCTFflags = 0;
  1875. + }
  1876. +
  1877. + public static synchronized void removeOfflinePlayers()
  1878. + {
  1879. + try
  1880. + {
  1881. + if (_playersShuffle == null)
  1882. + return;
  1883. + else if (_playersShuffle.isEmpty())
  1884. + return;
  1885. + else if (_playersShuffle.size() > 0)
  1886. + {
  1887. + for (L2PcInstance player : _playersShuffle)
  1888. + {
  1889. + if (player == null)
  1890. + _playersShuffle.remove(player);
  1891. + else if (player.isOnline() == 0 || player.isInJail())
  1892. + removePlayer(player);
  1893. + if (_playersShuffle.size() == 0 || _playersShuffle.isEmpty())
  1894. + break;
  1895. + }
  1896. + }
  1897. + }
  1898. + catch (Exception e)
  1899. + {
  1900. + _log.warning("CTF Engine exception: " + e.getMessage());
  1901. + return;
  1902. + }
  1903. + }
  1904. +
  1905. + public static boolean checkShufflePlayers(L2PcInstance eventPlayer)
  1906. + {
  1907. + try
  1908. + {
  1909. + for (L2PcInstance player : _playersShuffle)
  1910. + {
  1911. + if (player == null || player.isOnline() == 0)
  1912. + {
  1913. + _playersShuffle.remove(player);
  1914. + eventPlayer._inEventCTF = false;
  1915. + continue;
  1916. + }
  1917. + else if (player.getObjectId() == eventPlayer.getObjectId())
  1918. + {
  1919. + eventPlayer._inEventCTF = true;
  1920. + eventPlayer._countCTFflags = 0;
  1921. + return true;
  1922. + }
  1923. + //this 1 is incase player got new objectid after DC or reconnect
  1924. + else if (player.getName().equals(eventPlayer.getName()))
  1925. + {
  1926. + _playersShuffle.remove(player);
  1927. + _playersShuffle.add(eventPlayer);
  1928. + eventPlayer._inEventCTF = true;
  1929. + eventPlayer._countCTFflags = 0;
  1930. + return true;
  1931. + }
  1932. + }
  1933. + }
  1934. + catch (Exception e)
  1935. + {
  1936. + }
  1937. + return false;
  1938. + }
  1939. +
  1940. + public static boolean addPlayerOk(String teamName, L2PcInstance eventPlayer)
  1941. + {
  1942. + try
  1943. + {
  1944. + if (checkShufflePlayers(eventPlayer) || eventPlayer._inEventCTF)
  1945. + {
  1946. + eventPlayer.sendMessage("You are already participating in the event!");
  1947. + return false;
  1948. + }
  1949. +
  1950. + for (L2PcInstance player : _players)
  1951. + {
  1952. + if (player.getObjectId() == eventPlayer.getObjectId())
  1953. + {
  1954. + eventPlayer.sendMessage("You are already participating in the event!");
  1955. + return false;
  1956. + }
  1957. + else if (player.getName() == eventPlayer.getName())
  1958. + {
  1959. + eventPlayer.sendMessage("You are already participating in the event!");
  1960. + return false;
  1961. + }
  1962. + }
  1963. + if (_players.contains(eventPlayer))
  1964. + {
  1965. + eventPlayer.sendMessage("You are already participating in the event!");
  1966. + return false;
  1967. + }
  1968. + }
  1969. + catch (Exception e)
  1970. + {
  1971. + _log.warning("CTF Siege Engine exception: " + e.getMessage());
  1972. + }
  1973. +
  1974. + if (Config.CTF_EVEN_TEAMS.equals("NO"))
  1975. + return true;
  1976. + else if (Config.CTF_EVEN_TEAMS.equals("BALANCE"))
  1977. + {
  1978. + boolean allTeamsEqual = true;
  1979. + int countBefore = -1;
  1980. +
  1981. + for (int playersCount : _teamPlayersCount)
  1982. + {
  1983. + if (countBefore == -1)
  1984. + countBefore = playersCount;
  1985. +
  1986. + if (countBefore != playersCount)
  1987. + {
  1988. + allTeamsEqual = false;
  1989. + break;
  1990. + }
  1991. +
  1992. + countBefore = playersCount;
  1993. + }
  1994. +
  1995. + if (allTeamsEqual)
  1996. + return true;
  1997. +
  1998. + countBefore = Integer.MAX_VALUE;
  1999. +
  2000. + for (int teamPlayerCount : _teamPlayersCount)
  2001. + {
  2002. + if (teamPlayerCount < countBefore)
  2003. + countBefore = teamPlayerCount;
  2004. + }
  2005. +
  2006. + Vector<String> joinableTeams = new Vector<String>();
  2007. +
  2008. + for (String team : _teams)
  2009. + {
  2010. + if (teamPlayersCount(team) == countBefore)
  2011. + joinableTeams.add(team);
  2012. + }
  2013. +
  2014. + if (joinableTeams.contains(teamName))
  2015. + return true;
  2016. + }
  2017. + else if (Config.CTF_EVEN_TEAMS.equals("SHUFFLE"))
  2018. + return true;
  2019. +
  2020. + eventPlayer.sendMessage("Too many players in team \"" + teamName + "\"");
  2021. + return false;
  2022. + }
  2023. +
  2024. + public static synchronized void addDisconnectedPlayer(L2PcInstance player)
  2025. + {
  2026. + /*
  2027. + * !!! CAUTION !!!
  2028. + * Do NOT fix multiple object Ids on this event or you will ruin the flag reposition check!!!
  2029. + * All Multiple object Ids will be collected by the Garbage Collector, after the event ends, memory sweep is made!!!
  2030. + */
  2031. +
  2032. + if ((Config.CTF_EVEN_TEAMS.equals("SHUFFLE") && (_teleport || _started))
  2033. + || (Config.CTF_EVEN_TEAMS.equals("NO") || Config.CTF_EVEN_TEAMS.equals("BALANCE") && (_teleport || _started)))
  2034. + {
  2035. + if (Config.CTF_ON_START_REMOVE_ALL_EFFECTS)
  2036. + {
  2037. + for (L2Effect e : player.getAllEffects())
  2038. + {
  2039. + if (e != null)
  2040. + e.exit();
  2041. + }
  2042. + }
  2043. +
  2044. + player._teamNameCTF = _savePlayerTeams.get(_savePlayers.indexOf(player.getName()));
  2045. + for (L2PcInstance p : _players)
  2046. + {
  2047. + if (p == null)
  2048. + {
  2049. + continue;
  2050. + }
  2051. + //check by name incase player got new objectId
  2052. + else if (p.getName().equals(player.getName()))
  2053. + {
  2054. + player._originalNameColorCTF = player.getAppearance().getNameColor();
  2055. + player._originalKarmaCTF = player.getKarma();
  2056. + player._inEventCTF = true;
  2057. + player._countCTFflags = p._countCTFflags;
  2058. + _players.remove(p); //removing old object id from vector
  2059. + _players.add(player); //adding new objectId to vector
  2060. + break;
  2061. + }
  2062. + }
  2063. + player.getAppearance().setNameColor(_teamColors.get(_teams.indexOf(player._teamNameCTF)));
  2064. + player.setKarma(0);
  2065. + player.broadcastUserInfo();
  2066. + player.teleToLocation(_teamsX.get(_teams.indexOf(player._teamNameCTF)), _teamsY.get(_teams.indexOf(player._teamNameCTF)), _teamsZ.get(_teams
  2067. + .indexOf(player._teamNameCTF)));
  2068. + Started(player);
  2069. + CheckRestoreFlags();
  2070. + }
  2071. + }
  2072. +
  2073. + public static void removePlayer(L2PcInstance player)
  2074. + {
  2075. + if (player._inEventCTF)
  2076. + {
  2077. + if (!_joining)
  2078. + {
  2079. + player.getAppearance().setNameColor(player._originalNameColorCTF);
  2080. + player.setKarma(player._originalKarmaCTF);
  2081. + player.broadcastUserInfo();
  2082. + }
  2083. + player._teamNameCTF = new String();
  2084. + player._countCTFflags = 0;
  2085. + player._inEventCTF = false;
  2086. +
  2087. + if ((Config.CTF_EVEN_TEAMS.equals("NO") || Config.CTF_EVEN_TEAMS.equals("BALANCE")) && _players.contains(player))
  2088. + {
  2089. + setTeamPlayersCount(player._teamNameCTF, teamPlayersCount(player._teamNameCTF) - 1);
  2090. + _players.remove(player);
  2091. + }
  2092. + else if (Config.CTF_EVEN_TEAMS.equals("SHUFFLE") && (!_playersShuffle.isEmpty() && _playersShuffle.contains(player)))
  2093. + _playersShuffle.remove(player);
  2094. + }
  2095. + }
  2096. +
  2097. + public static void cleanCTF()
  2098. + {
  2099. + _log.warning("CTF : Cleaning players.");
  2100. + for (L2PcInstance player : _players)
  2101. + {
  2102. + if (player != null)
  2103. + {
  2104. + if (player._haveFlagCTF)
  2105. + removeFlagFromPlayer(player);
  2106. + else
  2107. + player.getInventory().destroyItemByItemId("", CTF._FLAG_IN_HAND_ITEM_ID, 1, player, null);
  2108. + player._haveFlagCTF = false;
  2109. + removePlayer(player);
  2110. + if (_savePlayers.contains(player.getName()))
  2111. + _savePlayers.remove(player.getName());
  2112. + player._inEventCTF = false;
  2113. + }
  2114. + }
  2115. + if (_playersShuffle != null && !_playersShuffle.isEmpty())
  2116. + {
  2117. + for (L2PcInstance player : _playersShuffle)
  2118. + {
  2119. + if (player != null)
  2120. + player._inEventCTF = false;
  2121. + }
  2122. + }
  2123. + _log.warning("CTF : Cleaning teams and flags.");
  2124. + for (String team : _teams)
  2125. + {
  2126. + int index = _teams.indexOf(team);
  2127. + _teamPointsCount.set(index, 0);
  2128. + _flagSpawns.set(index, null);
  2129. + _flagsTaken.set(index, false);
  2130. + _teamPlayersCount.set(index, 0);
  2131. + _teamPointsCount.set(index, 0);
  2132. + }
  2133. + _topScore = 0;
  2134. + _topTeam = new String();
  2135. + _players = new Vector<L2PcInstance>();
  2136. + _playersShuffle = new Vector<L2PcInstance>();
  2137. + _savePlayers = new Vector<String>();
  2138. + _savePlayerTeams = new Vector<String>();
  2139. + _teamPointsCount = new Vector<Integer>();
  2140. + _flagSpawns = new Vector<L2Spawn>();
  2141. + _flagsTaken = new Vector<Boolean>();
  2142. + _teamPlayersCount = new Vector<Integer>();
  2143. + _log.warning("Cleaning CTF done.");
  2144. + _log.warning("Loading new data from MySql");
  2145. + loadData();
  2146. + }
  2147. +
  2148. + public static void unspawnEventNpc()
  2149. + {
  2150. + if (_npcSpawn == null)
  2151. + return;
  2152. +
  2153. + _npcSpawn.getLastSpawn().deleteMe();
  2154. + _npcSpawn.stopRespawn();
  2155. + SpawnTable.getInstance().deleteSpawn(_npcSpawn, true);
  2156. + }
  2157. +
  2158. + public static void teleportFinish()
  2159. + {
  2160. + AnnounceToPlayers(false, _eventName + "(CTF): Teleport back to participation NPC in 20 seconds!");
  2161. + ThreadPoolManager.getInstance().scheduleGeneral (new Runnable()
  2162. + {
  2163. + public void run()
  2164. + {
  2165. + for (L2PcInstance player : _players)
  2166. + {
  2167. + if (player != null)
  2168. + {
  2169. + if (player.isOnline() != 0)
  2170. + player.teleToLocation(_npcX, _npcY, _npcZ, false);
  2171. + else
  2172. + {
  2173. + Connection con = null;
  2174. + try
  2175. + {
  2176. + con = L2DatabaseFactory.getInstance().getConnection();
  2177. +
  2178. + PreparedStatement statement = con.prepareStatement("UPDATE characters SET x=?, y=?, z=? WHERE char_name=?");
  2179. + statement.setInt(1, _npcX);
  2180. + statement.setInt(2, _npcY);
  2181. + statement.setInt(3, _npcZ);
  2182. + statement.setString(4, player.getName());
  2183. + statement.execute();
  2184. + statement.close();
  2185. + }
  2186. + catch (SQLException se)
  2187. + {
  2188. + _log.warning("CTF Engine exception: " + se.getMessage());
  2189. + }
  2190. + finally { try { if (con != null) con.close(); } catch (SQLException e) { e.printStackTrace(); } }
  2191. + }
  2192. + }
  2193. + }
  2194. + cleanCTF();
  2195. + }
  2196. + }, 20000);
  2197. + }
  2198. +
  2199. + public static int teamFlagCount(String teamName)
  2200. + {
  2201. + int index = _teams.indexOf(teamName);
  2202. +
  2203. + if (index == -1)
  2204. + return -1;
  2205. +
  2206. + return _teamPointsCount.get(index);
  2207. + }
  2208. +
  2209. + public static void setTeamFlagCount(String teamName, int teamFlagCount)
  2210. + {
  2211. + int index = _teams.indexOf(teamName);
  2212. +
  2213. + if (index == -1)
  2214. + return;
  2215. +
  2216. + _teamPointsCount.set(index, teamFlagCount);
  2217. + }
  2218. +
  2219. + /**
  2220. + * Used to calculate the event CTF area, so that players don't run off with the flag.
  2221. + * Essential, since a player may take the flag just so other teams can't score points.
  2222. + * This function is Only called upon ONE time on BEGINING OF EACH EVENT right after we spawn the flags.
  2223. + */
  2224. + private static void calculateOutSideOfCTF()
  2225. + {
  2226. + if (_teams == null || _flagSpawns == null || _teamsX == null || _teamsY == null || _teamsZ == null)
  2227. + return;
  2228. +
  2229. + int division = _teams.size() * 2, pos = 0;
  2230. + int[] locX = new int[division], locY = new int[division], locZ = new int[division];
  2231. + //Get all coordinates inorder to create a polygon:
  2232. + for (L2Spawn flag : _flagSpawns)
  2233. + {
  2234. + locX[pos] = flag.getLocx();
  2235. + locY[pos] = flag.getLocy();
  2236. + locZ[pos] = flag.getLocz();
  2237. + pos++;
  2238. + if (pos > division / 2)
  2239. + break;
  2240. + }
  2241. +
  2242. + for (int x = 0; x < _teams.size(); x++)
  2243. + {
  2244. + locX[pos] = _teamsX.get(x);
  2245. + locY[pos] = _teamsY.get(x);
  2246. + locZ[pos] = _teamsZ.get(x);
  2247. + pos++;
  2248. + if (pos > division)
  2249. + break;
  2250. + }
  2251. +
  2252. + //find the polygon center, note that it's not the mathematical center of the polygon,
  2253. + //rather than a point which centers all coordinates:
  2254. + int centerX = 0, centerY = 0, centerZ = 0;
  2255. + for (int x = 0; x < pos; x++)
  2256. + {
  2257. + centerX += (locX[x] / division);
  2258. + centerY += (locY[x] / division);
  2259. + centerZ += (locZ[x] / division);
  2260. + }
  2261. +
  2262. + //now let's find the furthest distance from the "center" to the egg shaped sphere
  2263. + //surrounding the polygon, size x1.5 (for maximum logical area to wander...):
  2264. + int maxX = 0, maxY = 0, maxZ = 0;
  2265. + for (int x = 0; x < pos; x++)
  2266. + {
  2267. + if (maxX < 2 * Math.abs(centerX - locX[x]))
  2268. + maxX = (2 * Math.abs(centerX - locX[x]));
  2269. + if (maxY < 2 * Math.abs(centerY - locY[x]))
  2270. + maxY = (2 * Math.abs(centerY - locY[x]));
  2271. + if (maxZ < 2 * Math.abs(centerZ - locZ[x]))
  2272. + maxZ = (2 * Math.abs(centerZ - locZ[x]));
  2273. + }
  2274. +
  2275. + //centerX,centerY,centerZ are the coordinates of the "event center".
  2276. + //so let's save those coordinates to check on the players:
  2277. + eventCenterX = centerX;
  2278. + eventCenterY = centerY;
  2279. + eventCenterZ = centerZ;
  2280. + eventOffset = maxX;
  2281. + if (eventOffset < maxY)
  2282. + eventOffset = maxY;
  2283. + if (eventOffset < maxZ)
  2284. + eventOffset = maxZ;
  2285. + }
  2286. +
  2287. + public static boolean isOutsideCTFArea(L2PcInstance _player)
  2288. + {
  2289. + if (_player == null || _player.isOnline() == 0)
  2290. + return true;
  2291. + if (!(_player.getX() > eventCenterX - eventOffset && _player.getX() < eventCenterX + eventOffset && _player.getY() > eventCenterY - eventOffset
  2292. + && _player.getY() < eventCenterY + eventOffset && _player.getZ() > eventCenterZ - eventOffset && _player.getZ() < eventCenterZ + eventOffset))
  2293. + return true;
  2294. + return false;
  2295. + }
  2296. +}
  2297. \ No newline at end of file
  2298. Index: java/com/l2jserver/gameserver/model/actor/stat/PcStat.java
  2299. ===================================================================
  2300. --- java/com/l2jserver/gameserver/model/actor/stat/PcStat.java (revision 3844)
  2301. +++ java/com/l2jserver/gameserver/model/actor/stat/PcStat.java (working copy)
  2302. @@ -21,6 +21,7 @@
  2303. import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
  2304. import com.l2jserver.gameserver.model.actor.instance.L2PetInstance;
  2305. import com.l2jserver.gameserver.model.base.Experience;
  2306. +import com.l2jserver.gameserver.model.entity.CTF;
  2307. import com.l2jserver.gameserver.model.quest.QuestState;
  2308. import com.l2jserver.gameserver.network.SystemMessageId;
  2309. import com.l2jserver.gameserver.network.serverpackets.ExBrExtraUserInfo;
  2310. @@ -212,6 +213,13 @@
  2311. getActiveChar().sendPacket(new SystemMessage(SystemMessageId.YOU_INCREASED_YOUR_LEVEL));
  2312.  
  2313. L2ClassMasterInstance.showQuestionMark(getActiveChar());
  2314. +
  2315. + if (getActiveChar().isInFunEvent())
  2316. + {
  2317. + if (getActiveChar()._inEventCTF && CTF._maxlvl == getLevel() && !CTF._started)
  2318. + CTF.removePlayer(getActiveChar());
  2319. + getActiveChar().sendMessage("Your event sign up was canceled.");
  2320. + }
  2321. }
  2322.  
  2323. getActiveChar().rewardSkills(); // Give Expertise skill of this level
  2324. Index: java/com/l2jserver/gameserver/network/clientpackets/RequestBypassToServer.java
  2325. ===================================================================
  2326. --- java/com/l2jserver/gameserver/network/clientpackets/RequestBypassToServer.java (revision 3844)
  2327. +++ java/com/l2jserver/gameserver/network/clientpackets/RequestBypassToServer.java (working copy)
  2328. @@ -30,6 +30,7 @@
  2329. import com.l2jserver.gameserver.model.actor.L2Npc;
  2330. import com.l2jserver.gameserver.model.actor.instance.L2MerchantSummonInstance;
  2331. import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
  2332. +import com.l2jserver.gameserver.model.entity.CTF;
  2333. import com.l2jserver.gameserver.model.entity.L2Event;
  2334. import com.l2jserver.gameserver.model.olympiad.Olympiad;
  2335. import com.l2jserver.gameserver.network.SystemMessageId;
  2336. @@ -130,6 +131,24 @@
  2337. else if (object instanceof L2Npc && endOfId > 0 && activeChar.isInsideRadius(object, L2Npc.INTERACTION_DISTANCE, false, false))
  2338. ((L2Npc)object).onBypassFeedback(activeChar, _command.substring(endOfId+1));
  2339.  
  2340. + // Add by CTF Event
  2341. + if (_command.substring(endOfId+1).startsWith("ctf_player_join "))
  2342. + {
  2343. + String teamName = _command.substring(endOfId+1).substring(16);
  2344. +
  2345. + if (CTF._joining)
  2346. + CTF.addPlayer(activeChar, teamName);
  2347. + else
  2348. + activeChar.sendMessage("The event is already started. You can not join now!");
  2349. + }
  2350. + else if (_command.substring(endOfId+1).startsWith("ctf_player_leave"))
  2351. + {
  2352. + if (CTF._joining)
  2353. + CTF.removePlayer(activeChar);
  2354. + else
  2355. + activeChar.sendMessage("The event is already started. You can not leave now!");
  2356. + }
  2357. +
  2358. activeChar.sendPacket(ActionFailed.STATIC_PACKET);
  2359. }
  2360. catch (NumberFormatException nfe) {}
  2361. Index: java/com/l2jserver/Config.java
  2362. ===================================================================
  2363. --- java/com/l2jserver/Config.java (revision 3844)
  2364. +++ java/com/l2jserver/Config.java (working copy)
  2365. @@ -622,6 +622,18 @@
  2366. public static TIntIntHashMap TVT_EVENT_FIGHTER_BUFFS;
  2367. public static TIntIntHashMap TVT_EVENT_MAGE_BUFFS;
  2368. public static boolean TVT_ALLOW_VOICED_COMMAND;
  2369. + public static String CTF_EVEN_TEAMS;
  2370. + public static boolean CTF_ALLOW_VOICE_COMMAND;
  2371. + public static boolean CTF_ALLOW_INTERFERENCE;
  2372. + public static boolean CTF_ALLOW_POTIONS;
  2373. + public static boolean CTF_ALLOW_SUMMON;
  2374. + public static boolean CTF_ON_START_REMOVE_ALL_EFFECTS;
  2375. + public static boolean CTF_ON_START_UNSUMMON_PET;
  2376. + public static boolean CTF_ANNOUNCE_TEAM_STATS;
  2377. + public static boolean CTF_ANNOUNCE_REWARD;
  2378. + public static boolean CTF_JOIN_CURSED;
  2379. + public static boolean CTF_REVIVE_RECOVERY;
  2380. + public static long CTF_REVIVE_DELAY;
  2381. public static boolean L2JMOD_ALLOW_WEDDING;
  2382. public static int L2JMOD_WEDDING_PRICE;
  2383. public static boolean L2JMOD_WEDDING_PUNISH_INFIDELITY;
  2384. @@ -2120,6 +2132,22 @@
  2385. }
  2386. }
  2387.  
  2388. + CTF_EVEN_TEAMS = L2JModSettings.getProperty("CTFEvenTeams", "BALANCE");
  2389. + CTF_ALLOW_VOICE_COMMAND = Boolean.parseBoolean(L2JModSettings.getProperty("CTFAllowVoiceCommand", "false"));
  2390. + CTF_ALLOW_INTERFERENCE = Boolean.parseBoolean(L2JModSettings.getProperty("CTFAllowInterference", "false"));
  2391. + CTF_ALLOW_POTIONS = Boolean.parseBoolean(L2JModSettings.getProperty("CTFAllowPotions", "false"));
  2392. + CTF_ALLOW_SUMMON = Boolean.parseBoolean(L2JModSettings.getProperty("CTFAllowSummon", "false"));
  2393. + CTF_ON_START_REMOVE_ALL_EFFECTS = Boolean.parseBoolean(L2JModSettings.getProperty("CTFOnStartRemoveAllEffects", "true"));
  2394. + CTF_ON_START_UNSUMMON_PET = Boolean.parseBoolean(L2JModSettings.getProperty("CTFOnStartUnsummonPet", "true"));
  2395. + CTF_ANNOUNCE_TEAM_STATS = Boolean.parseBoolean(L2JModSettings.getProperty("CTFAnnounceTeamStats", "false"));
  2396. + CTF_ANNOUNCE_REWARD = Boolean.parseBoolean(L2JModSettings.getProperty("CTFAnnounceReward", "false"));
  2397. + CTF_JOIN_CURSED = Boolean.parseBoolean(L2JModSettings.getProperty("CTFJoinWithCursedWeapon", "true"));
  2398. + CTF_REVIVE_RECOVERY = Boolean.parseBoolean(L2JModSettings.getProperty("CTFReviveRecovery", "false"));
  2399. + CTF_REVIVE_DELAY = Long.parseLong(L2JModSettings.getProperty("CTFReviveDelay", "20000"));
  2400. +
  2401. + if (CTF_REVIVE_DELAY < 1000)
  2402. + CTF_REVIVE_DELAY = 1000; //can't be set less then 1 second
  2403. +
  2404. BANKING_SYSTEM_ENABLED = Boolean.parseBoolean(L2JModSettings.getProperty("BankingEnabled", "false"));
  2405. BANKING_SYSTEM_GOLDBARS = Integer.parseInt(L2JModSettings.getProperty("BankingGoldbarCount", "1"));
  2406. BANKING_SYSTEM_ADENA = Integer.parseInt(L2JModSettings.getProperty("BankingAdenaCount", "500000000"));
  2407. @@ -2762,6 +2790,16 @@
  2408.  
  2409. else if (pName.equalsIgnoreCase("EnableManaPotionSupport")) L2JMOD_ENABLE_MANA_POTIONS_SUPPORT = Boolean.parseBoolean(pValue);
  2410.  
  2411. + // L2JMOD CTF Event
  2412. + else if (pName.equalsIgnoreCase("CTFEvenTeams")) CTF_EVEN_TEAMS = pValue;
  2413. + else if (pName.equalsIgnoreCase("CTFAllowVoiceCommand")) CTF_ALLOW_VOICE_COMMAND = Boolean.parseBoolean(pValue);
  2414. + else if (pName.equalsIgnoreCase("CTFAllowInterference")) CTF_ALLOW_INTERFERENCE = Boolean.parseBoolean(pValue);
  2415. + else if (pName.equalsIgnoreCase("CTFAllowPotions")) CTF_ALLOW_POTIONS = Boolean.parseBoolean(pValue);
  2416. + else if (pName.equalsIgnoreCase("CTFAllowSummon")) CTF_ALLOW_SUMMON = Boolean.parseBoolean(pValue);
  2417. + else if (pName.equalsIgnoreCase("CTFOnStartRemoveAllEffects")) CTF_ON_START_REMOVE_ALL_EFFECTS = Boolean.parseBoolean(pValue);
  2418. + else if (pName.equalsIgnoreCase("CTFOnStartUnsummonPet")) CTF_ON_START_UNSUMMON_PET = Boolean.parseBoolean(pValue);
  2419. + else if (pName.equalsIgnoreCase("CTFReviveDelay")) CTF_REVIVE_DELAY = Long.parseLong(pValue);
  2420. +
  2421. else if (pName.equalsIgnoreCase("DisplayServerTime")) L2JMOD_DISPLAY_SERVER_TIME = Boolean.parseBoolean(pValue);
  2422.  
  2423. else if (pName.equalsIgnoreCase("AntiFeedEnable")) L2JMOD_ANTIFEED_ENABLE = Boolean.parseBoolean(pValue);
  2424. Index: java/com/l2jserver/gameserver/model/actor/L2Summon.java
  2425. ===================================================================
  2426. --- java/com/l2jserver/gameserver/model/actor/L2Summon.java (revision 3844)
  2427. +++ java/com/l2jserver/gameserver/model/actor/L2Summon.java (working copy)
  2428. @@ -734,7 +734,8 @@
  2429. {
  2430. if (isInsidePeaceZone(this, target)
  2431. && getOwner() != null
  2432. - && (!getOwner().getAccessLevel().allowPeaceAttack()))
  2433. + && (!getOwner().getAccessLevel().allowPeaceAttack())
  2434. + && (!this.isInFunEvent() || !target.isInFunEvent()))
  2435. {
  2436. // If summon or target is in a peace zone, send a system message TARGET_IN_PEACEZONE
  2437. sendPacket(new SystemMessage(SystemMessageId.TARGET_IN_PEACEZONE));
  2438. Index: java/com/l2jserver/gameserver/model/actor/L2Npc.java
  2439. ===================================================================
  2440. --- java/com/l2jserver/gameserver/model/actor/L2Npc.java (revision 3844)
  2441. +++ java/com/l2jserver/gameserver/model/actor/L2Npc.java (working copy)
  2442. @@ -69,6 +69,7 @@
  2443. import com.l2jserver.gameserver.model.actor.knownlist.NpcKnownList;
  2444. import com.l2jserver.gameserver.model.actor.stat.NpcStat;
  2445. import com.l2jserver.gameserver.model.actor.status.NpcStatus;
  2446. +import com.l2jserver.gameserver.model.entity.CTF;
  2447. import com.l2jserver.gameserver.model.entity.Castle;
  2448. import com.l2jserver.gameserver.model.entity.Fort;
  2449. import com.l2jserver.gameserver.model.entity.L2Event;
  2450. @@ -148,6 +149,12 @@
  2451. public boolean isEventMob = false;
  2452. private boolean _isInTown = false;
  2453.  
  2454. + // Add by CTF Event
  2455. + public boolean _isEventMobCTF = false;
  2456. + public boolean _isCTF_throneSpawn = false;
  2457. + public boolean _isCTF_Flag = false;
  2458. + public String _CTF_FlagTeamName;
  2459. +
  2460. private int _isSpoiledBy = 0;
  2461.  
  2462. /** Time of last social packet broadcast*/
  2463. @@ -1106,6 +1113,19 @@
  2464. {
  2465. L2Event.showEventHtml(player, String.valueOf(getObjectId()));
  2466. }
  2467. + // Add by CTF Event
  2468. + else if (_isEventMobCTF)
  2469. + {
  2470. + CTF.showEventHtml(player, String.valueOf(getObjectId()));
  2471. + }
  2472. + else if (_isCTF_Flag && player._inEventCTF)
  2473. + {
  2474. + CTF.showFlagHtml(player, String.valueOf(this.getObjectId()), _CTF_FlagTeamName);
  2475. + }
  2476. + else if (_isCTF_throneSpawn)
  2477. + {
  2478. + CTF.CheckRestoreFlags();
  2479. + }
  2480. else
  2481. {
  2482. Quest[] qlsa = getTemplate().getEventQuests(Quest.QuestEventType.QUEST_START);
  2483. Index: java/com/l2jserver/gameserver/network/clientpackets/EnterWorld.java
  2484. ===================================================================
  2485. --- java/com/l2jserver/gameserver/network/clientpackets/EnterWorld.java (revision 3844)
  2486. +++ java/com/l2jserver/gameserver/network/clientpackets/EnterWorld.java (working copy)
  2487. @@ -47,6 +47,7 @@
  2488. import com.l2jserver.gameserver.model.actor.L2Character;
  2489. import com.l2jserver.gameserver.model.actor.instance.L2ClassMasterInstance;
  2490. import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
  2491. +import com.l2jserver.gameserver.model.entity.CTF;
  2492. import com.l2jserver.gameserver.model.entity.ClanHall;
  2493. import com.l2jserver.gameserver.model.entity.Couple;
  2494. import com.l2jserver.gameserver.model.entity.Fort;
  2495. @@ -474,6 +475,11 @@
  2496.  
  2497. L2ClassMasterInstance.showQuestionMark(activeChar);
  2498.  
  2499. + if (CTF._savePlayers.contains(activeChar.getName()))
  2500. + {
  2501. + CTF.addDisconnectedPlayer(activeChar);
  2502. + }
  2503. +
  2504. int birthday = activeChar.checkBirthDay();
  2505. if (birthday == 0)
  2506. {
  2507. Index: java/com/l2jserver/gameserver/network/clientpackets/RequestActionUse.java
  2508. ===================================================================
  2509. --- java/com/l2jserver/gameserver/network/clientpackets/RequestActionUse.java (revision 3844)
  2510. +++ java/com/l2jserver/gameserver/network/clientpackets/RequestActionUse.java (working copy)
  2511. @@ -169,7 +169,8 @@
  2512. return;
  2513. }
  2514.  
  2515. - if (!activeChar.getAccessLevel().allowPeaceAttack() && activeChar.isInsidePeaceZone(pet, target))
  2516. + if (!activeChar.getAccessLevel().allowPeaceAttack() && activeChar.isInsidePeaceZone(pet, target)
  2517. + && (!activeChar.isInFunEvent() || !target.isInFunEvent()))
  2518. {
  2519. activeChar.sendPacket(new SystemMessage(SystemMessageId.TARGET_IN_PEACEZONE));
  2520. return;
  2521. Index: java/com/l2jserver/gameserver/skills/l2skills/L2SkillTeleport.java
  2522. ===================================================================
  2523. --- java/com/l2jserver/gameserver/skills/l2skills/L2SkillTeleport.java (revision 3844)
  2524. +++ java/com/l2jserver/gameserver/skills/l2skills/L2SkillTeleport.java (working copy)
  2525. @@ -99,6 +99,13 @@
  2526. continue;
  2527. }
  2528.  
  2529. + // Check to see if the current player target is in CTF
  2530. + if (targetChar._inEventCTF)
  2531. + {
  2532. + targetChar.sendMessage("You may not use an escape skill in a Event.");
  2533. + continue;
  2534. + }
  2535. +
  2536. // Check to see if player is in jail
  2537. if (targetChar.isInJail())
  2538. {
  2539. Index: java/com/l2jserver/gameserver/model/CursedWeapon.java
  2540. ===================================================================
  2541. --- java/com/l2jserver/gameserver/model/CursedWeapon.java (revision 3844)
  2542. +++ java/com/l2jserver/gameserver/model/CursedWeapon.java (working copy)
  2543. @@ -30,6 +30,7 @@
  2544. import com.l2jserver.gameserver.model.actor.L2Attackable;
  2545. import com.l2jserver.gameserver.model.actor.L2Character;
  2546. import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
  2547. +import com.l2jserver.gameserver.model.entity.CTF;
  2548. import com.l2jserver.gameserver.network.SystemMessageId;
  2549. import com.l2jserver.gameserver.network.serverpackets.Earthquake;
  2550. import com.l2jserver.gameserver.network.serverpackets.ExRedSky;
  2551. @@ -416,6 +417,13 @@
  2552. }
  2553. }
  2554.  
  2555. + // Add by CTF Event
  2556. + if(player._inEventCTF && !Config.CTF_JOIN_CURSED)
  2557. + {
  2558. + if(player._inEventCTF)
  2559. + CTF.removePlayer(player);
  2560. + }
  2561. +
  2562. _isActivated = true;
  2563.  
  2564. // Player holding it data
  2565. Index: java/com/l2jserver/gameserver/model/actor/instance/L2PcInstance.java
  2566. ===================================================================
  2567. --- java/com/l2jserver/gameserver/model/actor/instance/L2PcInstance.java (revision 3844)
  2568. +++ java/com/l2jserver/gameserver/model/actor/instance/L2PcInstance.java (working copy)
  2569. @@ -136,6 +136,7 @@
  2570. import com.l2jserver.gameserver.model.base.PlayerClass;
  2571. import com.l2jserver.gameserver.model.base.Race;
  2572. import com.l2jserver.gameserver.model.base.SubClass;
  2573. +import com.l2jserver.gameserver.model.entity.CTF;
  2574. import com.l2jserver.gameserver.model.entity.Castle;
  2575. import com.l2jserver.gameserver.model.entity.Duel;
  2576. import com.l2jserver.gameserver.model.entity.Fort;
  2577. @@ -726,6 +727,17 @@
  2578. public boolean eventSitForced = false;
  2579. public boolean atEvent = false;
  2580.  
  2581. + /** CTF Engine parameters */
  2582. + public String _teamNameCTF,
  2583. + _teamNameHaveFlagCTF,
  2584. + _originalTitleCTF;
  2585. + public int _originalNameColorCTF,
  2586. + _originalKarmaCTF,
  2587. + _countCTFflags;
  2588. + public boolean _inEventCTF = false,
  2589. + _haveFlagCTF = false;
  2590. + public Future<?> _posCheckerCTF = null;
  2591. +
  2592. /** new loto ticket **/
  2593. private int _loto[] = new int[5];
  2594. //public static int _loto_nums[] = {0,1,2,3,4,5,6,7,8,9,};
  2595. @@ -3121,6 +3133,11 @@
  2596. {
  2597. sendMessage("A dark force beyond your mortal understanding makes your knees to shake when you try to stand up ...");
  2598. }
  2599. + // Add by CTF Event
  2600. + else if (CTF._sitForced && _inEventCTF)
  2601. + {
  2602. + sendMessage("The Admin/GM handle if you sit or stand in this match!");
  2603. + }
  2604. else if (_waitTypeSitting && !isInStoreMode() && !isAlikeDead())
  2605. {
  2606. if (_relax)
  2607. @@ -4224,6 +4241,16 @@
  2608. player.sendPacket(ActionFailed.STATIC_PACKET);
  2609. return;
  2610. }
  2611. +
  2612. + // Add by CTF Event
  2613. + if (CTF._started && !Config.CTF_ALLOW_INTERFERENCE)
  2614. + {
  2615. + if ((_inEventCTF && !player._inEventCTF) || (!_inEventCTF && player._inEventCTF))
  2616. + {
  2617. + sendPacket(ActionFailed.STATIC_PACKET);
  2618. + return;
  2619. + }
  2620. + }
  2621.  
  2622. // Check if the L2PcInstance is confused
  2623. if (player.isOutOfControl())
  2624. @@ -4263,7 +4290,7 @@
  2625. else
  2626. {
  2627. // Check if this L2PcInstance is autoAttackable
  2628. - if (isAutoAttackable(player))
  2629. + if (isAutoAttackable(player) || (player._inEventCTF && CTF._started)) // Modified by CTF Event
  2630. {
  2631. // Player with lvl < 21 can't attack a cursed weapon holder
  2632. // And a cursed weapon holder can't attack players with lvl < 21
  2633. @@ -4333,6 +4360,12 @@
  2634. player.sendPacket(ActionFailed.STATIC_PACKET);
  2635. }
  2636.  
  2637. + // Add by CTF Event
  2638. + public boolean isInFunEvent()
  2639. + {
  2640. + return (atEvent || (CTF._started && _inEventCTF));
  2641. + }
  2642. +
  2643. /**
  2644. * Returns true if cp update should be done, false if not
  2645. * @return boolean
  2646. @@ -5457,6 +5490,28 @@
  2647.  
  2648. TvTEvent.onKill(killer, this);
  2649.  
  2650. + // Add by CTF Event
  2651. + if (_inEventCTF)
  2652. + {
  2653. + if (CTF._teleport || CTF._started)
  2654. + {
  2655. + sendMessage("You will be revived and teleported to team flag in " + Config.CTF_REVIVE_DELAY / 1000 + " seconds!");
  2656. +
  2657. + if (_haveFlagCTF)
  2658. + removeCTFFlagOnDie();
  2659. +
  2660. + ThreadPoolManager.getInstance().scheduleGeneral(new Runnable()
  2661. + {
  2662. + public void run()
  2663. + {
  2664. + teleToLocation(CTF._teamsX.get(CTF._teams.indexOf(_teamNameCTF)), CTF._teamsY.get(CTF._teams.indexOf(_teamNameCTF)), CTF._teamsZ
  2665. + .get(CTF._teams.indexOf(_teamNameCTF)), false);
  2666. + doRevive();
  2667. + }
  2668. + }, Config.CTF_REVIVE_DELAY);
  2669. + }
  2670. + }
  2671. +
  2672. if (atEvent && pk != null)
  2673. {
  2674. pk.kills.add(getName());
  2675. @@ -5596,9 +5651,20 @@
  2676. return true;
  2677. }
  2678.  
  2679. + // Add by CTF Event
  2680. + public void removeCTFFlagOnDie()
  2681. + {
  2682. + CTF._flagsTaken.set(CTF._teams.indexOf(_teamNameHaveFlagCTF), false);
  2683. + CTF.spawnFlag(_teamNameHaveFlagCTF);
  2684. + CTF.removeFlagFromPlayer(this);
  2685. + broadcastUserInfo();
  2686. + _haveFlagCTF = false;
  2687. + CTF.AnnounceToPlayers(false, CTF._eventName + "(CTF): " + _teamNameHaveFlagCTF + "'s flag returned.");
  2688. + }
  2689. +
  2690. private void onDieDropItem(L2Character killer)
  2691. {
  2692. - if (atEvent || killer == null)
  2693. + if (atEvent || (CTF._started && _inEventCTF) || killer == null) // Modified by CTF Event
  2694. return;
  2695.  
  2696. L2PcInstance pk = killer.getActingPlayer();
  2697. @@ -5711,6 +5777,9 @@
  2698. if (target == null) return;
  2699. if (!(target instanceof L2Playable)) return;
  2700.  
  2701. + // Add by CTF Event
  2702. + if (_inEventCTF) return;
  2703. +
  2704. L2PcInstance targetPlayer = target.getActingPlayer();
  2705.  
  2706. if (targetPlayer == null) return; // Target player is null
  2707. @@ -5800,6 +5869,9 @@
  2708. if (target instanceof L2PcInstance
  2709. && AntiFeedManager.getInstance().check(this, target))
  2710. {
  2711. + // Add by CTF Event
  2712. + if (CTF._started && _inEventCTF) return;
  2713. +
  2714. // Add karma to attacker and increase its PK counter
  2715. setPvpKills(getPvpKills() + 1);
  2716.  
  2717. @@ -5817,6 +5889,9 @@
  2718. */
  2719. public void increasePkKillsAndKarma(L2Character target)
  2720. {
  2721. + // Add by CTF Event
  2722. + if (CTF._started && _inEventCTF) return;
  2723. +
  2724. int baseKarma = Config.KARMA_MIN_KARMA;
  2725. int newKarma = baseKarma;
  2726. int karmaLimit = Config.KARMA_MAX_KARMA;
  2727. @@ -5898,6 +5973,9 @@
  2728.  
  2729. public void updatePvPStatus()
  2730. {
  2731. + // Add by CTF Event
  2732. + if (CTF._started && _inEventCTF) return;
  2733. +
  2734. if (isInsideZone(ZONE_PVP)) return;
  2735. setPvpFlagLasts(System.currentTimeMillis() + Config.PVP_NORMAL_TIME);
  2736.  
  2737. @@ -5912,6 +5990,9 @@
  2738. if (player_target == null)
  2739. return;
  2740.  
  2741. + // Add by CTF Event
  2742. + if (CTF._started && _inEventCTF && player_target._inEventCTF) return;
  2743. +
  2744. if ((isInDuel() && player_target.getDuelId() == getDuelId())) return;
  2745. if ((!isInsideZone(ZONE_PVP) || !player_target.isInsideZone(ZONE_PVP)) && player_target.getKarma() == 0)
  2746. {
  2747. @@ -6006,7 +6087,7 @@
  2748.  
  2749. // Calculate the Experience loss
  2750. long lostExp = 0;
  2751. - if (!atEvent)
  2752. + if (!atEvent && !_inEventCTF) // Modified by CTF Event
  2753. if (lvl < Experience.MAX_LEVEL)
  2754. lostExp = Math.round((getStat().getExpForLevel(lvl+1) - getStat().getExpForLevel(lvl)) * percentLost /100);
  2755. else
  2756. @@ -6772,6 +6853,14 @@
  2757. sendPacket(new SystemMessage(SystemMessageId.STRIDER_CANT_BE_RIDDEN_WHILE_DEAD));
  2758. return false;
  2759. }
  2760. + // Add by CTF Event
  2761. + else if (_haveFlagCTF)
  2762. + {
  2763. + // You cannot mount a steed while holding a flag.
  2764. + sendPacket(ActionFailed.STATIC_PACKET);
  2765. + sendPacket (new SystemMessage(SystemMessageId.YOU_CANNOT_MOUNT_A_STEED_WHILE_HOLDING_A_FLAG));
  2766. + return false;
  2767. + }
  2768. else if (pet.isDead())
  2769. {
  2770. //A dead strider cannot be ridden.
  2771. @@ -9360,7 +9449,11 @@
  2772. */
  2773. public boolean checkPvpSkill(L2Object target, L2Skill skill)
  2774. {
  2775. - return checkPvpSkill(target, skill, false);
  2776. + // Add and Modified by CTF Event
  2777. + if (_inEventCTF && CTF._started)
  2778. + return true;
  2779. + else
  2780. + return checkPvpSkill(target, skill, false);
  2781. }
  2782.  
  2783. /**
  2784. @@ -11039,6 +11132,13 @@
  2785. if (!DimensionalRiftManager.getInstance().checkIfInPeaceZone(getX(), getY(), getZ()))
  2786. getParty().getDimensionalRift().memberRessurected(this);
  2787. }
  2788. + // Add by CTF Event
  2789. + if (_inEventCTF && CTF._started && Config.CTF_REVIVE_RECOVERY)
  2790. + {
  2791. + getStatus().setCurrentHp(getMaxHp());
  2792. + getStatus().setCurrentMp(getMaxMp());
  2793. + getStatus().setCurrentCp(getMaxCp());
  2794. + }
  2795. }
  2796.  
  2797. @Override
  2798. Index: java/com/l2jserver/gameserver/network/clientpackets/RequestUnEquipItem.java
  2799. ===================================================================
  2800. --- java/com/l2jserver/gameserver/network/clientpackets/RequestUnEquipItem.java (revision 3844)
  2801. +++ java/com/l2jserver/gameserver/network/clientpackets/RequestUnEquipItem.java (working copy)
  2802. @@ -60,6 +60,12 @@
  2803. if (activeChar == null)
  2804. return;
  2805.  
  2806. + if (activeChar._haveFlagCTF)
  2807. + {
  2808. + activeChar.sendMessage("You can't unequip a CTF flag.");
  2809. + return;
  2810. + }
  2811. +
  2812. L2ItemInstance item = activeChar.getInventory().getPaperdollItemByL2ItemId(_slot);
  2813. if (item != null && item.isWear())
  2814. {
  2815. Index: java/com/l2jserver/gameserver/model/L2Skill.java
  2816. ===================================================================
  2817. --- java/com/l2jserver/gameserver/model/L2Skill.java (revision 3844)
  2818. +++ java/com/l2jserver/gameserver/model/L2Skill.java (working copy)
  2819. @@ -35,6 +35,7 @@
  2820. import com.l2jserver.gameserver.model.actor.instance.L2PetInstance;
  2821. import com.l2jserver.gameserver.model.actor.instance.L2SiegeFlagInstance;
  2822. import com.l2jserver.gameserver.model.actor.instance.L2SummonInstance;
  2823. +import com.l2jserver.gameserver.model.entity.CTF;
  2824. import com.l2jserver.gameserver.model.entity.TvTEvent;
  2825. import com.l2jserver.gameserver.network.SystemMessageId;
  2826. import com.l2jserver.gameserver.network.serverpackets.SystemMessage;
  2827. @@ -2143,6 +2144,13 @@
  2828. final L2PcInstance targetPlayer = target.getActingPlayer();
  2829. if (targetPlayer != null)
  2830. {
  2831. + // Add by CTF Event - check if allow interference is allowed if player is not on event but target is on event
  2832. + if ((CTF._started && !Config.CTF_ALLOW_INTERFERENCE) && !player.isGM())
  2833. + {
  2834. + if ((targetPlayer._inEventCTF && !player._inEventCTF) || (!targetPlayer._inEventCTF && player._inEventCTF))
  2835. + return false;
  2836. + }
  2837. +
  2838. if (targetPlayer == caster || targetPlayer == player)
  2839. return false;
  2840.  
  2841. Index: java/com/l2jserver/gameserver/model/L2Radar.java
  2842. ===================================================================
  2843. --- java/com/l2jserver/gameserver/model/L2Radar.java (revision 3844)
  2844. +++ java/com/l2jserver/gameserver/model/L2Radar.java (working copy)
  2845. @@ -14,6 +14,7 @@
  2846. */
  2847. package com.l2jserver.gameserver.model;
  2848.  
  2849. +import com.l2jserver.gameserver.ThreadPoolManager;
  2850. import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
  2851. import com.l2jserver.gameserver.network.serverpackets.RadarControl;
  2852.  
  2853. @@ -128,4 +129,33 @@
  2854. return true;
  2855. }
  2856. }
  2857. + // Add by CTF Event
  2858. + public class RadarOnPlayer implements Runnable
  2859. + {
  2860. + private final L2PcInstance _myTarget, _me;
  2861. +
  2862. + public RadarOnPlayer(L2PcInstance target, L2PcInstance me)
  2863. + {
  2864. + _me = me;
  2865. + _myTarget = target;
  2866. + }
  2867. +
  2868. + public void run()
  2869. + {
  2870. + try
  2871. + {
  2872. + if (_me == null || _me.isOnline()==0)
  2873. + return;
  2874. +
  2875. + _me.sendPacket(new RadarControl(1, 1, _me.getX(), _me.getY(), _me.getZ()));
  2876. + if (_myTarget == null || _myTarget.isOnline()==0 || !_myTarget._haveFlagCTF)
  2877. + return;
  2878. +
  2879. + _me.sendPacket(new RadarControl(0, 1, _myTarget.getX(), _myTarget.getY(), _myTarget.getZ()));
  2880. + ThreadPoolManager.getInstance().scheduleGeneral(new RadarOnPlayer(_myTarget,_me), 15000);
  2881. + }
  2882. + catch(Throwable t)
  2883. + {}
  2884. + }
  2885. + }
  2886. }
  2887. Index: java/com/l2jserver/gameserver/network/clientpackets/UseItem.java
  2888. ===================================================================
  2889. --- java/com/l2jserver/gameserver/network/clientpackets/UseItem.java (revision 3844)
  2890. +++ java/com/l2jserver/gameserver/network/clientpackets/UseItem.java (working copy)
  2891. @@ -254,7 +254,7 @@
  2892. activeChar.sendPacket(new SystemMessage(SystemMessageId.CANNOT_USE_ITEM_WHILE_USING_MAGIC));
  2893. return;
  2894. }
  2895. - if (activeChar.isMounted())
  2896. + if (activeChar.isMounted() || (activeChar._inEventCTF && activeChar._haveFlagCTF))
  2897. {
  2898. activeChar.sendPacket(new SystemMessage(SystemMessageId.CANNOT_EQUIP_ITEM_DUE_TO_BAD_CONDITION));
  2899. return;
  2900. Index: java/config/l2jmods.properties
  2901. ===================================================================
  2902. --- java/config/l2jmods.properties (revision 3844)
  2903. +++ java/config/l2jmods.properties (working copy)
  2904. @@ -212,6 +212,37 @@
  2905. TvTAllowVoicedInfoCommand = false
  2906.  
  2907. # ---------------------------------------------------------------------------
  2908. +# Setting for Capture The Flag
  2909. +# ---------------------------------------------------------------------------
  2910. +# CTFEvenTeams = NO|BALANCE|SHUFFLE
  2911. +# NO means: not even teams.
  2912. +# BALANCE means: Players can only join team with lowest player count.
  2913. +# SHUFFLE means: Players can only participate to the event and not direct to a team. Teams will be shuffled on teams teleport.
  2914. +CTFEvenTeams = SHUFFLE
  2915. +# Allow voiced command on CTF Event?
  2916. +CTFAllowVoiceCommand = False
  2917. +# Players that are not participating in CTF can target ctf participants?
  2918. +CTFAllowInterference = False
  2919. +# CTF participants can use potions?
  2920. +CTFAllowPotions = False
  2921. +# CTF participants can summon by item?
  2922. +CTFAllowSummon = False
  2923. +# Remove all effects of CTF participants on event start?
  2924. +CTFOnStartRemoveAllEffects = True
  2925. +# Unsummon pet of CTF participants on event start?
  2926. +CTFOnStartUnsummonPet = True
  2927. +# On revive participants regain full HP/MP/CP?
  2928. +CTFReviveRecovery = False
  2929. +# Announce all team statistics
  2930. +CTFAnnounceTeamStats = False
  2931. +# Announce reward
  2932. +CTFAnnounceReward = False
  2933. +# Players with cursed weapon are allowed to join?
  2934. +CTFJoinWithCursedWeapon = True
  2935. +# Delay on revive when dead, NOTE: 20000 equals to 20 seconds, minimum 1000 (1 second)
  2936. +CTFReviveDelay = 20000
  2937. +
  2938. +# ---------------------------------------------------------------------------
  2939. # L2J Banking System
  2940. # ---------------------------------------------------------------------------
  2941. # Enable/Disable Banking System
  2942. Index: java/com/l2jserver/gameserver/model/actor/instance/L2VillageMasterInstance.java
  2943. ===================================================================
  2944. --- java/com/l2jserver/gameserver/model/actor/instance/L2VillageMasterInstance.java (revision 3844)
  2945. +++ java/com/l2jserver/gameserver/model/actor/instance/L2VillageMasterInstance.java (working copy)
  2946. @@ -356,6 +356,12 @@
  2947. if (player.getLevel() < 75)
  2948. allowAddition = false;
  2949.  
  2950. + if (player._inEventCTF)
  2951. + {
  2952. + player.sendMessage("You have already been registered in a waiting list of an event.");
  2953. + return;
  2954. + }
  2955. +
  2956. if (allowAddition)
  2957. {
  2958. if (!player.getSubClasses().isEmpty())
  2959. @@ -404,6 +410,12 @@
  2960. * Note: paramOne = classIndex
  2961. */
  2962.  
  2963. + if (player._inEventCTF)
  2964. + {
  2965. + player.sendMessage("You have already been registered in a waiting list of an event.");
  2966. + return;
  2967. + }
  2968. +
  2969. if (!player.getFloodProtectors().getSubclass().tryPerformAction("change class"))
  2970. {
  2971. _log.warning("Player "+player.getName()+" has performed a subclass change too fast");
  2972. Index: java/com/l2jserver/gameserver/model/L2Object.java
  2973. ===================================================================
  2974. --- java/com/l2jserver/gameserver/model/L2Object.java (revision 3844)
  2975. +++ java/com/l2jserver/gameserver/model/L2Object.java (working copy)
  2976. @@ -454,7 +454,14 @@
  2977. {
  2978. return (getClass().getSimpleName() + ":"+getName()+"[" + getObjectId() + "]");
  2979. }
  2980. -
  2981. +
  2982. + // Add by CTF Event
  2983. + public boolean isInFunEvent()
  2984. + {
  2985. + L2PcInstance player = getActingPlayer();
  2986. + return (player == null ? false : player.isInFunEvent());
  2987. + }
  2988. +
  2989. /**
  2990. * Not Implemented.<BR><BR>
  2991. *
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!