Giardev

AntiZerg L2BossZone.java L2jorion

May 24th, 2022 (edited)
111
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  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