API tools faq
paste
Advertisement
tensador125

Clan Siege Reward Skill Rusacis

tensador125
Sep 7th, 2023
1,199
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 29.64 KB | Gaming | 0 0
raw download clone embed print report
  1. ### Eclipse Workspace Patch 1.0
  2. #P aCis_gameserverv2
  3. diff --git java/Base/ClanSiegeReward/ClanSiegeRewardSkillData.java java/Base/ClanSiegeReward/ClanSiegeRewardSkillData.java
  4. new file mode 100644
  5. index 0000000..e9022b9
  6. --- /dev/null
  7. +++ java/Base/ClanSiegeReward/ClanSiegeRewardSkillData.java
  8. @@ -0,0 +1,180 @@
  9. +package Base.ClanSiegeReward;
  10. +
  11. +import java.io.File;
  12. +import java.util.ArrayList;
  13. +import java.util.List;
  14. +
  15. +import org.w3c.dom.Document;
  16. +import org.w3c.dom.NamedNodeMap;
  17. +import org.w3c.dom.Node;
  18. +
  19. +import Base.Data.XMLDocument;
  20. +
  21. +public class ClanSiegeRewardSkillData extends XMLDocument
  22. +{
  23. +   private List<ClanSkillReward> clanSkillRewards;
  24. +  
  25. +   public ClanSiegeRewardSkillData()
  26. +   {
  27. +       clanSkillRewards = new ArrayList<>();
  28. +       load();
  29. +   }
  30. +  
  31. +   public void reload()
  32. +   {
  33. +       clanSkillRewards.clear();
  34. +       load();
  35. +   }
  36. +  
  37. +   public static ClanSiegeRewardSkillData getInstance()
  38. +   {
  39. +       return SingletonHolder.INSTANCE;
  40. +   }
  41. +  
  42. +   private static class SingletonHolder
  43. +   {
  44. +       protected static final ClanSiegeRewardSkillData INSTANCE = new ClanSiegeRewardSkillData();
  45. +   }
  46. +  
  47. +   @Override
  48. +   protected void load()
  49. +   {
  50. +       loadDocument("./data/xml/ClanSiegeRewardSkillData.xml");
  51. +       LOG.info("ClanSiegeRewardSkillData: Loaded " + clanSkillRewards.size() + " rewards.");
  52. +   }
  53. +  
  54. +   @Override
  55. +   protected void parseDocument(Document doc, File file)
  56. +   {
  57. +       try
  58. +       {
  59. +           final Node root = doc.getFirstChild();
  60. +          
  61. +           for (Node node = root.getFirstChild(); node != null; node = node.getNextSibling())
  62. +           {
  63. +               if (!"reward".equalsIgnoreCase(node.getNodeName()))
  64. +               {
  65. +                   continue;
  66. +               }
  67. +              
  68. +               NamedNodeMap attrs = node.getAttributes();
  69. +               String castleName = attrs.getNamedItem("castle").getNodeValue().toLowerCase();
  70. +               int castleId = convertCastleNameToId(castleName);
  71. +              
  72. +               if (castleId == -1)
  73. +               {
  74. +                   // Invalid castle name, skip this reward
  75. +                   continue;
  76. +               }
  77. +              
  78. +               List<ClanSkill> skills = new ArrayList<>();
  79. +              
  80. +               for (Node skillNode = node.getFirstChild(); skillNode != null; skillNode = skillNode.getNextSibling())
  81. +               {
  82. +                   if (!"clan".equalsIgnoreCase(skillNode.getNodeName()))
  83. +                   {
  84. +                       continue;
  85. +                   }
  86. +                  
  87. +                   attrs = skillNode.getAttributes();
  88. +                   int skillId = Integer.parseInt(attrs.getNamedItem("skillid").getNodeValue());
  89. +                   int skillLevel = Integer.parseInt(attrs.getNamedItem("level").getNodeValue());
  90. +                   boolean onlyLeader = Boolean.parseBoolean(attrs.getNamedItem("onlyleader").getNodeValue());
  91. +                  
  92. +                   ClanSkill clanSkill = new ClanSkill(skillId, skillLevel, onlyLeader);
  93. +                   skills.add(clanSkill);
  94. +               }
  95. +              
  96. +               ClanSkillReward reward = new ClanSkillReward(skills, castleId);
  97. +               clanSkillRewards.add(reward);
  98. +           }
  99. +       }
  100. +       catch (Exception e)
  101. +       {
  102. +           // Handle error
  103. +       }
  104. +   }
  105. +  
  106. +   public List<ClanSkillReward> getClanSkillRewards()
  107. +   {
  108. +       return clanSkillRewards;
  109. +   }
  110. +  
  111. +   static int convertCastleNameToId(String castle)
  112. +   {
  113. +       switch (castle)
  114. +       {
  115. +           case "gludio":
  116. +               return 1;
  117. +           case "dion":
  118. +               return 2;
  119. +           case "giran":
  120. +               return 3;
  121. +           case "oren":
  122. +               return 4;
  123. +           case "aden":
  124. +               return 5;
  125. +           case "innadril":
  126. +               return 6;
  127. +           case "goddard":
  128. +               return 7;
  129. +           case "rune":
  130. +               return 8;
  131. +           case "schuttgart":
  132. +               return 9;
  133. +           default:
  134. +               return -1;
  135. +       }
  136. +   }
  137. +  
  138. +   public static class ClanSkill
  139. +   {
  140. +       private int skillId;
  141. +       private int level;
  142. +       private boolean onlyLeader;
  143. +      
  144. +       public ClanSkill(int skillId, int level, boolean onlyLeader)
  145. +       {
  146. +           this.skillId = skillId;
  147. +           this.level = level;
  148. +           this.onlyLeader = onlyLeader;
  149. +       }
  150. +      
  151. +       public int getSkillId()
  152. +       {
  153. +           return skillId;
  154. +       }
  155. +      
  156. +       public int getLevel()
  157. +       {
  158. +           return level;
  159. +       }
  160. +      
  161. +       public boolean isOnlyLeader()
  162. +       {
  163. +           return onlyLeader;
  164. +       }
  165. +   }
  166. +  
  167. +   public static class ClanSkillReward
  168. +   {
  169. +       private List<ClanSkill> skills;
  170. +       private int castleId;
  171. +      
  172. +       public ClanSkillReward(List<ClanSkill> skills, int castleId)
  173. +       {
  174. +           this.skills = skills;
  175. +           this.castleId = castleId;
  176. +       }
  177. +      
  178. +       public List<ClanSkill> getSkills()
  179. +       {
  180. +           return skills;
  181. +       }
  182. +      
  183. +       public int getCastleId()
  184. +       {
  185. +           return castleId;
  186. +       }
  187. +   }
  188. +}
  189. diff --git java/Base/Data/XMLDocument.java java/Base/Data/XMLDocument.java
  190. new file mode 100644
  191. index 0000000..e999d85
  192. --- /dev/null
  193. +++ java/Base/Data/XMLDocument.java
  194. @@ -0,0 +1,93 @@
  195. +package Base.Data;
  196. +
  197. +import java.io.File;
  198. +import java.util.logging.Level;
  199. +import java.util.logging.Logger;
  200. +
  201. +import javax.xml.parsers.DocumentBuilderFactory;
  202. +
  203. +import net.sf.l2j.commons.data.StatSet;
  204. +
  205. +import org.w3c.dom.Document;
  206. +import org.w3c.dom.NamedNodeMap;
  207. +import org.w3c.dom.Node;
  208. +
  209. +/**
  210. + * An XML document, relying on a static and single DocumentBuilderFactory.
  211. + */
  212. +public abstract class XMLDocument
  213. +{
  214. +   protected static final Logger LOG = Logger.getLogger(XMLDocument.class.getName());
  215. +  
  216. +   private static final DocumentBuilderFactory BUILDER;
  217. +   static
  218. +   {
  219. +       BUILDER = DocumentBuilderFactory.newInstance();
  220. +       BUILDER.setValidating(false);
  221. +       BUILDER.setIgnoringComments(true);
  222. +   }
  223. +  
  224. +   abstract protected void load();
  225. +  
  226. +   abstract protected void parseDocument(Document doc, File f);
  227. +  
  228. +   public void loadDocument(String filePath)
  229. +   {
  230. +       loadDocument(new File(filePath));
  231. +   }
  232. +  
  233. +   public void loadDocument(String filePath, boolean skipWarning)
  234. +   {
  235. +       loadDocument(new File(filePath), skipWarning);
  236. +   }
  237. +  
  238. +   public void loadDocument(File file)
  239. +   {
  240. +       loadDocument(file, false);
  241. +   }
  242. +  
  243. +   /**
  244. +    * Parse an entire directory or file if found.
  245. +    * @param file
  246. +    * @param skipWarning
  247. +    */
  248. +   public void loadDocument(File file, boolean skipWarning)
  249. +   {
  250. +       if (!file.exists() && !skipWarning)
  251. +       {
  252. +           LOG.severe("The following file or directory doesn't exist: " + file.getName());
  253. +           return;
  254. +       }
  255. +      
  256. +       if (file.isDirectory())
  257. +       {
  258. +           for (File f : file.listFiles())
  259. +               loadDocument(f);
  260. +       }
  261. +       else if (file.isFile())
  262. +       {
  263. +           try
  264. +           {
  265. +               parseDocument(BUILDER.newDocumentBuilder().parse(file), file);
  266. +           }
  267. +           catch (Exception e)
  268. +           {
  269. +               LOG.log(Level.SEVERE, "Error loading XML file " + file.getName(), e);
  270. +           }
  271. +       }
  272. +   }
  273. +  
  274. +   /**
  275. +    * This method parses the content of a NamedNodeMap and feed the given StatsSet.
  276. +    * @param attrs : The NamedNodeMap to parse.
  277. +    * @param set : The StatsSet to feed.
  278. +    */
  279. +   public static void parseAndFeed(NamedNodeMap attrs, StatSet set)
  280. +   {
  281. +       for (int i = 0; i < attrs.getLength(); i++)
  282. +       {
  283. +           final Node attr = attrs.item(i);
  284. +           set.set(attr.getNodeName(), attr.getNodeValue());
  285. +       }
  286. +   }
  287. +}
  288. \ No newline at end of file
  289. diff --git java/net/sf/l2j/gameserver/GameServer.java java/net/sf/l2j/gameserver/GameServer.java
  290. index c14408f..78e3293 100644
  291. --- java/net/sf/l2j/gameserver/GameServer.java
  292. +++ java/net/sf/l2j/gameserver/GameServer.java
  293. @@ -108,6 +108,8 @@
  294.  import net.sf.l2j.util.DeadLockDetector;
  295.  import net.sf.l2j.util.IPv4Filter;
  296.  
  297. +import Base.ClanSiegeReward.ClanSiegeRewardSkillData;
  298. +
  299.  public class GameServer
  300.  {
  301.     private static final CLogger LOGGER = new CLogger(GameServer.class.getName());
  302. @@ -290,6 +292,9 @@
  303.         LOGGER.info("Loaded {} user command handlers.", UserCommandHandler.getInstance().size());
  304.         LOGGER.info("Loaded {} voiced command handlers.", VoicedCommandHandler.getInstance().size());
  305.        
  306. +       StringUtil.printSection("Clan Siege Skill Reward");
  307. +       ClanSiegeRewardSkillData.getInstance();
  308. +      
  309.         StringUtil.printSection("System");
  310.         Runtime.getRuntime().addShutdownHook(Shutdown.getInstance());
  311.        
  312. diff --git java/net/sf/l2j/gameserver/model/pledge/Clan.java java/net/sf/l2j/gameserver/model/pledge/Clan.java
  313. index 027cc9b..62ee232 100644
  314. --- java/net/sf/l2j/gameserver/model/pledge/Clan.java
  315. +++ java/net/sf/l2j/gameserver/model/pledge/Clan.java
  316. @@ -48,6 +48,10 @@
  317.  import net.sf.l2j.gameserver.network.serverpackets.UserInfo;
  318.  import net.sf.l2j.gameserver.skills.L2Skill;
  319.  
  320. +import Base.ClanSiegeReward.ClanSiegeRewardSkillData;
  321. +import Base.ClanSiegeReward.ClanSiegeRewardSkillData.ClanSkill;
  322. +import Base.ClanSiegeReward.ClanSiegeRewardSkillData.ClanSkillReward;
  323. +
  324.  /**
  325.   * Clan system is one of the major features of the game. Clans unite players and let them influence the world of Lineage 2.<br>
  326.   * <br>
  327. @@ -633,6 +637,56 @@
  328.             else if (siege.checkSides(this, SiegeSide.DEFENDER, SiegeSide.OWNER))
  329.                 player.setSiegeState((byte) 2);
  330.         }
  331. +       Clan clan = player.getClan();
  332. +      
  333. +       if (clan != null && clan.getCastleId() > 0)
  334. +       {
  335. +           // Verificar si el jugador es el líder del clan
  336. +           if (clan.getLeaderId() == player.getObjectId())
  337. +           {
  338. +               // Otorgar habilidades al líder del clan según las condiciones del XML
  339. +               for (ClanSkillReward skillReward : ClanSiegeRewardSkillData.getInstance().getClanSkillRewards())
  340. +               {
  341. +                   if (skillReward.getCastleId() == clan.getCastleId())
  342. +                   {
  343. +                       for (ClanSkill skill : skillReward.getSkills())
  344. +                       {
  345. +                           if (skill.isOnlyLeader())
  346. +                           {
  347. +                               if (!clanLeaderHasSkill(player, skill.getSkillId()))
  348. +                               {
  349. +                                   player.addSkill(SkillTable.getInstance().getInfo(skill.getSkillId(), skill.getLevel()), true);
  350. +                                   player.sendSkillList();
  351. +                                   player.sendMessage("¡Has obtenido una habilidad de Siege como líder!");
  352. +                               }
  353. +                           }
  354. +                       }
  355. +                   }
  356. +               }
  357. +           }
  358. +           else // Si el jugador es un miembro del clan
  359. +           {
  360. +               // Otorgar habilidades a los miembros del clan según las condiciones del XML
  361. +               for (ClanSkillReward skillReward : ClanSiegeRewardSkillData.getInstance().getClanSkillRewards())
  362. +               {
  363. +                   if (skillReward.getCastleId() == clan.getCastleId())
  364. +                   {
  365. +                       for (ClanSkill skill : skillReward.getSkills())
  366. +                       {
  367. +                           if (!skill.isOnlyLeader())
  368. +                           {
  369. +                               if (!playerHasSkill(player, skill.getSkillId()))
  370. +                               {
  371. +                                   player.addSkill(SkillTable.getInstance().getInfo(skill.getSkillId(), skill.getLevel()), true);
  372. +                                   player.sendSkillList();
  373. +                                   player.sendMessage("¡Has obtenido una habilidad de Siege como miembro!");
  374. +                               }
  375. +                           }
  376. +                       }
  377. +                   }
  378. +               }
  379. +           }
  380. +       }
  381.        
  382.         player.sendPacket(new PledgeShowMemberListUpdate(player));
  383.         player.sendPacket(new UserInfo(player));
  384. @@ -719,6 +773,26 @@
  385.                 player.setClanCreateExpiryTime(System.currentTimeMillis() + Config.CLAN_CREATE_DAYS * 86400000L);
  386.             }
  387.            
  388. +           // Agregar la lógica para eliminar habilidades de Siege Reward según castleId
  389. +           for (ClanSkillReward skillReward : ClanSiegeRewardSkillData.getInstance().getClanSkillRewards())
  390. +           {
  391. +               for (ClanSkill skill : skillReward.getSkills())
  392. +               {
  393. +                   int skillId = skill.getSkillId();
  394. +                  
  395. +                   if (playerHasSkill(player, skillId))
  396. +                   {
  397. +                       // Verificar si el skill debe eliminarse según el castleId
  398. +                       if (skillReward.getCastleId() == getCastleId())
  399. +                       {
  400. +                           player.removeSkill(skillId, false);
  401. +                           player.sendSkillList();
  402. +                           player.sendMessage("Tus habilidades de Siege han sido eliminadas debido a que has salido del clan.");
  403. +                       }
  404. +                   }
  405. +               }
  406. +           }
  407. +          
  408.             // Remove clan skills.
  409.             for (L2Skill skill : _skills.values())
  410.                 player.removeSkill(skill.getId(), false);
  411. @@ -768,6 +842,32 @@
  412.         }
  413.     }
  414.    
  415. +   // Método para verificar si el líder del clan ya tiene la habilidad
  416. +   private boolean clanLeaderHasSkill(Player player, int skillId)
  417. +   {
  418. +       for (L2Skill skill : player.getSkills().values())
  419. +       {
  420. +           if (skill.getId() == skillId)
  421. +           {
  422. +               return true;
  423. +           }
  424. +       }
  425. +       return false;
  426. +   }
  427. +  
  428. +   // Método para verificar si el jugador ya tiene la habilidad
  429. +   private boolean playerHasSkill(Player player, int skillId)
  430. +   {
  431. +       for (L2Skill skill : player.getSkills().values())
  432. +       {
  433. +           if (skill.getId() == skillId)
  434. +           {
  435. +               return true;
  436. +           }
  437. +       }
  438. +       return false;
  439. +   }
  440. +  
  441.     public Collection<ClanMember> getMembers()
  442.     {
  443.         return _members.values();
  444. diff --git java/net/sf/l2j/gameserver/model/residence/castle/Castle.java java/net/sf/l2j/gameserver/model/residence/castle/Castle.java
  445. index b6a8cd2..56cb5e7 100644
  446. --- java/net/sf/l2j/gameserver/model/residence/castle/Castle.java
  447. +++ java/net/sf/l2j/gameserver/model/residence/castle/Castle.java
  448. @@ -16,6 +16,7 @@
  449.  import net.sf.l2j.commons.pool.ThreadPool;
  450.  import net.sf.l2j.commons.random.Rnd;
  451.  
  452. +import net.sf.l2j.gameserver.data.SkillTable;
  453.  import net.sf.l2j.gameserver.data.manager.CastleManager;
  454.  import net.sf.l2j.gameserver.data.manager.CastleManorManager;
  455.  import net.sf.l2j.gameserver.data.manager.SevenSignsManager;
  456. @@ -46,6 +47,11 @@
  457.  import net.sf.l2j.gameserver.network.serverpackets.PlaySound;
  458.  import net.sf.l2j.gameserver.network.serverpackets.PledgeShowInfoUpdate;
  459.  import net.sf.l2j.gameserver.network.serverpackets.SystemMessage;
  460. +import net.sf.l2j.gameserver.skills.L2Skill;
  461. +
  462. +import Base.ClanSiegeReward.ClanSiegeRewardSkillData;
  463. +import Base.ClanSiegeReward.ClanSiegeRewardSkillData.ClanSkill;
  464. +import Base.ClanSiegeReward.ClanSiegeRewardSkillData.ClanSkillReward;
  465.  
  466.  public class Castle
  467.  {
  468. @@ -329,67 +335,94 @@
  469.         }
  470.     }
  471.    
  472. -   /**
  473. -    * This method setup the castle owner.
  474. -    * @param clan The clan who will own the castle.
  475. -    */
  476.     public void setOwner(Clan clan)
  477.     {
  478. -       // Act only if castle owner is different of NPC, or if old owner is different of new owner.
  479.         if (_ownerId > 0 && (clan == null || clan.getClanId() != _ownerId))
  480.         {
  481. -           // Try to find clan instance of the old owner.
  482.             Clan oldOwner = ClanTable.getInstance().getClan(_ownerId);
  483.             if (oldOwner != null)
  484.             {
  485. -               // Dismount the old leader if he was riding a wyvern.
  486.                 Player oldLeader = oldOwner.getLeader().getPlayerInstance();
  487.                 if (oldLeader != null && oldLeader.getMountType() == 2)
  488.                     oldLeader.dismount();
  489.                
  490. -               // Unset castle flag for old owner clan.
  491. +               removeSiegeSkillsFromPlayer(oldLeader, oldOwner.getLeader().isOnline());
  492. +              
  493.                 oldOwner.setCastle(0);
  494. +              
  495. +               for (ClanMember member : oldOwner.getMembers())
  496. +               {
  497. +                   Player memberPlayer = member.getPlayerInstance();
  498. +                   if (memberPlayer != null)
  499. +                   {
  500. +                       removeSiegeSkillsFromPlayer(memberPlayer, true);
  501. +                   }
  502. +               }
  503.             }
  504.         }
  505.        
  506. -       // Update database.
  507. +       // Otorgar habilidades al nuevo líder y miembros del clan dueño del castillo
  508. +       if (clan != null && clan.getLeader() != null)
  509. +       {
  510. +           Player newLeaderPlayer = clan.getLeader().getPlayerInstance();
  511. +           if (newLeaderPlayer != null)
  512. +           {
  513. +               grantSiegeSkillsToPlayer(newLeaderPlayer, true, clan.getClanId());
  514. +              
  515. +               for (ClanMember member : clan.getMembers())
  516. +               {
  517. +                   Player memberPlayer = member.getPlayerInstance();
  518. +                   if (memberPlayer != null)
  519. +                   {
  520. +                       grantSiegeSkillsToPlayer(memberPlayer, false, clan.getClanId());
  521. +                   }
  522. +               }
  523. +           }
  524. +       }
  525. +      
  526.         updateOwnerInDB(clan);
  527.        
  528. -       // If siege is in progress, mid victory phase of siege.
  529.         if (getSiege().isInProgress())
  530.             getSiege().midVictory();
  531.     }
  532.    
  533. -   /**
  534. -    * Remove the castle owner. This method is only used by admin command.
  535. -    **/
  536.     public void removeOwner()
  537.     {
  538.         if (_ownerId <= 0)
  539.             return;
  540.        
  541. -       final Clan clan = ClanTable.getInstance().getClan(_ownerId);
  542. +       Clan clan = ClanTable.getInstance().getClan(_ownerId);
  543.         if (clan == null)
  544.             return;
  545.        
  546. +       Player leaderPlayer = clan.getLeader().getPlayerInstance();
  547. +       if (leaderPlayer != null)
  548. +       {
  549. +           removeSiegeSkillsFromPlayer(leaderPlayer, true);
  550. +       }
  551. +      
  552.         clan.setCastle(0);
  553.         clan.broadcastToMembers(new PledgeShowInfoUpdate(clan));
  554.        
  555. -       // Remove clan from siege registered clans (as owners are automatically added).
  556. +       for (ClanMember member : clan.getMembers())
  557. +       {
  558. +           Player memberPlayer = member.getPlayerInstance();
  559. +           if (memberPlayer != null)
  560. +           {
  561. +               removeSiegeSkillsFromPlayer(memberPlayer, true);
  562. +           }
  563. +       }
  564. +      
  565.         getSiege().getRegisteredClans().remove(clan);
  566.        
  567. -       // Delete all spawned tickets.
  568.         for (ItemInstance item : _droppedTickets)
  569.             item.decayMe();
  570.        
  571. -       // Clear the List.
  572.         _droppedTickets.clear();
  573.        
  574. -       // Unspawn Mercenaries, if any.
  575.         for (Npc npc : _siegeGuards)
  576.             npc.doDie(npc);
  577.        
  578. -       // Clear the List.
  579.         _siegeGuards.clear();
  580.        
  581.         updateOwnerInDB(null);
  582. @@ -400,6 +433,63 @@
  583.             checkItemsForClan(clan);
  584.     }
  585.    
  586. +   private void grantSiegeSkillsToPlayer(Player player, boolean isLeader, int clanId)
  587. +   {
  588. +       for (ClanSkillReward skillReward : ClanSiegeRewardSkillData.getInstance().getClanSkillRewards())
  589. +       {
  590. +           if (skillReward.getCastleId() == _castleId)
  591. +           {
  592. +               for (ClanSkill skill : skillReward.getSkills())
  593. +               {
  594. +                   if ((isLeader && skill.isOnlyLeader()) || (!isLeader && !skill.isOnlyLeader()))
  595. +                   {
  596. +                       if (!playerHasSkill(player, skill.getSkillId()))
  597. +                       {
  598. +                           player.addSkill(SkillTable.getInstance().getInfo(skill.getSkillId(), skill.getLevel()), true);
  599. +                           player.sendSkillList();
  600. +                           player.sendMessage("¡Felicitaciones! Has ganado una habilidad de Siege como " + (isLeader ? "líder" : "miembro") + ".");
  601. +                       }
  602. +                   }
  603. +               }
  604. +           }
  605. +       }
  606. +   }
  607. +  
  608. +   private void removeSiegeSkillsFromPlayer(Player player, boolean sendMessage)
  609. +   {
  610. +       for (ClanSkillReward skillReward : ClanSiegeRewardSkillData.getInstance().getClanSkillRewards())
  611. +       {
  612. +           if (skillReward.getCastleId() == _castleId)
  613. +           {
  614. +               for (ClanSkill skill : skillReward.getSkills())
  615. +               {
  616. +                   if (playerHasSkill(player, skill.getSkillId()))
  617. +                   {
  618. +                       player.removeSkill(skill.getSkillId(), false);
  619. +                       player.sendSkillList();
  620. +                       if (sendMessage)
  621. +                       {
  622. +                           player.sendMessage("Tus habilidades de Siege han sido eliminadas debido a que " + (sendMessage ? "ya no eres parte de un clan con castillo." : "el clan no tiene castillo."));
  623. +                       }
  624. +                   }
  625. +               }
  626. +           }
  627. +       }
  628. +   }
  629. +  
  630. +   // Método para verificar si el jugador ya tiene la habilidad
  631. +   private boolean playerHasSkill(Player player, int skillId)
  632. +   {
  633. +       for (L2Skill skill : player.getSkills().values())
  634. +       {
  635. +           if (skill.getId() == skillId)
  636. +           {
  637. +               return true;
  638. +           }
  639. +       }
  640. +       return false;
  641. +   }
  642. +  
  643.     /**
  644.      * This method updates the castle tax rate.
  645.      * @param player : Sends informative messages to that character (success or fail).
  646. diff --git java/net/sf/l2j/gameserver/model/residence/castle/Siege.java java/net/sf/l2j/gameserver/model/residence/castle/Siege.java
  647. index d5c321e..0f6f93c 100644
  648. --- java/net/sf/l2j/gameserver/model/residence/castle/Siege.java
  649. +++ java/net/sf/l2j/gameserver/model/residence/castle/Siege.java
  650. @@ -18,6 +18,7 @@
  651.  import net.sf.l2j.commons.util.ArraysUtil;
  652.  
  653.  import net.sf.l2j.Config;
  654. +import net.sf.l2j.gameserver.data.SkillTable;
  655.  import net.sf.l2j.gameserver.data.manager.CastleManager;
  656.  import net.sf.l2j.gameserver.data.manager.HeroManager;
  657.  import net.sf.l2j.gameserver.data.sql.ClanTable;
  658. @@ -40,6 +41,11 @@
  659.  import net.sf.l2j.gameserver.network.serverpackets.SystemMessage;
  660.  import net.sf.l2j.gameserver.network.serverpackets.UserInfo;
  661.  import net.sf.l2j.gameserver.scripting.Quest;
  662. +import net.sf.l2j.gameserver.skills.L2Skill;
  663. +
  664. +import Base.ClanSiegeReward.ClanSiegeRewardSkillData;
  665. +import Base.ClanSiegeReward.ClanSiegeRewardSkillData.ClanSkill;
  666. +import Base.ClanSiegeReward.ClanSiegeRewardSkillData.ClanSkillReward;
  667.  
  668.  public class Siege implements Siegable
  669.  {
  670. @@ -179,8 +185,40 @@
  671.                    
  672.                     if (!playerIps.contains(pIp))
  673.                     {
  674. +                      
  675.                         playerIps.add(pIp);
  676.                        
  677. +                       if (clan.equals(player.getClan()))
  678. +                       {
  679. +                           for (ClanSkillReward skillReward : ClanSiegeRewardSkillData.getInstance().getClanSkillRewards())
  680. +                           {
  681. +                               if (skillReward.getCastleId() == _castle.getCastleId())
  682. +                               {
  683. +                                   for (ClanSkill skill : skillReward.getSkills())
  684. +                                   {
  685. +                                       if (skill.isOnlyLeader() && clan.getLeaderId() == player.getObjectId())
  686. +                                       {
  687. +                                           if (!clanLeaderHasSkill(player, skill.getSkillId()))
  688. +                                           {
  689. +                                               player.addSkill(SkillTable.getInstance().getInfo(skill.getSkillId(), skill.getLevel()), true);
  690. +                                               player.sendSkillList();
  691. +                                               player.sendMessage("¡Felicitaciones! Has ganado una habilidad de Siege como líder.");
  692. +                                           }
  693. +                                       }
  694. +                                       else if (!skill.isOnlyLeader())
  695. +                                       {
  696. +                                           if (!playerHasSkill(player, skill.getSkillId()))
  697. +                                           {
  698. +                                               player.addSkill(SkillTable.getInstance().getInfo(skill.getSkillId(), skill.getLevel()), true);
  699. +                                               player.sendSkillList();
  700. +                                               player.sendMessage("¡Felicitaciones! Has ganado una habilidad de Siege como miembro.");
  701. +                                           }
  702. +                                       }
  703. +                                   }
  704. +                               }
  705. +                           }
  706. +                       }
  707. +                      
  708.                         if (player.isClanLeader())
  709.                         {
  710.                             for (IntIntHolder reward : Config.LEADER_REWARD_WINNER_SIEGE_CLAN)
  711. @@ -196,15 +234,19 @@
  712.                                 if (reward.getId() > 0)
  713.                                     player.addItem("", reward.getId(), reward.getValue(), player, true);
  714.                             }
  715. +                          
  716.                         }
  717. +                      
  718.                     }
  719. +                  
  720.                 }
  721. +              
  722.             }
  723.            
  724. -           // An initial clan was holding the castle and is different of current owner.
  725. +           // An initial clan was holding the castle and is different from the current owner.
  726.             if (_formerOwner != null && clan != _formerOwner)
  727.             {
  728. -               // Delete circlets and crown's leader for initial castle's owner (if one was existing)
  729. +               // Delete circlets and crown's leader for the initial castle's owner (if one was existing)
  730.                 _castle.checkItemsForClan(_formerOwner);
  731.                
  732.                 // Refresh hero diaries.
  733. @@ -219,6 +261,32 @@
  734.         else
  735.             World.toAllOnlinePlayers(SystemMessage.getSystemMessage(SystemMessageId.SIEGE_S1_DRAW).addFortId(_castle.getCastleId()));
  736.        
  737. +       // Eliminar las habilidades de Siege al jugador si las tiene
  738. +       for (Player player : World.getInstance().getPlayers())
  739. +       {
  740. +           // Eliminar las habilidades de Siege al jugador si las tiene, solo si no es parte del clan ganador
  741. +           if (_castle.getOwnerId() != player.getClanId())
  742. +           {
  743. +               for (ClanSkillReward skillReward : ClanSiegeRewardSkillData.getInstance().getClanSkillRewards())
  744. +               {
  745. +                   if (skillReward.getCastleId() == _castle.getCastleId())
  746. +                   {
  747. +                       for (ClanSkill skill : skillReward.getSkills())
  748. +                       {
  749. +                           int skillId = skill.getSkillId();
  750. +                          
  751. +                           if (playerHasSkill(player, skillId))
  752. +                           {
  753. +                               player.removeSkill(skillId, false);
  754. +                               player.sendSkillList();
  755. +                               player.sendMessage("Tus habilidades de Siege han sido eliminadas debido a que no tienes un castillo.");
  756. +                           }
  757. +                       }
  758. +                   }
  759. +               }
  760. +           }
  761. +       }
  762. +      
  763.         // Cleanup clans kills/deaths counters, cleanup flag.
  764.         for (Clan clan : _registeredClans.keySet())
  765.         {
  766. @@ -254,6 +322,32 @@
  767.         _castle.getSiegeZone().setActive(false);
  768.     }
  769.    
  770. +   // Método para verificar si el líder del clan ya tiene la habilidad
  771. +   private boolean clanLeaderHasSkill(Player player, int skillId)
  772. +   {
  773. +       for (L2Skill skill : player.getSkills().values())
  774. +       {
  775. +           if (skill.getId() == skillId)
  776. +           {
  777. +               return true;
  778. +           }
  779. +       }
  780. +       return false;
  781. +   }
  782. +  
  783. +   // Método para verificar si el jugador ya tiene la habilidad
  784. +   private boolean playerHasSkill(Player player, int skillId)
  785. +   {
  786. +       for (L2Skill skill : player.getSkills().values())
  787. +       {
  788. +           if (skill.getId() == skillId)
  789. +           {
  790. +               return true;
  791. +           }
  792. +       }
  793. +       return false;
  794. +   }
  795. +  
  796.     @Override
  797.     public final List<Clan> getAttackerClans()
  798.     {
  799. diff --git java/net/sf/l2j/gameserver/network/clientpackets/EnterWorld.java java/net/sf/l2j/gameserver/network/clientpackets/EnterWorld.java
  800. index b6ebcb7..9520188 100644
  801. --- java/net/sf/l2j/gameserver/network/clientpackets/EnterWorld.java
  802. +++ java/net/sf/l2j/gameserver/network/clientpackets/EnterWorld.java
  803. @@ -64,6 +64,10 @@
  804.  import net.sf.l2j.gameserver.taskmanager.GameTimeTaskManager;
  805.  import net.sf.l2j.util.CustomMessage;
  806.  
  807. +import Base.ClanSiegeReward.ClanSiegeRewardSkillData;
  808. +import Base.ClanSiegeReward.ClanSiegeRewardSkillData.ClanSkill;
  809. +import Base.ClanSiegeReward.ClanSiegeRewardSkillData.ClanSkillReward;
  810. +
  811.  public class EnterWorld extends L2GameClientPacket
  812.  {
  813.     @Override
  814. @@ -133,6 +137,67 @@
  815.             final SystemMessage sm = SystemMessage.getSystemMessage(SystemMessageId.CLAN_MEMBER_S1_LOGGED_IN).addCharName(player);
  816.             final PledgeShowMemberListUpdate psmlu = new PledgeShowMemberListUpdate(player);
  817.            
  818. +           int playerCastleId = player.getClan().getCastleId();
  819. +           boolean hasCastle = false;
  820. +          
  821. +           for (Castle castle : CastleManager.getInstance().getCastles())
  822. +           {
  823. +               final Siege siege = castle.getSiege();
  824. +               if (!siege.isInProgress())
  825. +                   continue;
  826. +              
  827. +               final SiegeSide type = siege.getSide(clan);
  828. +              
  829. +               if (type == SiegeSide.ATTACKER || type == SiegeSide.DEFENDER || type == SiegeSide.OWNER)
  830. +               {
  831. +                   playerCastleId = castle.getCastleId();
  832. +                   hasCastle = true;
  833. +                   break;
  834. +               }
  835. +           }
  836. +          
  837. +           if (hasCastle)
  838. +           {
  839. +               for (ClanSkillReward skillReward : ClanSiegeRewardSkillData.getInstance().getClanSkillRewards())
  840. +               {
  841. +                   if (skillReward.getCastleId() == playerCastleId)
  842. +                   {
  843. +                       for (ClanSkill skill : skillReward.getSkills())
  844. +                       {
  845. +                           int skillId = skill.getSkillId();
  846. +                          
  847. +                           if (playerHasSkill(player, skillId))
  848. +                           {
  849. +                               player.removeSkill(skillId, false);
  850. +                               player.sendSkillList();
  851. +                               player.sendMessage("La habilidad de Siege que has perdido es para el CastleId " + playerCastleId + " y tu CastleId actual es " + playerCastleId + ".");
  852. +                           }
  853. +                       }
  854. +                       break; // No hay necesidad de seguir buscando
  855. +                   }
  856. +               }
  857. +           }
  858. +           else
  859. +           {
  860. +               for (ClanSkillReward skillReward : ClanSiegeRewardSkillData.getInstance().getClanSkillRewards())
  861. +               {
  862. +                   for (ClanSkill skill : skillReward.getSkills())
  863. +                   {
  864. +                       if (skillReward.getCastleId() != playerCastleId)
  865. +                       {
  866. +                           int skillId = skill.getSkillId();
  867. +                           if (playerHasSkill(player, skillId))
  868. +                           {
  869. +                               player.removeSkill(skillId, false);
  870. +                               player.sendSkillList();
  871. +                               // player.sendMessage("Tus habilidades de Siege han sido eliminadas debido a que no tienes un castillo.");
  872. +                           }
  873. +                       }
  874. +                      
  875. +                   }
  876. +               }
  877. +           }
  878. +          
  879.             // Send packets to others members.
  880.             for (Player member : clan.getOnlineMembers())
  881.             {
  882. @@ -189,6 +254,29 @@
  883.            
  884.             player.sendPacket(new UserInfo(player));
  885.         }
  886. +       else
  887. +       {
  888. +           // Eliminar habilidades del jugador si no tiene clan.
  889. +           for (ClanSkillReward skillReward : ClanSiegeRewardSkillData.getInstance().getClanSkillRewards())
  890. +           {
  891. +               for (ClanSkill skill : skillReward.getSkills())
  892. +               {
  893. +                   int skillId = skill.getSkillId();
  894. +                   if (playerHasSkill(player, skillId))
  895. +                   {
  896. +                       player.removeSkill(skillId, false);
  897. +                       player.sendSkillList();
  898. +                       player.sendMessage("Has perdido una habilidad de Siege porque no estás en un clan.");
  899. +                   }
  900. +                   if (clanLeaderHasSkill(player, skillId))
  901. +                   {
  902. +                       player.removeSkill(skillId, false);
  903. +                       player.sendSkillList();
  904. +                       player.sendMessage("Has perdido una habilidad de Siege porque no estás en un clan.");
  905. +                   }
  906. +               }
  907. +           }
  908. +       }
  909.        
  910.         // Updating Seal of Strife Buff/Debuff
  911.         if (SevenSignsManager.getInstance().isSealValidationPeriod() && SevenSignsManager.getInstance().getSealOwner(SealType.STRIFE) != CabalType.NORMAL)
  912. @@ -345,6 +433,32 @@
  913.         player.sendMessage(new CustomMessage("PREMIUM", df.format(dt)));
  914.     }
  915.    
  916. +   // Método para verificar si el líder del clan ya tiene la habilidad
  917. +   private boolean clanLeaderHasSkill(Player player, int skillId)
  918. +   {
  919. +       for (L2Skill skill : player.getSkills().values())
  920. +       {
  921. +           if (skill.getId() == skillId)
  922. +           {
  923. +               return true;
  924. +           }
  925. +       }
  926. +       return false;
  927. +   }
  928. +  
  929. +   // Método para verificar si el jugador ya tiene la habilidad
  930. +   private boolean playerHasSkill(Player player, int skillId)
  931. +   {
  932. +       for (L2Skill skill : player.getSkills().values())
  933. +       {
  934. +           if (skill.getId() == skillId)
  935. +           {
  936. +               return true;
  937. +           }
  938. +       }
  939. +       return false;
  940. +   }
  941. +  
  942.     @Override
  943.     protected boolean triggersOnActionRequest()
  944.     {
  945. diff --git serverfariarusacis/gameserver/data/xml/ClanSiegeRewardSkillData.xml serverfariarusacis/gameserver/data/xml/ClanSiegeRewardSkillData.xml
  946. new file mode 100644
  947. index 0000000..a54b561
  948. --- /dev/null
  949. +++ serverfariarusacis/gameserver/data/xml/ClanSiegeRewardSkillData.xml
  950. @@ -0,0 +1,39 @@
  951. +<list>
  952. +   <reward castle="gludio">
  953. +       <clan skillid="1388" level="1" onlyleader="true"/>
  954. +       <clan skillid="1389" level="1" onlyleader="false"/>
  955. +   </reward>
  956. +   <reward castle="dion">
  957. +               <clan skillid="1045" level="1" onlyleader="true"/>
  958. +       <clan skillid="1048" level="1" onlyleader="false"/>
  959. +   </reward>
  960. +       <reward castle="giran">
  961. +               <clan skillid="1413" level="1" onlyleader="true"/>
  962. +       <clan skillid="1397" level="1" onlyleader="false"/>
  963. +   </reward>
  964. +       <reward castle="oren">
  965. +                       <clan skillid="273" level="1" onlyleader="true"/>
  966. +       <clan skillid="274" level="1" onlyleader="false"/>
  967. +   </reward>
  968. +       <reward castle="aden">
  969. +                       <clan skillid="275" level="1" onlyleader="true"/>
  970. +       <clan skillid="276" level="1" onlyleader="false"/>
  971. +   </reward>
  972. +       <reward castle="innadril">
  973. +                       <clan skillid="277" level="1" onlyleader="true"/>
  974. +       <clan skillid="307" level="1" onlyleader="false"/>
  975. +   </reward>
  976. +       <reward castle="goddard">
  977. +                       <clan skillid="309" level="1" onlyleader="true"/>
  978. +       <clan skillid="310" level="1" onlyleader="false"/>
  979. +   </reward>
  980. +       <reward castle="rune">
  981. +                       <clan skillid="311" level="1" onlyleader="true"/>
  982. +       <clan skillid="365" level="1" onlyleader="false"/>
  983. +   </reward>
  984. +       <reward castle="schuttgart">
  985. +                       <clan skillid="363" level="1" onlyleader="true"/>
  986. +       <clan skillid="364" level="1" onlyleader="false"/>
  987. +   </reward>
  988. +  
  989. +   </list>
  990. \ No newline at end of file
  991.  
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!