API tools faq
paste
Giardev

AntiZerg L2BossZone.java L2jorion

Giardev
May 24th, 2022 (edited)
111
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
JavaScript 14.86 KB
Copied copy raw download clone embed print report
  1. /*
  2.  * This program is free software: you can redistribute it and/or modify it under
  3.  * the terms of the GNU General Public License as published by the Free Software
  4.  * Foundation, either version 3 of the License, or (at your option) any later
  5.  * version.
  6.  *
  7.  * This program is distributed in the hope that it will be useful, but WITHOUT
  8.  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  9.  * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
  10.  * details.
  11.  *
  12.  * You should have received a copy of the GNU General Public License along with
  13.  * this program. If not, see <http://www.gnu.org/licenses/>.
  14.  */
  15. package l2jorion.game.model.zone.type;
  16.  
  17. import java.util.ArrayList;
  18. import java.util.HashMap;
  19. import java.util.List;
  20. import java.util.Map;
  21. import java.util.concurrent.ConcurrentHashMap;
  22. import java.util.concurrent.CopyOnWriteArrayList;
  23.  
  24. import l2jorion.Config;
  25. import l2jorion.game.GameServer;
  26. import l2jorion.game.datatables.csv.MapRegionTable;
  27. import l2jorion.game.datatables.csv.MapRegionTable.TeleportWhereType;
  28. import l2jorion.game.managers.GrandBossManager;
  29. import l2jorion.game.model.L2Character;
  30. import l2jorion.game.model.L2Clan;
  31. import l2jorion.game.model.L2ClanMember;
  32. import l2jorion.game.model.L2Summon;
  33. import l2jorion.game.model.L2World;
  34. import l2jorion.game.model.actor.instance.L2ItemInstance;
  35. import l2jorion.game.model.actor.instance.L2NpcInstance;
  36. import l2jorion.game.model.actor.instance.L2PcInstance;
  37. import l2jorion.game.model.zone.L2ZoneType;
  38. import l2jorion.game.model.zone.ZoneId;
  39. import l2jorion.game.network.serverpackets.ExShowScreenMessage;
  40. import l2jorion.util.StringUtil;
  41.  
  42. public class L2BossZone extends L2ZoneType
  43. {
  44.     private int _timeInvade;
  45.     private int _maxLevel = 0;
  46.     private boolean _enabled = true;
  47.     private boolean _IsFlyingEnable = true;
  48.     private boolean _pvp = false;
  49.     private boolean _AllowCursedWeapons = true;
  50.     private boolean _access = false;
  51.     private boolean _teleportOut = true;
  52.     private final Map<String, List<L2PcInstance>> _zergMap = new HashMap<>();
  53. +   private int _maxClanMembers;
  54. +   private int _maxAllyMembers;
  55.    
  56.     private boolean _NoSummonZone = true;
  57.    
  58.     private final Map<Integer, Long> _playerAllowedReEntryTimes;
  59.     private List<Integer> _playersAllowed;
  60.    
  61.     private int _bossId;
  62.    
  63.     protected volatile List<Integer> _skills = new ArrayList<>();
  64.    
  65.     public L2BossZone(int id)
  66.     {
  67.         super(id);
  68.        
  69.         _playerAllowedReEntryTimes = new ConcurrentHashMap<>();
  70.         _playersAllowed = new CopyOnWriteArrayList<>();
  71.        
  72.         GrandBossManager.getInstance().addZone(this);
  73.     }
  74.    
  75.     @Override
  76.     public void setParameter(String name, String value)
  77.     {
  78.         switch (name)
  79.         {
  80.             case "bossId":
  81.                 _bossId = Integer.parseInt(value);
  82.                 break;
  83.             case "InvadeTime":
  84.                 _timeInvade = Integer.parseInt(value);
  85.                 break;
  86.             case "maxLevel":
  87.                 _maxLevel = Integer.parseInt(value);
  88.                 break;
  89.             case "EnabledByDefault":
  90.                 _enabled = Boolean.parseBoolean(value);
  91.                 break;
  92.             case "flying":
  93.                 _IsFlyingEnable = Boolean.parseBoolean(value);
  94.                 break;
  95.             case "pvp":
  96.                 _pvp = Boolean.parseBoolean(value);
  97.                 break;
  98.             case "AllowCursedWeapons":
  99.                 _AllowCursedWeapons = Boolean.parseBoolean(value);
  100.                 break;
  101.             case "access":
  102.                 _access = Boolean.parseBoolean(value);
  103.                 break;
  104.             case "teleportOut":
  105.                 _teleportOut = Boolean.parseBoolean(value);
  106.                 break;
  107.             case "removeSkills":
  108.                
  109.                 String[] propertySplit = value.split(";");
  110.                
  111.                 for (String skill : propertySplit)
  112.                 {
  113.                     try
  114.                     {
  115.                         _skills.add(Integer.parseInt(skill));
  116.                        
  117.                     }
  118.                     catch (final NumberFormatException nfe)
  119.                     {
  120.                         if (!skill.isEmpty())
  121.                         {
  122.                             LOG.warn(StringUtil.concat(getClass().getSimpleName() + ": invalid config property -> skillsIdLvl \"", propertySplit[0], "\""));
  123.                         }
  124.                     }
  125.                 }
  126.                 break;
  127. +           case "MaxClanMembers":
  128. +               _maxClanMembers = Integer.parseInt(value);
  129. +               break;
  130. +           case "MaxAllyMembers":
  131. +               _maxAllyMembers = Integer.parseInt(value);
  132. +               break;
  133.             case "noSummonZone":
  134.                 _NoSummonZone = Boolean.parseBoolean(value);
  135.                 break;
  136.             default:
  137.                 super.setParameter(name, value);
  138.                 break;
  139.         }
  140.     }
  141.    
  142.     @Override
  143.     protected void onEnter(L2Character character)
  144.     {
  145.         if (_enabled)
  146.         {
  147.             if (character != null)
  148.             {
  149.                 character.setInsideZone(ZoneId.ZONE_BOSS, true);
  150.             }
  151.            
  152.             if (character instanceof L2PcInstance)
  153.             {
  154.                 if (_NoSummonZone)
  155.                 {
  156.                     character.setInsideZone(ZoneId.ZONE_NOSUMMONFRIEND, true);
  157.                 }
  158.                
  159.                 final L2PcInstance player = (L2PcInstance) character;
  160.                
  161.                 if (Config.BOT_PROTECTOR)
  162.                 {
  163.                     player.stopBotChecker();
  164.                 }
  165.                
  166.                 // Asgota custom
  167.                 if (_skills != null)
  168.                 {
  169.                     if (player.getLevel() >= 70)
  170.                     {
  171.                         for (Integer skillId : _skills)
  172.                         {
  173.                             player.removeEffect(skillId);
  174.                         }
  175.                     }
  176.                 }
  177.                
  178.                 if (player.isGM())
  179.                 {
  180.                     player.sendMessage("You entered to " + getName());
  181.                     return;
  182.                 }
  183.                
  184. +               final L2Clan clan = player.getClan();
  185. +               if (clan != null)
  186. +               {
  187. +                   for (L2ClanMember activeChar : clan.getMembers())
  188. +                   {
  189. +                       final String zergClan1 = activeChar.getClan().getName();
  190. +                       final String zergClan2 = player.getClan().getName();
  191. +                      
  192. +                       // limit clan for zone
  193. +                       if (zergClan1.equals(zergClan2))
  194. +                       {
  195. +                           if (_zergMap.get(zergClan1) == null)
  196. +                           {
  197. +                               _zergMap.put(zergClan1, new ArrayList<L2PcInstance>());
  198. +                           }
  199. +                          
  200. +                           _zergMap.get(zergClan1).add(player);
  201. +                          
  202. +                           if (_zergMap.get(zergClan1).size() > _maxClanMembers)
  203. +                           {
  204. +                               player.sendMessage("Sorry only allowed " + _maxClanMembers + " members by Clan.");
  205. +                               player.teleToLocation(TeleportWhereType.Town);
  206. +                           }
  207. +                       }
  208. +                   }
  209. +               }
  210. +              
  211. +               for (L2PcInstance activeChar : L2World.getInstance().getPlayers())
  212. +               {
  213. +                   if (!player.isInsideZone(ZoneId.ZONE_BOSS) || player.getAllyId() == 0)
  214. +                   {
  215. +                       continue;
  216. +                   }
  217. +                  
  218. +                   final String zergAlly1 = activeChar.getClan().getAllyName();
  219. +                   final String zergAlly2 = player.getClan().getAllyName();
  220. +                  
  221. +                   // limit ally for zone
  222. +                   if (zergAlly1.equals(zergAlly2))
  223. +                   {
  224. +                       if (_zergMap.get(zergAlly1) == null)
  225. +                       {
  226. +                           _zergMap.put(zergAlly1, new ArrayList<L2PcInstance>());
  227. +                       }
  228. +                      
  229. +                       _zergMap.get(zergAlly1).add(player);
  230. +                      
  231. +                       if (_zergMap.get(zergAlly1).size() > _maxAllyMembers)
  232. +                       {
  233. +                           player.sendMessage("Sorry only allowed " + _maxAllyMembers + " members by Ally.");
  234. +                           player.teleToLocation(TeleportWhereType.Town);
  235. +                       }
  236. +                   }
  237. +               }
  238. +              
  239.                 // Ignore the check for Van Halter zone id 12014 if player got marks
  240.                 if (getId() == 12014)
  241.                 {
  242.                     final L2ItemInstance VisitorsMark = player.getInventory().getItemByItemId(8064);
  243.                     final L2ItemInstance FadedVisitorsMark = player.getInventory().getItemByItemId(8065);
  244.                     final L2ItemInstance PagansMark = player.getInventory().getItemByItemId(8067);
  245.                    
  246.                     final long mark1 = VisitorsMark == null ? 0 : VisitorsMark.getCount();
  247.                     final long mark2 = FadedVisitorsMark == null ? 0 : FadedVisitorsMark.getCount();
  248.                     final long mark3 = PagansMark == null ? 0 : PagansMark.getCount();
  249.                    
  250.                     if (mark1 != 0 || mark2 != 0 || mark3 != 0)
  251.                     {
  252.                         return;
  253.                     }
  254.                 }
  255.                
  256.                 if (player.isFlying() && !_IsFlyingEnable)
  257.                 {
  258.                     player.teleToLocation(MapRegionTable.TeleportWhereType.Town);
  259.                 }
  260.                
  261.                 if (_pvp)
  262.                 {
  263.                     player.stopPvPFlag();
  264.                     player.updatePvPFlag(1);
  265.                 }
  266.                
  267.                 if (_maxLevel > 0)
  268.                 {
  269.                     if (player.getLevel() > _maxLevel)
  270.                     {
  271.                         player.sendMessage(player.getName() + ", your level was too high (Max level: " + _maxLevel + ")! Teleporting to town...");
  272.                         player.sendPacket(new ExShowScreenMessage("" + player.getName() + ", your level was too high (Max level: " + _maxLevel + ")! Teleporting to town...", 3000, 0x02, false));
  273.                         player.teleToLocation(MapRegionTable.TeleportWhereType.Town);
  274.                     }
  275.                 }
  276.                
  277.                 if (!_AllowCursedWeapons && player.isCursedWeaponEquiped())
  278.                 {
  279.                     player.sendMessage(player.getName() + ", cursed weapon is not allowed here anymore.");
  280.                     player.sendPacket(new ExShowScreenMessage("" + player.getName() + ", cursed weapon is not allowed here anymore.", 3000, 0x02, false));
  281.                     player.teleToLocation(MapRegionTable.TeleportWhereType.Town);
  282.                 }
  283.                
  284.                 if (!player.isEnteringToWorld())
  285.                 {
  286.                     if (_access)
  287.                     {
  288.                         allowPlayerEntry(player, 1);
  289.                     }
  290.                 }
  291.                
  292.                 if (_playersAllowed.contains(player.getObjectId()))
  293.                 {
  294.                     final Long expirationTime = _playerAllowedReEntryTimes.get(player.getObjectId());
  295.                     if (expirationTime == null)
  296.                     {
  297.                         long serverStartTime = GameServer.dateTimeServerStarted.getTimeInMillis();
  298.                         if (serverStartTime > (System.currentTimeMillis() - _timeInvade))
  299.                         {
  300.                             return;
  301.                         }
  302.                     }
  303.                     else
  304.                     {
  305.                         _playerAllowedReEntryTimes.remove(player.getObjectId());
  306.                         if (expirationTime.longValue() > System.currentTimeMillis())
  307.                         {
  308.                             return;
  309.                         }
  310.                     }
  311.                     _playersAllowed.remove(_playersAllowed.indexOf(player.getObjectId()));
  312.                 }
  313.                
  314.                 if (_teleportOut)
  315.                 {
  316.                     player.teleToLocation(MapRegionTable.TeleportWhereType.Town);
  317.                 }
  318.                
  319.             }
  320.             else if (character instanceof L2Summon)
  321.             {
  322.                 final L2PcInstance player = ((L2Summon) character).getOwner();
  323.                 if (player != null && (_maxLevel > 0) && player.getLevel() > _maxLevel)
  324.                 {
  325.                     ((L2Summon) character).unSummon(player);
  326.                 }
  327.             }
  328.         }
  329.     }
  330.    
  331.     @Override
  332.     protected void onExit(L2Character character)
  333.     {
  334.         if (_enabled)
  335.         {
  336.             if (character != null)
  337.             {
  338.                 character.setInsideZone(ZoneId.ZONE_BOSS, false);
  339.             }
  340.            
  341.             if (character instanceof L2PcInstance)
  342.             {
  343.                 if (_NoSummonZone)
  344.                 {
  345.                     character.setInsideZone(ZoneId.ZONE_NOSUMMONFRIEND, false);
  346.                 }
  347.                
  348.                 L2PcInstance player = (L2PcInstance) character;
  349.                
  350.                 if (Config.BOT_PROTECTOR)
  351.                 {
  352.                     player.startBotChecker();
  353.                 }
  354.                
  355.                 if (player.isGM())
  356.                 {
  357.                     player.sendMessage("You left " + getName());
  358.                     return;
  359.                 }
  360. +              
  361. +               if (_zergMap.containsKey(player.getName()))
  362. +               {
  363. +                   _zergMap.remove(player.getName());
  364. +               }
  365. +              
  366.                 if (_pvp)
  367.                 {
  368.                     player.stopPvPFlag();
  369.                     player.updatePvPStatus();
  370.                 }
  371.                
  372.                 // if the player just got disconnected/logged out, store the dc time so that
  373.                 // decisions can be made later about allowing or not the player to log into the zone
  374.                 if (player.isOnline() == 0 && _playersAllowed.contains(character.getObjectId()))
  375.                 {
  376.                     // mark the time that the player left the zone
  377.                     _playerAllowedReEntryTimes.put(character.getObjectId(), System.currentTimeMillis() + _timeInvade);
  378.                 }
  379.                 else
  380.                 {
  381.                     if (_playersAllowed.contains(player.getObjectId()))
  382.                     {
  383.                         _playersAllowed.remove(_playersAllowed.indexOf(player.getObjectId()));
  384.                     }
  385.                    
  386.                     _playerAllowedReEntryTimes.remove(player.getObjectId());
  387.                 }
  388.             }
  389.         }
  390.     }
  391.    
  392.     public void setZoneEnabled(boolean flag)
  393.     {
  394.         if (_enabled != flag)
  395.         {
  396.             oustAllPlayers();
  397.         }
  398.        
  399.         _enabled = flag;
  400.     }
  401.    
  402.     public int getTimeInvade()
  403.     {
  404.         return _timeInvade;
  405.     }
  406.    
  407.     public void setAllowedPlayers(List<Integer> list)
  408.     {
  409.         if (list != null)
  410.         {
  411.             _playersAllowed = list;
  412.         }
  413.     }
  414.    
  415.     public List<Integer> getAllowedPlayers()
  416.     {
  417.         return _playersAllowed;
  418.     }
  419.    
  420.     public boolean isPlayerAllowed(L2PcInstance player)
  421.     {
  422.         if (player.isGM())
  423.         {
  424.             return true;
  425.         }
  426.         else if (_playersAllowed.contains(player.getObjectId()))
  427.         {
  428.             return true;
  429.         }
  430.         player.teleToLocation(MapRegionTable.TeleportWhereType.Town);
  431.         return false;
  432.     }
  433.    
  434.     public void movePlayersTo(int x, int y, int z)
  435.     {
  436.         if (_characterList.isEmpty())
  437.         {
  438.             return;
  439.         }
  440.        
  441.         for (final L2Character character : _characterList.values())
  442.         {
  443.             if (character instanceof L2PcInstance)
  444.             {
  445.                 final L2PcInstance player = (L2PcInstance) character;
  446.                 if (player.isOnline() == 1)
  447.                 {
  448.                     player.teleToLocation(x, y, z);
  449.                 }
  450.             }
  451.         }
  452.     }
  453.    
  454.     public void oustAllPlayers()
  455.     {
  456.         if (_characterList == null)
  457.         {
  458.             return;
  459.         }
  460.        
  461.         if (_characterList.isEmpty())
  462.         {
  463.             return;
  464.         }
  465.        
  466.         for (L2Character character : _characterList.values())
  467.         {
  468.             if (character == null)
  469.             {
  470.                 continue;
  471.             }
  472.            
  473.             if (character instanceof L2PcInstance)
  474.             {
  475.                 L2PcInstance player = (L2PcInstance) character;
  476.                 if (player.isOnline() == 1)
  477.                 {
  478.                     player.teleToLocation(MapRegionTable.TeleportWhereType.Town);
  479.                 }
  480.             }
  481.         }
  482.        
  483.         if (_playerAllowedReEntryTimes != null)
  484.         {
  485.             _playerAllowedReEntryTimes.clear();
  486.         }
  487.        
  488.         if (_playersAllowed != null)
  489.         {
  490.             _playersAllowed.clear();
  491.         }
  492.     }
  493.    
  494.     public void allowPlayerEntry(L2PcInstance player, int durationInSec)
  495.     {
  496.         if (!player.isGM())
  497.         {
  498.             if (!_playersAllowed.contains(player.getObjectId()))
  499.             {
  500.                 _playersAllowed.add(player.getObjectId());
  501.             }
  502.            
  503.             _playerAllowedReEntryTimes.put(player.getObjectId(), System.currentTimeMillis() + durationInSec * 1000);
  504.         }
  505.     }
  506.    
  507.     public void removePlayer(L2PcInstance player)
  508.     {
  509.         if (!player.isGM())
  510.         {
  511.             _playersAllowed.remove(Integer.valueOf(player.getObjectId()));
  512.             _playerAllowedReEntryTimes.remove(player.getObjectId());
  513.         }
  514.     }
  515.    
  516.     @Override
  517.     public void onDieInside(L2Character character)
  518.     {
  519.     }
  520.    
  521.     @Override
  522.     public void onReviveInside(L2Character character)
  523.     {
  524.     }
  525.    
  526.     public void updateKnownList(L2NpcInstance npc)
  527.     {
  528.         if (_characterList == null || _characterList.isEmpty())
  529.         {
  530.             return;
  531.         }
  532.        
  533.         final Map<Integer, L2PcInstance> npcKnownPlayers = npc.getKnownList().getKnownPlayers();
  534.         for (final L2Character character : _characterList.values())
  535.         {
  536.             if (character == null)
  537.             {
  538.                 continue;
  539.             }
  540.            
  541.             if (character instanceof L2PcInstance)
  542.             {
  543.                 final L2PcInstance player = (L2PcInstance) character;
  544.                 if (player.isOnline() == 1 || player.isInOfflineMode())
  545.                 {
  546.                     npcKnownPlayers.put(player.getObjectId(), player);
  547.                 }
  548.             }
  549.         }
  550.         return;
  551.     }
  552.    
  553.     public int getBossId()
  554.     {
  555.         return _bossId;
  556.     }
  557. }
  558.  
  559.  
  560.  
  561.  
  562.  
  563. =========================================================
  564. BossZone.xml
  565. =========================================================
  566.   <!-- Boss zone of Zaken (Correction) -->
  567. <zone name="Zaken Zone (Correction)" type="BossZone" shape="NPoly" minZ="-3632" maxZ="-3000">
  568.     <stat name="bossId" val="29022"/>
  569.     <stat name="maxLevel" val="80"/>
  570.     <stat name="flying" val="false"/>
  571.     <stat name="access" val="true"/>
  572.     <stat name="InvadeTime" val="300000"/>
  573. +    <stat name="MaxClanMembers" val="27" />   
  574. +   <stat name="MaxAllyMembers" val="36" />
  575.     <stat name="pvp" val="true"/>
  576.     <node X="52413" Y="219015"/>
  577.     <node X="52726" Y="219053"/>
  578.     <node X="53407" Y="219939"/>
  579.     <node X="53401" Y="220319"/>
  580.     <node X="52608" Y="220053"/>
  581.     <node X="52423" Y="219292"/>
  582. </zone>
RAW Paste Data Copied
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!