API tools faq
paste
Zaun

Kill The Boss Event Interlude aCis

Zaun
Feb 14th, 2021 (edited)
1,678
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 34.34 KB | None | 0 0
raw download clone embed print report
  1. +++ b/config/BossEvent.properties
  2. @@ -0,0 +1,42 @@
  3. +# ================================================
  4. +#       BossEvent   (by Zaun)               #
  5. +# ================================================
  6. +#General
  7. +# Event Hour
  8. +EventTime = 20:55,00:00
  9. +# List of bosses randomly selected
  10. +# e.g 29046;29029
  11. +BossList = 29046
  12. +# Id of registration NPC
  13. +RegisterNpcID = 10003
  14. +# Npc location
  15. +RegisterNpcLocation = 82727,148605,-3471
  16. +# List of locations randomly selected
  17. +# e.g 10468,-24569,-3645;174229,-88032,-5116
  18. +LocationsList = 174229,-88032,-5116
  19. +# Min players to start event
  20. +MinPlayers = 1
  21. +# Min damage to boss to receive rewards
  22. +MinDamage = 2000
  23. +# if true countdown will be shown on screen
  24. +EventTimeOnScreen = True
  25. +
  26. +# Timing
  27. +# reg time in seconds
  28. +RegistrationTime = 30
  29. +# Wait time in seconds
  30. +WaitTime = 15
  31. +# Teleport time in seconds
  32. +TeleportTime = 10
  33. +# time to despawn boss
  34. +TimeToDespawnBoss = 300
  35. +
  36. +# Rewards
  37. +# Rewards for players who hitted min damage on boss
  38. +GeneralRewards = 57,100000;3470,10
  39. +# Reward last hit player
  40. +RewardLastAttacker = True
  41. +LastAttackerRewards = 3470,5;3470,5
  42. +# Reward Player with bigger dmg
  43. +RewardMainDamageDealer = True
  44. +MainDamageDealerRewards = 3470,5;3470,5
  45. \ No newline at end of file
  46. diff --git a/java/dev/bossInstancedEvent/BossEvent.java b/java/dev/bossInstancedEvent/BossEvent.java
  47. new file mode 100644
  48. index 0000000..5f4175a
  49. --- /dev/null
  50. +++ b/java/dev/bossInstancedEvent/BossEvent.java
  51. @@ -0,0 +1,634 @@
  52. +package dev.bossInstancedEvent;
  53. +
  54. +import java.util.ArrayList;
  55. +import java.util.Collection;
  56. +import java.util.HashMap;
  57. +import java.util.List;
  58. +import java.util.Map;
  59. +import java.util.concurrent.ScheduledFuture;
  60. +import java.util.logging.Logger;
  61. +
  62. +import net.sf.l2j.Config;
  63. +import net.sf.l2j.commons.concurrent.ThreadPool;
  64. +import net.sf.l2j.commons.random.Rnd;
  65. +import net.sf.l2j.gameserver.data.NpcTable;
  66. +import net.sf.l2j.gameserver.data.SpawnTable;
  67. +import net.sf.l2j.gameserver.handler.VoicedCommandHandler;
  68. +import net.sf.l2j.gameserver.model.L2Spawn;
  69. +import net.sf.l2j.gameserver.model.World;
  70. +import net.sf.l2j.gameserver.model.actor.instance.Player;
  71. +import net.sf.l2j.gameserver.model.actor.template.NpcTemplate;
  72. +import net.sf.l2j.gameserver.model.location.Location;
  73. +import net.sf.l2j.gameserver.network.clientpackets.Say2;
  74. +import net.sf.l2j.gameserver.network.serverpackets.CreatureSay;
  75. +import net.sf.l2j.gameserver.network.serverpackets.ExShowScreenMessage;
  76. +import net.sf.l2j.gameserver.network.serverpackets.ExShowScreenMessage.SMPOS;
  77. +import net.sf.l2j.gameserver.network.serverpackets.MagicSkillUse;
  78. +
  79. +/**
  80. + * @author Zaun
  81. + */
  82. +public class BossEvent
  83. +{
  84. +   public L2Spawn bossSpawn;
  85. +   public List<Location> locList = new ArrayList<>();
  86. +   public Location loc;
  87. +   public List<Integer> bossList = new ArrayList<>();
  88. +   public int bossId;
  89. +   public int objectId;
  90. +   public List<Player> eventPlayers = new ArrayList<>();
  91. +   protected static final Logger _log = Logger.getLogger(BossEvent.class.getName());
  92. +   private EventState state = EventState.INACTIVE;
  93. +   public boolean started = false;
  94. +   public boolean aborted = false;
  95. +   private Player lastAttacker = null;
  96. +   private Map<Integer, Integer> generalRewards = new HashMap<>();
  97. +   private Map<Integer, Integer> lastAttackerRewards = new HashMap<>();
  98. +   private Map<Integer, Integer> mainDamageDealerRewards = new HashMap<>();
  99. +   public ScheduledFuture<?> despawnBoss = null;
  100. +   public ScheduledFuture<?> countDownTask = null;
  101. +   private String bossName = "";
  102. +   public boolean bossKilled = false;
  103. +   public L2Spawn eventNpc = null;
  104. +   public long startTime;
  105. +
  106. +   public enum EventState
  107. +   {
  108. +       REGISTRATION, TELEPORTING, WAITING, FIGHTING, FINISHING, INACTIVE
  109. +   }
  110. +
  111. +   public BossEvent()
  112. +   {
  113. +       VoicedCommandHandler.getInstance().registerHandler(new BossEventCMD());
  114. +       NextBossEvent.getInstance().startCalculationOfNextEventTime();
  115. +       _log.info("Boss Event loaded.");
  116. +
  117. +   }
  118. +
  119. +   public boolean addPlayer(Player player)
  120. +   {
  121. +       return eventPlayers.add(player);
  122. +   }
  123. +
  124. +   public boolean removePlayer(Player player)
  125. +   {
  126. +       return eventPlayers.remove(player);
  127. +   }
  128. +
  129. +   public boolean isRegistered(Player player)
  130. +   {
  131. +       return eventPlayers.contains(player);
  132. +   }
  133. +
  134. +   class Registration implements Runnable
  135. +   {
  136. +       @Override
  137. +       public void run()
  138. +       {
  139. +           startRegistration();
  140. +
  141. +       }
  142. +
  143. +   }
  144. +
  145. +   public void teleToTown()
  146. +   {
  147. +       for (Player p : eventPlayers)
  148. +       {
  149. +           p.teleToLocation(new Location(83374, 148081, -3407), 300);
  150. +       }
  151. +       setState(EventState.INACTIVE);
  152. +   }
  153. +
  154. +   public void delay(int delay)
  155. +   {
  156. +       try
  157. +       {
  158. +           Thread.sleep(delay);
  159. +       }
  160. +       catch (InterruptedException e)
  161. +       {
  162. +           // TODO Auto-generated catch block
  163. +           e.printStackTrace();
  164. +       }
  165. +   }
  166. +
  167. +   class Teleporting implements Runnable
  168. +   {
  169. +       Location teleTo;
  170. +       List<Player> toTeleport = new ArrayList<>();
  171. +
  172. +       public Teleporting(List<Player> toTeleport, Location teleTo)
  173. +       {
  174. +           this.teleTo = teleTo;
  175. +           this.toTeleport = toTeleport;
  176. +       }
  177. +
  178. +       @Override
  179. +       public void run()
  180. +       {
  181. +           if (eventPlayers.size() >= Config.BOSS_EVENT_MIN_PLAYERS)
  182. +           {
  183. +               despawnNpc(eventNpc);
  184. +               setState(EventState.TELEPORTING);
  185. +               announce("Event Started!", false);
  186. +               startCountDown(Config.BOSS_EVENT_TIME_TO_TELEPORT_PLAYERS, true);
  187. +
  188. +               for (Player p : toTeleport)
  189. +               {
  190. +                   ThreadPool.schedule(new Runnable()
  191. +                   {
  192. +
  193. +                       @Override
  194. +                       public void run()
  195. +                       {
  196. +                           p.teleToLocation(teleTo, 300);
  197. +
  198. +                       }
  199. +                   }, Config.BOSS_EVENT_TIME_TO_TELEPORT_PLAYERS * 1000);
  200. +
  201. +               }
  202. +               delay(Config.BOSS_EVENT_TIME_TO_TELEPORT_PLAYERS * 1000);
  203. +               setState(EventState.WAITING);
  204. +               startCountDown(Config.BOSS_EVENT_TIME_TO_WAIT, true);
  205. +               ThreadPool.schedule(new Fighting(bossId, teleTo), Config.BOSS_EVENT_TIME_TO_WAIT * 1000);
  206. +
  207. +           }
  208. +           else
  209. +           {
  210. +               announce("Event was cancelled due to lack of participation!", false);
  211. +               setState(EventState.INACTIVE);
  212. +               despawnNpc(eventNpc);
  213. +               eventPlayers.clear();
  214. +               objectId = 0;
  215. +
  216. +           }
  217. +
  218. +       }
  219. +
  220. +   }
  221. +
  222. +   public void reward(Player p, Map<Integer, Integer> rewardType)
  223. +   {
  224. +
  225. +       for (Map.Entry<Integer, Integer> entry : rewardType.entrySet())
  226. +       {
  227. +           p.addItem("BossEventReward", entry.getKey(), entry.getValue(), null, true);
  228. +       }
  229. +
  230. +   }
  231. +
  232. +   public void rewardPlayers()
  233. +   {
  234. +       for (Player p : eventPlayers)
  235. +       {
  236. +           if (p.getBossEventDamage() > Config.BOSS_EVENT_MIN_DAMAGE_TO_OBTAIN_REWARD)
  237. +           {
  238. +               reward(p, generalRewards);
  239. +           }
  240. +           else
  241. +           {
  242. +               p.sendPacket(new ExShowScreenMessage("You didn't caused min damage to receive rewards!", 5000));
  243. +               p.sendMessage("You didn't caused min damage to receive rewards! Min. Damage: " + Config.BOSS_EVENT_MIN_DAMAGE_TO_OBTAIN_REWARD + ". Your Damage: " + p.getBossEventDamage());
  244. +           }
  245. +       }
  246. +
  247. +       if (Config.BOSS_EVENT_REWARD_MAIN_DAMAGE_DEALER)
  248. +       {
  249. +           if (getMainDamageDealer() != null)
  250. +           {
  251. +               reward(getMainDamageDealer(), mainDamageDealerRewards);
  252. +               getMainDamageDealer().sendChatMessage(0, Say2.CRITICAL_ANNOUNCE, "[Boss Event]", "Congratulations, you was the damage dealer! So you will receive wonderful rewards.");
  253. +           }
  254. +
  255. +       }
  256. +   }
  257. +
  258. +   public void finishEvent()
  259. +   {
  260. +       started = false;
  261. +       // if (!AdminBossEvent.manual)
  262. +       // {
  263. +       NextBossEvent.getInstance().startCalculationOfNextEventTime();
  264. +       // }
  265. +       // else
  266. +       // {
  267. +       // AdminBossEvent.manual = false;
  268. +       // }
  269. +       rewardPlayers();
  270. +       if (bossKilled) announce(bossName + " has been defeated!", false);
  271. +       if (Config.BOSS_EVENT_REWARD_LAST_ATTACKER)
  272. +       {
  273. +           if (lastAttacker != null)
  274. +           {
  275. +               announce("LastAttacker: " + lastAttacker.getName(), false);
  276. +           }
  277. +       }
  278. +
  279. +       if (Config.BOSS_EVENT_REWARD_MAIN_DAMAGE_DEALER)
  280. +       {
  281. +           if (getMainDamageDealer() != null)
  282. +           {
  283. +               announce("Main Damage Dealer: " + getMainDamageDealer().getName() + ". Total Damage = " + getMainDamageDealer().getBossEventDamage(), false);
  284. +           }
  285. +       }
  286. +       ThreadPool.schedule(new Runnable()
  287. +       {
  288. +
  289. +           @Override
  290. +           public void run()
  291. +           {
  292. +               teleToTown();
  293. +               eventPlayers.clear();
  294. +
  295. +           }
  296. +       }, Config.BOSS_EVENT_TIME_TO_TELEPORT_PLAYERS * 1000);
  297. +
  298. +       setState(EventState.FINISHING);
  299. +       startCountDown(Config.BOSS_EVENT_TIME_TO_TELEPORT_PLAYERS, true);
  300. +       if (despawnBoss != null)
  301. +       {
  302. +           despawnBoss.cancel(true);
  303. +           despawnBoss = null;
  304. +       }
  305. +       objectId = 0;
  306. +
  307. +   }
  308. +
  309. +   class Fighting implements Runnable
  310. +   {
  311. +       int bossId;
  312. +       Location spawnLoc;
  313. +
  314. +       public Fighting(int bossId, Location spawnLoc)
  315. +       {
  316. +           this.bossId = bossId;
  317. +           this.spawnLoc = spawnLoc;
  318. +       }
  319. +
  320. +       @Override
  321. +       public void run()
  322. +       {
  323. +           if (spawnNpc(bossId, loc.getX(), loc.getY(), loc.getZ()))
  324. +           {
  325. +               setState(EventState.FIGHTING);
  326. +               if (Config.BOSS_EVENT_TIME_ON_SCREEN)
  327. +               {
  328. +                   startCountDown(Config.BOSS_EVENT_TIME_TO_DESPAWN_BOSS, true);
  329. +               }
  330. +               despawnBoss = ThreadPool.schedule(new DespawnBossTask(bossSpawn), Config.BOSS_EVENT_TIME_TO_DESPAWN_BOSS * 1000);
  331. +               objectId = bossSpawn.getNpc().getObjectId();
  332. +               for (Player p : eventPlayers)
  333. +               {
  334. +                   p.sendPacket(new ExShowScreenMessage("Boss " + bossSpawn.getNpc().getName() + " has been spawned. Go and Defeat him!", 5000));
  335. +               }
  336. +
  337. +           }
  338. +
  339. +       }
  340. +
  341. +   }
  342. +
  343. +   public void despawnNpc(L2Spawn spawn)
  344. +   {
  345. +       if (spawn != null)
  346. +       {
  347. +           spawn.getNpc().deleteMe();
  348. +           spawn.setRespawnState(false);
  349. +           SpawnTable.getInstance().deleteSpawn(spawn, true);
  350. +       }
  351. +
  352. +   }
  353. +
  354. +   class DespawnBossTask implements Runnable
  355. +   {
  356. +       L2Spawn spawn;
  357. +
  358. +       public DespawnBossTask(L2Spawn spawn)
  359. +       {
  360. +           this.spawn = spawn;
  361. +       }
  362. +
  363. +       @Override
  364. +       public void run()
  365. +       {
  366. +           if (spawn != null)
  367. +           {
  368. +               announceScreen("Your time is over " + spawn.getNpc().getName() + " returned to his home!", true);
  369. +               announce("Your time is over " + spawn.getNpc().getName() + " returned to his home!", true);
  370. +               announce("You will be teleported to town.", true);
  371. +               despawnNpc(spawn);
  372. +               ThreadPool.schedule(new Runnable()
  373. +               {
  374. +
  375. +                   @Override
  376. +                   public void run()
  377. +                   {
  378. +                       teleToTown();
  379. +                       eventPlayers.clear();
  380. +                       setState(EventState.INACTIVE);
  381. +                       objectId = 0;
  382. +
  383. +                   }
  384. +               }, 10000);
  385. +           }
  386. +       }
  387. +
  388. +   }
  389. +
  390. +   public void startRegistration()
  391. +   {
  392. +       try
  393. +       {
  394. +           resetPlayersDamage();
  395. +           bossKilled = false;
  396. +           bossList = Config.BOSS_EVENT_ID;
  397. +           bossId = bossList.get(Rnd.get(bossList.size()));
  398. +           locList = Config.BOSS_EVENT_LOCATION;
  399. +           loc = locList.get(Rnd.get(locList.size()));
  400. +           if (NpcTable.getInstance().getTemplate(bossId) != null)
  401. +           {
  402. +               startTime = System.currentTimeMillis() + Config.BOSS_EVENT_REGISTRATION_TIME * 1000;
  403. +               eventNpc = spawnEventNpc(Config.BOSS_EVENT_NPC_REGISTER_LOC._x, Config.BOSS_EVENT_NPC_REGISTER_LOC._y, Config.BOSS_EVENT_NPC_REGISTER_LOC._z);
  404. +               generalRewards = Config.BOSS_EVENT_GENERAL_REWARDS;
  405. +               lastAttackerRewards = Config.BOSS_EVENT_LAST_ATTACKER_REWARDS;
  406. +               mainDamageDealerRewards = Config.BOSS_EVENT_MAIN_DAMAGE_DEALER_REWARDS;
  407. +               started = true;
  408. +               aborted = false;
  409. +               bossName = NpcTable.getInstance().getTemplate(bossId).getName();
  410. +               setState(EventState.REGISTRATION);
  411. +               announce("Registration started!", false);
  412. +               announce("Joinable in giran or use command \".bossevent\" to register to event", false);
  413. +               startCountDown(Config.BOSS_EVENT_REGISTRATION_TIME, false);
  414. +
  415. +               ThreadPool.schedule(new Teleporting(eventPlayers, loc), Config.BOSS_EVENT_REGISTRATION_TIME * 1000);
  416. +
  417. +           }
  418. +           else
  419. +           {
  420. +               _log.warning(getClass().getName() + ": cannot be started. Invalid BossId: " + bossList);
  421. +               return;
  422. +           }
  423. +       }
  424. +       catch (Exception e)
  425. +       {
  426. +           _log.warning("[Boss Event]: Couldn't be started");
  427. +           e.printStackTrace();
  428. +       }
  429. +
  430. +   }
  431. +
  432. +   public int timeInMillisToStart()
  433. +   {
  434. +       return (int) (startTime - System.currentTimeMillis()) / 1000;
  435. +   }
  436. +
  437. +   public void startCountDownEnterWorld(Player player)
  438. +   {
  439. +       if (getState() == EventState.REGISTRATION)
  440. +       {
  441. +           ThreadPool.schedule(new Countdown(player, timeInMillisToStart(), getState()), 0);
  442. +       }
  443. +   }
  444. +
  445. +   public boolean spawnNpc(int npcId, int x, int y, int z)
  446. +   {
  447. +       NpcTemplate tmpl = NpcTable.getInstance().getTemplate(npcId);
  448. +       try
  449. +       {
  450. +           bossSpawn = new L2Spawn(tmpl);
  451. +
  452. +           bossSpawn.setLoc(x, y, z, Rnd.get(65535));
  453. +           bossSpawn.setRespawnDelay(1);
  454. +
  455. +           SpawnTable.getInstance().addNewSpawn(bossSpawn, false);
  456. +
  457. +           bossSpawn.setRespawnState(false);
  458. +           bossSpawn.doSpawn(false);
  459. +           bossSpawn.getNpc().isAggressive();
  460. +           bossSpawn.getNpc().decayMe();
  461. +           bossSpawn.getNpc().spawnMe(bossSpawn.getNpc().getX(), bossSpawn.getNpc().getY(), bossSpawn.getNpc().getZ());
  462. +           bossSpawn.getNpc().broadcastPacket(new MagicSkillUse(bossSpawn.getNpc(), bossSpawn.getNpc(), 1034, 1, 1, 1));
  463. +           return true;
  464. +       }
  465. +       catch (Exception e)
  466. +       {
  467. +           e.printStackTrace();
  468. +           return false;
  469. +       }
  470. +   }
  471. +
  472. +   public void resetPlayersDamage()
  473. +   {
  474. +       for (Player p : World.getInstance().getPlayers())
  475. +       {
  476. +           p.setBossEventDamage(0);
  477. +       }
  478. +   }
  479. +
  480. +   public L2Spawn spawnEventNpc(int x, int y, int z)
  481. +   {
  482. +       L2Spawn spawn = null;
  483. +       NpcTemplate tmpl = NpcTable.getInstance().getTemplate(Config.BOSS_EVENT_REGISTRATION_NPC_ID);
  484. +       try
  485. +       {
  486. +           spawn = new L2Spawn(tmpl);
  487. +
  488. +           spawn.setLoc(x, y, z, Rnd.get(65535));
  489. +           spawn.setRespawnDelay(1);
  490. +
  491. +           SpawnTable.getInstance().addNewSpawn(spawn, false);
  492. +
  493. +           spawn.setRespawnState(false);
  494. +           spawn.doSpawn(false);
  495. +           spawn.getNpc().isAggressive();
  496. +           spawn.getNpc().decayMe();
  497. +           spawn.getNpc().spawnMe(spawn.getNpc().getX(), spawn.getNpc().getY(), spawn.getNpc().getZ());
  498. +           spawn.getNpc().broadcastPacket(new MagicSkillUse(spawn.getNpc(), spawn.getNpc(), 1034, 1, 1, 1));
  499. +           return spawn;
  500. +       }
  501. +       catch (Exception e)
  502. +       {
  503. +           e.printStackTrace();
  504. +           return spawn;
  505. +       }
  506. +   }
  507. +
  508. +   public final Player getMainDamageDealer()
  509. +   {
  510. +       int dmg = 0;
  511. +       Player mainDamageDealer = null;
  512. +       for (Player p : eventPlayers)
  513. +       {
  514. +           if (p.getBossEventDamage() > dmg)
  515. +           {
  516. +               dmg = p.getBossEventDamage();
  517. +               mainDamageDealer = p;
  518. +           }
  519. +       }
  520. +       return mainDamageDealer;
  521. +   }
  522. +
  523. +   public static BossEvent getInstance()
  524. +   {
  525. +       return SingleTonHolder._instance;
  526. +   }
  527. +
  528. +   private static class SingleTonHolder
  529. +   {
  530. +       protected static final BossEvent _instance = new BossEvent();
  531. +   }
  532. +
  533. +   public void startCountDown(int time, boolean eventOnly)
  534. +   {
  535. +       Collection<Player> players = new ArrayList<>();
  536. +       players = eventOnly ? eventPlayers : World.getInstance().getPlayers();
  537. +       for (Player player : players)
  538. +       {
  539. +           ThreadPool.schedule(new Countdown(player, time, getState()), 0L);
  540. +       }
  541. +
  542. +   }
  543. +
  544. +   public void announce(String text, boolean eventOnly)
  545. +   {
  546. +       Collection<Player> players = new ArrayList<>();
  547. +       players = eventOnly ? eventPlayers : World.getInstance().getPlayers();
  548. +       for (Player player : players)
  549. +       {
  550. +           player.sendPacket(new CreatureSay(0, Say2.CRITICAL_ANNOUNCE, "[Boss Event]", text));
  551. +       }
  552. +   }
  553. +
  554. +   public void announceScreen(String text, boolean eventOnly)
  555. +   {
  556. +       Collection<Player> players = new ArrayList<>();
  557. +       players = eventOnly ? eventPlayers : World.getInstance().getPlayers();
  558. +       for (Player player : players)
  559. +       {
  560. +           player.sendPacket(new ExShowScreenMessage(text, 4000));
  561. +       }
  562. +   }
  563. +
  564. +   /**
  565. +    * @return the state
  566. +    */
  567. +   public EventState getState()
  568. +   {
  569. +       return state;
  570. +   }
  571. +
  572. +   /**
  573. +    * @param state the state to set
  574. +    */
  575. +   public void setState(EventState state)
  576. +   {
  577. +       this.state = state;
  578. +   }
  579. +
  580. +   /**
  581. +    * @return the lastAttacker
  582. +    */
  583. +   public Player getLastAttacker()
  584. +   {
  585. +       return lastAttacker;
  586. +   }
  587. +
  588. +   /**
  589. +    * @param lastAttacker the lastAttacker to set
  590. +    */
  591. +   public void setLastAttacker(Player lastAttacker)
  592. +   {
  593. +       this.lastAttacker = lastAttacker;
  594. +   }
  595. +
  596. +   protected class Countdown implements Runnable
  597. +   {
  598. +       private final Player _player;
  599. +       private final int _time;
  600. +       private String text = "";
  601. +       EventState evtState;
  602. +
  603. +       public Countdown(Player player, int time, EventState evtState)
  604. +       {
  605. +           _time = time;
  606. +           _player = player;
  607. +           switch (evtState)
  608. +           {
  609. +           case REGISTRATION:
  610. +               text = "Boss Event registration ends in: ";
  611. +               break;
  612. +           case TELEPORTING:
  613. +               text = "You will be teleported to Boss Event in: ";
  614. +               break;
  615. +           case WAITING:
  616. +               text = "Boss will spawn in: ";
  617. +               break;
  618. +           case FINISHING:
  619. +               text = "You will be teleported to City in: ";
  620. +               break;
  621. +           }
  622. +           this.evtState = evtState;
  623. +       }
  624. +
  625. +       @Override
  626. +       public void run()
  627. +       {
  628. +           if (getState() == EventState.INACTIVE)
  629. +           {
  630. +               return;
  631. +           }
  632. +           if (_player.isOnline())
  633. +           {
  634. +               switch (evtState)
  635. +               {
  636. +               case REGISTRATION:
  637. +               case TELEPORTING:
  638. +               case WAITING:
  639. +               case FINISHING:
  640. +                   switch (_time)
  641. +                   {
  642. +
  643. +                   case 60:
  644. +                   case 120:
  645. +                   case 180:
  646. +                   case 240:
  647. +                   case 300:
  648. +                       _player.sendPacket(new CreatureSay(0, Say2.CRITICAL_ANNOUNCE, "[Boss Event]", text + _time / 60 + " minute(s)"));
  649. +                       break;
  650. +                   case 45:
  651. +                   case 30:
  652. +                   case 15:
  653. +                   case 10:
  654. +                   case 5:
  655. +                   case 4:
  656. +                   case 3:
  657. +                   case 2:
  658. +                   case 1:
  659. +                       _player.sendPacket(new CreatureSay(0, Say2.CRITICAL_ANNOUNCE, "[Boss Event]", text + _time + " second(s)"));
  660. +                       break;
  661. +
  662. +                   }
  663. +                   if (_time > 1)
  664. +                   {
  665. +                       ThreadPool.schedule(new Countdown(_player, _time - 1, evtState), 1000L);
  666. +                   }
  667. +                   break;
  668. +               case FIGHTING:
  669. +                   int minutes = _time / 60;
  670. +                   int second = _time % 60;
  671. +                   String timing = ((minutes < 10) ? ("0" + minutes) : minutes) + ":" + ((second < 10) ? ("0" + second) : second);
  672. +
  673. +                   _player.sendPacket(new ExShowScreenMessage("Time Left: " + timing, 1100, SMPOS.BOTTOM_RIGHT, true));
  674. +                   if (_time > 1)
  675. +                   {
  676. +                       ThreadPool.schedule(new Countdown(_player, _time - 1, evtState), 1000L);
  677. +                   }
  678. +                   break;
  679. +               }
  680. +
  681. +           }
  682. +       }
  683. +   }
  684. +
  685. +}
  686. diff --git a/java/dev/bossInstancedEvent/BossEventCMD.java b/java/dev/bossInstancedEvent/BossEventCMD.java
  687. new file mode 100644
  688. index 0000000..284d342
  689. --- /dev/null
  690. +++ b/java/dev/bossInstancedEvent/BossEventCMD.java
  691. @@ -0,0 +1,55 @@
  692. +package dev.bossInstancedEvent;
  693. +
  694. +
  695. +
  696. +import net.sf.l2j.gameserver.handler.IVoicedCommandHandler;
  697. +import net.sf.l2j.gameserver.model.actor.instance.Player;
  698. +
  699. +import dev.bossInstancedEvent.BossEvent.EventState;
  700. +
  701. +/**
  702. + * @author Zaun
  703. + */
  704. +public class BossEventCMD implements IVoicedCommandHandler
  705. +{
  706. +  
  707. +   @Override
  708. +   public boolean useVoicedCommand(String command, Player activeChar, String params)
  709. +   {
  710. +       if (command.startsWith("bossevent"))
  711. +       {
  712. +           if (BossEvent.getInstance().getState() != EventState.REGISTRATION)
  713. +           {
  714. +               activeChar.sendMessage("Boss Event is not running!");
  715. +               return false;
  716. +           }
  717. +           if (!BossEvent.getInstance().isRegistered(activeChar))
  718. +           {
  719. +               if (BossEvent.getInstance().addPlayer(activeChar))
  720. +               {
  721. +                   activeChar.sendMessage("You have been successfully registered in Boss Event!");
  722. +               }
  723. +              
  724. +           }
  725. +           else
  726. +           {
  727. +               if (BossEvent.getInstance().removePlayer(activeChar))
  728. +               {
  729. +                   activeChar.sendMessage("You have been successfully removed of Boss Event!");
  730. +               }
  731. +           }
  732. +       }
  733. +       return false;
  734. +   }
  735. +  
  736. +   @Override
  737. +   public String[] getVoicedCommandList()
  738. +   {
  739. +      
  740. +       return new String[]
  741. +       {
  742. +           "bossevent"
  743. +       };
  744. +   }
  745. +  
  746. +}
  747. diff --git a/java/dev/bossInstancedEvent/NextBossEvent.java b/java/dev/bossInstancedEvent/NextBossEvent.java
  748. new file mode 100644
  749. index 0000000..fa9186f
  750. --- /dev/null
  751. +++ b/java/dev/bossInstancedEvent/NextBossEvent.java
  752. @@ -0,0 +1,98 @@
  753. +package dev.bossInstancedEvent;
  754. +
  755. +
  756. +
  757. +import java.text.SimpleDateFormat;
  758. +import java.util.Calendar;
  759. +import java.util.concurrent.ScheduledFuture;
  760. +import java.util.logging.Logger;
  761. +
  762. +import net.sf.l2j.commons.concurrent.ThreadPool;
  763. +
  764. +import net.sf.l2j.Config;
  765. +
  766. +public class NextBossEvent
  767. +{
  768. +   private static NextBossEvent _instance = null;
  769. +   protected static final Logger _log = Logger.getLogger(NextBossEvent.class.getName());
  770. +   private Calendar nextEvent;
  771. +   private final SimpleDateFormat format = new SimpleDateFormat("HH:mm");
  772. +   public ScheduledFuture<?> task = null;
  773. +  
  774. +   public static NextBossEvent getInstance()
  775. +   {
  776. +       if (_instance == null)
  777. +       {
  778. +           _instance = new NextBossEvent();
  779. +       }
  780. +       return _instance;
  781. +   }
  782. +  
  783. +   public String getNextTime()
  784. +   {
  785. +       if (nextEvent.getTime() != null)
  786. +       {
  787. +           return format.format(nextEvent.getTime());
  788. +       }
  789. +       return "Erro";
  790. +   }
  791. +  
  792. +   public void startCalculationOfNextEventTime()
  793. +   {
  794. +       try
  795. +       {
  796. +           Calendar currentTime = Calendar.getInstance();
  797. +           Calendar testStartTime = null;
  798. +           long flush2 = 0L;
  799. +           long timeL = 0L;
  800. +           int count = 0;
  801. +           for (String timeOfDay : Config.BOSS_EVENT_BY_TIME_OF_DAY)
  802. +           {
  803. +               testStartTime = Calendar.getInstance();
  804. +               testStartTime.setLenient(true);
  805. +               String[] splitTimeOfDay = timeOfDay.split(":");
  806. +               testStartTime.set(11, Integer.parseInt(splitTimeOfDay[0]));
  807. +               testStartTime.set(12, Integer.parseInt(splitTimeOfDay[1]));
  808. +               testStartTime.set(13, 0);
  809. +               if (testStartTime.getTimeInMillis() < currentTime.getTimeInMillis())
  810. +               {
  811. +                   testStartTime.add(5, 1);
  812. +               }
  813. +               timeL = testStartTime.getTimeInMillis() - currentTime.getTimeInMillis();
  814. +               if (count == 0)
  815. +               {
  816. +                   flush2 = timeL;
  817. +                   nextEvent = testStartTime;
  818. +               }
  819. +               if (timeL < flush2)
  820. +               {
  821. +                   flush2 = timeL;
  822. +                   nextEvent = testStartTime;
  823. +               }
  824. +               count++;
  825. +           }
  826. +           _log.info("[Boss Event]: Next Event Time -> " + nextEvent.getTime().toString());
  827. +           ThreadPool.schedule(new StartEventTask(), flush2);
  828. +       }
  829. +       catch (Exception e)
  830. +       {
  831. +           System.out.println("[Boss Event]: " + e);
  832. +       }
  833. +   }
  834. +  
  835. +   class StartEventTask implements Runnable
  836. +   {
  837. +       StartEventTask()
  838. +       {
  839. +       }
  840. +      
  841. +       @Override
  842. +       public void run()
  843. +       {
  844. +           NextBossEvent._log.info("----------------------------------------------------------------------------");
  845. +           NextBossEvent._log.info("[Boss Event]: Event Started.");
  846. +           NextBossEvent._log.info("----------------------------------------------------------------------------");
  847. +           BossEvent.getInstance().startRegistration();
  848. +       }
  849. +   }
  850. +}
  851. diff --git a/java/net/sf/l2j/Config.java b/java/net/sf/l2j/Config.java
  852. index 23c317c..2e25061 100644
  853. --- a/java/net/sf/l2j/Config.java
  854. +++ b/java/net/sf/l2j/Config.java
  855. @@ -70,6 +70,28 @@
  856.    
  857. +   public static final String BOSS_EVENT_INSTANCED = "./config/BossEvent.properties";
  858. +
  859. +   /** Boss Event */
  860. +   public static boolean BOSS_EVENT_TIME_ON_SCREEN;
  861. +   public static int BOSS_EVENT_TIME_TO_DESPAWN_BOSS;
  862. +   public static int BOSS_EVENT_REGISTRATION_NPC_ID;
  863. +   public static Map<Integer, Integer> BOSS_EVENT_GENERAL_REWARDS = new HashMap<>();
  864. +   public static Map<Integer, Integer> BOSS_EVENT_LAST_ATTACKER_REWARDS = new HashMap<>();
  865. +   public static Map<Integer, Integer> BOSS_EVENT_MAIN_DAMAGE_DEALER_REWARDS = new HashMap<>();
  866. +   public static boolean BOSS_EVENT_REWARD_MAIN_DAMAGE_DEALER;
  867. +   public static boolean BOSS_EVENT_REWARD_LAST_ATTACKER;
  868. +   public static List<Location> BOSS_EVENT_LOCATION = new ArrayList<>();
  869. +   public static int BOSS_EVENT_REWARD_ID;
  870. +   public static int BOSS_EVENT_REWARD_COUNT;
  871. +   public static int BOSS_EVENT_MIN_DAMAGE_TO_OBTAIN_REWARD;
  872. +   public static List<Integer> BOSS_EVENT_ID = new ArrayList<>();
  873. +   public static Location BOSS_EVENT_NPC_REGISTER_LOC;
  874. +   public static int BOSS_EVENT_TIME_TO_WAIT;
  875. +   public static int BOSS_EVENT_TIME_TO_TELEPORT_PLAYERS;
  876. +   public static int BOSS_EVENT_MIN_PLAYERS;
  877. +   public static int BOSS_EVENT_REGISTRATION_TIME;
  878. +   public static String[] BOSS_EVENT_BY_TIME_OF_DAY;
  879.  
  880.     public static Map<String, String> NPC_STRING_REPLACES;
  881.  
  882. @@ -1592,6 +1614,55 @@
  883.         return result;
  884.     }
  885.  
  886. +   private static final void loadBossEvent()
  887. +   {
  888. +       final ExProperties bossEvent = initProperties(BOSS_EVENT_INSTANCED);
  889. +       BOSS_EVENT_BY_TIME_OF_DAY = bossEvent.getProperty("EventTime", "20:00").split(",");
  890. +       for (String bossList : bossEvent.getProperty("BossList", "29046;29029").split(";"))
  891. +       {
  892. +           BOSS_EVENT_ID.add(Integer.parseInt(bossList));
  893. +       }
  894. +       String[] loc = bossEvent.getProperty("EventLocation", "174229,-88032,-5116").split(",");
  895. +       for (String locationsList : bossEvent.getProperty("LocationsList", "10468,-24569,-3645;174229,-88032,-5116").split(";"))
  896. +       {
  897. +           String[] coords = locationsList.split(",");
  898. +           int x = Integer.parseInt(coords[0]);
  899. +           int y = Integer.parseInt(coords[1]);
  900. +           int z = Integer.parseInt(coords[2]);
  901. +           BOSS_EVENT_LOCATION.add(new Location(x, y, z));
  902. +       }
  903. +
  904. +       BOSS_EVENT_MIN_PLAYERS = bossEvent.getProperty("MinPlayers", 1);
  905. +       BOSS_EVENT_MIN_DAMAGE_TO_OBTAIN_REWARD = bossEvent.getProperty("MinDamage", 2000);
  906. +       BOSS_EVENT_REGISTRATION_TIME = bossEvent.getProperty("RegistrationTime", 120);
  907. +       BOSS_EVENT_REWARD_ID = bossEvent.getProperty("RewardId", 3470);
  908. +       BOSS_EVENT_REWARD_COUNT = bossEvent.getProperty("RewardCount", 10);
  909. +       BOSS_EVENT_TIME_TO_WAIT = bossEvent.getProperty("WaitTime", 30);
  910. +       BOSS_EVENT_TIME_TO_TELEPORT_PLAYERS = bossEvent.getProperty("TeleportTime", 15);
  911. +       BOSS_EVENT_REWARD_LAST_ATTACKER = bossEvent.getProperty("RewardLastAttacker", true);
  912. +       BOSS_EVENT_REWARD_MAIN_DAMAGE_DEALER = bossEvent.getProperty("RewardMainDamageDealer", true);
  913. +       for (String rewards : bossEvent.getProperty("GeneralRewards", "57,100000;3470,10").split(";"))
  914. +       {
  915. +           String[] reward = rewards.split(",");
  916. +           BOSS_EVENT_GENERAL_REWARDS.put(Integer.parseInt(reward[0]), Integer.parseInt(reward[1]));
  917. +       }
  918. +       for (String rewards : bossEvent.getProperty("MainDamageDealerRewards", "57,100000;3470,10").split(";"))
  919. +       {
  920. +           String[] reward = rewards.split(",");
  921. +           BOSS_EVENT_MAIN_DAMAGE_DEALER_REWARDS.put(Integer.parseInt(reward[0]), Integer.parseInt(reward[1]));
  922. +       }
  923. +       for (String rewards : bossEvent.getProperty("LastAttackerRewards", "57,100000;3470,10").split(";"))
  924. +       {
  925. +           String[] reward = rewards.split(",");
  926. +           BOSS_EVENT_LAST_ATTACKER_REWARDS.put(Integer.parseInt(reward[0]), Integer.parseInt(reward[1]));
  927. +       }
  928. +       BOSS_EVENT_REGISTRATION_NPC_ID = bossEvent.getProperty("RegisterNpcID", 10003);
  929. +       BOSS_EVENT_TIME_TO_DESPAWN_BOSS = bossEvent.getProperty("TimeToDespawnBoss", 300);
  930. +       String[] regLoc = bossEvent.getProperty("RegisterNpcLocation", "82727,148605,-3471").split(",");
  931. +       BOSS_EVENT_NPC_REGISTER_LOC = new Location(Integer.parseInt(regLoc[0]), Integer.parseInt(regLoc[1]), Integer.parseInt(regLoc[2]));
  932. +       BOSS_EVENT_TIME_ON_SCREEN = bossEvent.getProperty("EventTimeOnScreen", true);
  933. +   }
  934. +
  935.     private static final void loadServerMods()
  936.     {
  937.         final ExProperties mods = initProperties(SERVER_MODS);
  938. @@ -4111,7 +4182,7 @@
  939.     public static final void loadGameServer()
  940.     {
  941.        
  942. -
  943. +       loadBossEvent();
  944.         loadServerMods();
  945.         loadPremium();
  946.         initGS();
  947. diff --git a/java/net/sf/l2j/gameserver/GameServer.java b/java/net/sf/l2j/gameserver/GameServer.java
  948. index 2e8021b..4565359 100644
  949. --- a/java/net/sf/l2j/gameserver/GameServer.java
  950. +++ b/java/net/sf/l2j/gameserver/GameServer.java
  951. @@ -18,6 +18,7 @@
  952.  import dev.SuperLeague.SuperLeagueManager;
  953.  import dev.SuperLeague.elo.EloData;
  954.  import dev.VoteSystem.VoteSystemGenerator;
  955. +import dev.bossInstancedEvent.BossEvent;
  956.  import dev.comboBox.data.xml.ComboBoxData;
  957.  import dev.dungeon.DungeonManager;
  958.  import dev.instance.InstanceManager;
  959. @@ -436,7 +437,7 @@
  960.              * SuperLeague
  961.              * ------------------------------------------------------------------
  962.              */
  963. -
  964. +           BossEvent.getInstance();
  965.             ClanRankingManager.getInstance();
  966.             VoteSystemGenerator.getInstance().deleteExpiredVars();
  967.             if (Config.CKM_ENABLED) CharacterKillingManager.getInstance().init();
  968. diff --git a/java/net/sf/l2j/gameserver/model/actor/Creature.java b/java/net/sf/l2j/gameserver/model/actor/Creature.java
  969. index 88217ab..976ff20 100644
  970. --- a/java/net/sf/l2j/gameserver/model/actor/Creature.java
  971. +++ b/java/net/sf/l2j/gameserver/model/actor/Creature.java
  972. @@ -9,6 +9,8 @@
  973.  import java.util.concurrent.Future;
  974.  import java.util.logging.Level;
  975.  
  976. +import dev.bossInstancedEvent.BossEvent;
  977. +import dev.bossInstancedEvent.BossEvent.EventState;
  978.  import net.sf.l2j.Config;
  979.  import net.sf.l2j.commons.concurrent.ThreadPool;
  980.  import net.sf.l2j.commons.math.MathUtil;
  981. @@ -56,6 +58,7 @@
  982.  import net.sf.l2j.gameserver.model.location.SpawnLocation;
  983.  import net.sf.l2j.gameserver.model.zone.ZoneId;
  984.  import net.sf.l2j.gameserver.network.SystemMessageId;
  985. +import net.sf.l2j.gameserver.network.clientpackets.Say2;
  986.  import net.sf.l2j.gameserver.network.serverpackets.AbstractNpcInfo;
  987.  import net.sf.l2j.gameserver.network.serverpackets.ActionFailed;
  988.  import net.sf.l2j.gameserver.network.serverpackets.Attack;
  989. @@ -1655,6 +1658,33 @@
  990.         // }
  991.         //
  992.  
  993. +       if (BossEvent.getInstance().getState() == EventState.FIGHTING)
  994. +       {
  995. +           if (BossEvent.getInstance().bossSpawn.getNpc() == this)
  996. +           {
  997. +               BossEvent.getInstance().finishEvent();
  998. +               BossEvent.getInstance().bossKilled = true;
  999. +               if (killer instanceof Player)
  1000. +               {
  1001. +                   Player lastAttacker = killer.getActingPlayer();
  1002. +                   BossEvent.getInstance().setLastAttacker(lastAttacker);
  1003. +                   _log.info("Boss Event Finished. Last Attacker : " + lastAttacker.getName());
  1004. +                   _log.info("Players rewarded: " + BossEvent.getInstance().eventPlayers.size());
  1005. +                   if (Config.BOSS_EVENT_REWARD_LAST_ATTACKER)
  1006. +                   {
  1007. +
  1008. +                       if (lastAttacker.getBossEventDamage() > Config.BOSS_EVENT_MIN_DAMAGE_TO_OBTAIN_REWARD)
  1009. +                       {
  1010. +                           BossEvent.getInstance().reward(lastAttacker, Config.BOSS_EVENT_LAST_ATTACKER_REWARDS);
  1011. +                           lastAttacker.sendChatMessage(0, Say2.CRITICAL_ANNOUNCE, "[Boss Event]", "Congratulations, you was the last attacker! So you will receive wonderful rewards.");
  1012. +
  1013. +                       }
  1014. +
  1015. +                   }
  1016. +               }
  1017. +
  1018. +           }
  1019. +       }
  1020.         if (Config.BOTS_PREVENTION) BotsPreventionManager.getInstance().updatecounter(killer, this);
  1021.  
  1022.         // Send the Server->Client packet StatusUpdate with current HP and MP to all
  1023. diff --git a/java/net/sf/l2j/gameserver/model/actor/instance/BossEventNpc.java b/java/net/sf/l2j/gameserver/model/actor/instance/BossEventNpc.java
  1024. new file mode 100644
  1025. index 0000000..6f6d7d5
  1026. --- /dev/null
  1027. +++ b/java/net/sf/l2j/gameserver/model/actor/instance/BossEventNpc.java
  1028. @@ -0,0 +1,103 @@
  1029. +package net.sf.l2j.gameserver.model.actor.instance;
  1030. +
  1031. +
  1032. +import net.sf.l2j.commons.random.Rnd;
  1033. +
  1034. +import net.sf.l2j.gameserver.model.actor.Npc;
  1035. +import net.sf.l2j.gameserver.model.actor.ai.CtrlIntention;
  1036. +import net.sf.l2j.gameserver.model.actor.template.NpcTemplate;
  1037. +import net.sf.l2j.gameserver.network.serverpackets.ActionFailed;
  1038. +import net.sf.l2j.gameserver.network.serverpackets.MoveToPawn;
  1039. +import net.sf.l2j.gameserver.network.serverpackets.MyTargetSelected;
  1040. +import net.sf.l2j.gameserver.network.serverpackets.NpcHtmlMessage;
  1041. +import net.sf.l2j.gameserver.network.serverpackets.ValidateLocation;
  1042. +
  1043. +import dev.bossInstancedEvent.BossEvent;
  1044. +import dev.bossInstancedEvent.BossEvent.EventState;
  1045. +
  1046. +/**
  1047. + * @author Zaun
  1048. + */
  1049. +public class BossEventNpc extends Folk
  1050. +{
  1051. +   /**
  1052. +    * @param objectId
  1053. +    * @param template
  1054. +    */
  1055. +   public BossEventNpc(int objectId, NpcTemplate template)
  1056. +   {
  1057. +       super(objectId, template);
  1058. +       // TODO Auto-generated constructor stub
  1059. +   }
  1060. +  
  1061. +   @Override
  1062. +   public void onAction(Player player)
  1063. +   {
  1064. +       if (this != player.getTarget())
  1065. +       {
  1066. +           player.setTarget(this);
  1067. +           player.sendPacket(new MyTargetSelected(getObjectId(), 0));
  1068. +           player.sendPacket(new ValidateLocation(this));
  1069. +       }
  1070. +       else
  1071. +       {
  1072. +           if (!canInteract(player))
  1073. +               player.getAI().setIntention(CtrlIntention.INTERACT, this);
  1074. +           else
  1075. +           {
  1076. +               // Rotate the player to face the instance
  1077. +               player.sendPacket(new MoveToPawn(player, this, Npc.INTERACTION_DISTANCE));
  1078. +              
  1079. +               if (hasRandomAnimation())
  1080. +                   onRandomAnimation(Rnd.get(8));
  1081. +              
  1082. +               showMainWindow(player);
  1083. +              
  1084. +               // Send ActionFailed to the player in order to avoid he stucks
  1085. +               player.sendPacket(ActionFailed.STATIC_PACKET);
  1086. +           }
  1087. +       }
  1088. +   }
  1089. +  
  1090. +   private void showMainWindow(Player player)
  1091. +   {
  1092. +      
  1093. +       NpcHtmlMessage html = new NpcHtmlMessage(getObjectId());
  1094. +       html.setFile("data/html/mods/BossEvent.htm");
  1095. +       html.replace("%objectId%", String.valueOf(getObjectId()));
  1096. +       html.replace("%npcname%", getName());
  1097. +       html.replace("%regCount%", String.valueOf(BossEvent.getInstance().eventPlayers.size()));
  1098. +       player.sendPacket(html);
  1099. +   }
  1100. +  
  1101. +   @Override
  1102. +   public void onBypassFeedback(Player activeChar, String command)
  1103. +   {
  1104. +      
  1105. +       super.onBypassFeedback(activeChar, command);
  1106. +       if (command.startsWith("register"))
  1107. +       {
  1108. +           if (BossEvent.getInstance().getState() != EventState.REGISTRATION)
  1109. +           {
  1110. +               activeChar.sendMessage("Boss Event is not running!");
  1111. +               return;
  1112. +           }
  1113. +           if (!BossEvent.getInstance().isRegistered(activeChar))
  1114. +           {
  1115. +               if (BossEvent.getInstance().addPlayer(activeChar))
  1116. +               {
  1117. +                   activeChar.sendMessage("You have been successfully registered in Boss Event!");
  1118. +               }
  1119. +              
  1120. +           }
  1121. +           else
  1122. +           {
  1123. +               if (BossEvent.getInstance().removePlayer(activeChar))
  1124. +               {
  1125. +                   activeChar.sendMessage("You have been successfully removed of Boss Event!");
  1126. +               }
  1127. +           }
  1128. +       }
  1129. +   }
  1130. +  
  1131. +}
  1132. diff --git a/java/net/sf/l2j/gameserver/model/actor/instance/Player.java b/java/net/sf/l2j/gameserver/model/actor/instance/Player.java
  1133. index bc0c0d5..8ff7dc8 100644
  1134. --- a/java/net/sf/l2j/gameserver/model/actor/instance/Player.java
  1135. +++ b/java/net/sf/l2j/gameserver/model/actor/instance/Player.java
  1136. @@ -33,6 +33,8 @@
  1137.  import dev.VoteSystem.VoteSystemGenerator;
  1138.  import dev.auction.pvpCycleRanking.PvPCycleRankingManager;
  1139.  import dev.autofarm.AutofarmManager;
  1140. +import dev.bossInstancedEvent.BossEvent;
  1141. +import dev.bossInstancedEvent.BossEvent.EventState;
  1142.  import dev.dungeon.Dungeon;
  1143.  import dev.instance.Instance;
  1144.  import dev.instance.InstanceManager;
  1145. @@ -10694,6 +10696,13 @@
  1146.             addSuperLeagueFightDamage(damage);
  1147.  
  1148.         }
  1149. +       if (BossEvent.getInstance().getState() == EventState.FIGHTING && BossEvent.getInstance().eventPlayers.contains(this))
  1150. +       {
  1151. +           if (target.getObjectId() == BossEvent.getInstance().objectId)
  1152. +           {
  1153. +               bossEventDamage += damage;
  1154. +           }
  1155. +       }
  1156.  
  1157.     }
  1158.  
  1159. @@ -13281,8 +13290,26 @@
  1160.         this.playerPvps = playerPvps;
  1161.     }
  1162.  
  1163. +   /**
  1164. +    * @return the bossEventDamage
  1165. +    */
  1166. +   public int getBossEventDamage()
  1167. +   {
  1168. +       return bossEventDamage;
  1169. +   }
  1170. +
  1171. +   /**
  1172. +    * @param bossEventDamage the bossEventDamage to set
  1173. +    */
  1174. +   public void setBossEventDamage(int bossEventDamage)
  1175. +   {
  1176. +       this.bossEventDamage = bossEventDamage;
  1177. +   }
  1178. +
  1179.     private int playerPvps;
  1180.  
  1181. +   private int bossEventDamage = 0;
  1182. +
  1183.     private Location _enterWorldLocation;
  1184.  
  1185.     public Location getEnterWorldLocation()
  1186.  
Add Comment
Please, Sign In to add comment
Public Pastes
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!