API tools faq
paste
Advertisement
tensador125

Clan Siege Reward Skill l2jmega

tensador125
Sep 7th, 2023
1,277
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 27.18 KB | Gaming | 0 0
raw download clone embed print report
  1. ### Eclipse Workspace Patch 1.0
  2. #P L2jMega_gameserver2
  3. diff --git dist/game/data/xml/ClanSiegeRewardSkillData.xml dist/game/data/xml/ClanSiegeRewardSkillData.xml
  4. new file mode 100644
  5. index 0000000..4e7b149
  6. --- /dev/null
  7. +++ dist/game/data/xml/ClanSiegeRewardSkillData.xml
  8. @@ -0,0 +1,39 @@
  9. +<list>
  10. +   <reward castle="gludio">
  11. +       <clan skillid="1388" level="1" onlyleader="true"/>
  12. +       <clan skillid="1389" level="1" onlyleader="false"/>
  13. +   </reward>
  14. +   <reward castle="dion">
  15. +               <clan skillid="1045" level="1" onlyleader="true"/>
  16. +       <clan skillid="1048" level="1" onlyleader="false"/>
  17. +   </reward>
  18. +       <reward castle="giran">
  19. +               <clan skillid="1413" level="1" onlyleader="true"/>
  20. +       <clan skillid="1397" level="1" onlyleader="false"/>
  21. +   </reward>
  22. +       <reward castle="oren">
  23. +                       <clan skillid="273" level="1" onlyleader="true"/>
  24. +       <clan skillid="274" level="1" onlyleader="false"/>
  25. +   </reward>
  26. +       <reward castle="aden">
  27. +                       <clan skillid="275" level="1" onlyleader="true"/>
  28. +       <clan skillid="276" level="1" onlyleader="false"/>
  29. +   </reward>
  30. +       <reward castle="innadril">
  31. +                       <clan skillid="277" level="1" onlyleader="true"/>
  32. +       <clan skillid="307" level="1" onlyleader="false"/>
  33. +   </reward>
  34. +       <reward castle="goddard">
  35. +                       <clan skillid="309" level="1" onlyleader="true"/>
  36. +       <clan skillid="310" level="1" onlyleader="false"/>
  37. +   </reward>
  38. +       <reward castle="rune">
  39. +                       <clan skillid="311" level="1" onlyleader="true"/>
  40. +       <clan skillid="365" level="1" onlyleader="false"/>
  41. +   </reward>
  42. +       <reward castle="schuttgart">
  43. +                       <clan skillid="363" level="1" onlyleader="true"/>
  44. +       <clan skillid="364" level="1" onlyleader="false"/>
  45. +   </reward>
  46. +  
  47. +   </list>
  48. diff --git java/Base/ClanSiegeReward/ClanSiegeRewardSkillData.java java/Base/ClanSiegeReward/ClanSiegeRewardSkillData.java
  49. new file mode 100644
  50. index 0000000..e9022b9
  51. --- /dev/null
  52. +++ java/Base/ClanSiegeReward/ClanSiegeRewardSkillData.java
  53. @@ -0,0 +1,180 @@
  54. +package Base.ClanSiegeReward;
  55. +
  56. +import java.io.File;
  57. +import java.util.ArrayList;
  58. +import java.util.List;
  59. +
  60. +import org.w3c.dom.Document;
  61. +import org.w3c.dom.NamedNodeMap;
  62. +import org.w3c.dom.Node;
  63. +
  64. +import Base.Data.XMLDocument;
  65. +
  66. +public class ClanSiegeRewardSkillData extends XMLDocument
  67. +{
  68. +   private List<ClanSkillReward> clanSkillRewards;
  69. +  
  70. +   public ClanSiegeRewardSkillData()
  71. +   {
  72. +       clanSkillRewards = new ArrayList<>();
  73. +       load();
  74. +   }
  75. +  
  76. +   public void reload()
  77. +   {
  78. +       clanSkillRewards.clear();
  79. +       load();
  80. +   }
  81. +  
  82. +   public static ClanSiegeRewardSkillData getInstance()
  83. +   {
  84. +       return SingletonHolder.INSTANCE;
  85. +   }
  86. +  
  87. +   private static class SingletonHolder
  88. +   {
  89. +       protected static final ClanSiegeRewardSkillData INSTANCE = new ClanSiegeRewardSkillData();
  90. +   }
  91. +  
  92. +   @Override
  93. +   protected void load()
  94. +   {
  95. +       loadDocument("./data/xml/ClanSiegeRewardSkillData.xml");
  96. +       LOG.info("ClanSiegeRewardSkillData: Loaded " + clanSkillRewards.size() + " rewards.");
  97. +   }
  98. +  
  99. +   @Override
  100. +   protected void parseDocument(Document doc, File file)
  101. +   {
  102. +       try
  103. +       {
  104. +           final Node root = doc.getFirstChild();
  105. +          
  106. +           for (Node node = root.getFirstChild(); node != null; node = node.getNextSibling())
  107. +           {
  108. +               if (!"reward".equalsIgnoreCase(node.getNodeName()))
  109. +               {
  110. +                   continue;
  111. +               }
  112. +              
  113. +               NamedNodeMap attrs = node.getAttributes();
  114. +               String castleName = attrs.getNamedItem("castle").getNodeValue().toLowerCase();
  115. +               int castleId = convertCastleNameToId(castleName);
  116. +              
  117. +               if (castleId == -1)
  118. +               {
  119. +                   // Invalid castle name, skip this reward
  120. +                   continue;
  121. +               }
  122. +              
  123. +               List<ClanSkill> skills = new ArrayList<>();
  124. +              
  125. +               for (Node skillNode = node.getFirstChild(); skillNode != null; skillNode = skillNode.getNextSibling())
  126. +               {
  127. +                   if (!"clan".equalsIgnoreCase(skillNode.getNodeName()))
  128. +                   {
  129. +                       continue;
  130. +                   }
  131. +                  
  132. +                   attrs = skillNode.getAttributes();
  133. +                   int skillId = Integer.parseInt(attrs.getNamedItem("skillid").getNodeValue());
  134. +                   int skillLevel = Integer.parseInt(attrs.getNamedItem("level").getNodeValue());
  135. +                   boolean onlyLeader = Boolean.parseBoolean(attrs.getNamedItem("onlyleader").getNodeValue());
  136. +                  
  137. +                   ClanSkill clanSkill = new ClanSkill(skillId, skillLevel, onlyLeader);
  138. +                   skills.add(clanSkill);
  139. +               }
  140. +              
  141. +               ClanSkillReward reward = new ClanSkillReward(skills, castleId);
  142. +               clanSkillRewards.add(reward);
  143. +           }
  144. +       }
  145. +       catch (Exception e)
  146. +       {
  147. +           // Handle error
  148. +       }
  149. +   }
  150. +  
  151. +   public List<ClanSkillReward> getClanSkillRewards()
  152. +   {
  153. +       return clanSkillRewards;
  154. +   }
  155. +  
  156. +   static int convertCastleNameToId(String castle)
  157. +   {
  158. +       switch (castle)
  159. +       {
  160. +           case "gludio":
  161. +               return 1;
  162. +           case "dion":
  163. +               return 2;
  164. +           case "giran":
  165. +               return 3;
  166. +           case "oren":
  167. +               return 4;
  168. +           case "aden":
  169. +               return 5;
  170. +           case "innadril":
  171. +               return 6;
  172. +           case "goddard":
  173. +               return 7;
  174. +           case "rune":
  175. +               return 8;
  176. +           case "schuttgart":
  177. +               return 9;
  178. +           default:
  179. +               return -1;
  180. +       }
  181. +   }
  182. +  
  183. +   public static class ClanSkill
  184. +   {
  185. +       private int skillId;
  186. +       private int level;
  187. +       private boolean onlyLeader;
  188. +      
  189. +       public ClanSkill(int skillId, int level, boolean onlyLeader)
  190. +       {
  191. +           this.skillId = skillId;
  192. +           this.level = level;
  193. +           this.onlyLeader = onlyLeader;
  194. +       }
  195. +      
  196. +       public int getSkillId()
  197. +       {
  198. +           return skillId;
  199. +       }
  200. +      
  201. +       public int getLevel()
  202. +       {
  203. +           return level;
  204. +       }
  205. +      
  206. +       public boolean isOnlyLeader()
  207. +       {
  208. +           return onlyLeader;
  209. +       }
  210. +   }
  211. +  
  212. +   public static class ClanSkillReward
  213. +   {
  214. +       private List<ClanSkill> skills;
  215. +       private int castleId;
  216. +      
  217. +       public ClanSkillReward(List<ClanSkill> skills, int castleId)
  218. +       {
  219. +           this.skills = skills;
  220. +           this.castleId = castleId;
  221. +       }
  222. +      
  223. +       public List<ClanSkill> getSkills()
  224. +       {
  225. +           return skills;
  226. +       }
  227. +      
  228. +       public int getCastleId()
  229. +       {
  230. +           return castleId;
  231. +       }
  232. +   }
  233. +}
  234. diff --git java/net/sf/l2j/gameserver/GameServer.java java/net/sf/l2j/gameserver/GameServer.java
  235. index e67bb46..115abbe 100644
  236. --- java/net/sf/l2j/gameserver/GameServer.java
  237. +++ java/net/sf/l2j/gameserver/GameServer.java
  238. @@ -161,6 +161,7 @@
  239.  import Base.Balance.ClassBalanceManager2;
  240.  import Base.Balance.SkillBalanceManager;
  241.  import Base.CapsuleBox.CapsuleBoxData;
  242. +import Base.ClanSiegeReward.ClanSiegeRewardSkillData;
  243.  import Base.Combination.XML.CombinationItemsData;
  244.  import Base.Dolls.DollsData;
  245.  import Base.HuntPass.HuntPassData;
  246. @@ -600,6 +601,11 @@
  247.         CapsuleBoxData.getInstance();
  248.        
  249.        
  250. +               StringUtil.printSection("Clan Siege Skill Reward");
  251. +               ClanSiegeRewardSkillData.getInstance();
  252. +      
  253. +      
  254. +      
  255.         StringUtil.printSection("Dolls Terius");
  256.         DollsData.getInstance();
  257.        
  258. diff --git java/net/sf/l2j/gameserver/model/entity/Castle.java java/net/sf/l2j/gameserver/model/entity/Castle.java
  259. index 5a5fb86..9a293e3 100644
  260. --- java/net/sf/l2j/gameserver/model/entity/Castle.java
  261. +++ java/net/sf/l2j/gameserver/model/entity/Castle.java
  262. @@ -13,12 +13,14 @@
  263.  
  264.  import net.sf.l2j.L2DatabaseFactory;
  265.  import net.sf.l2j.gameserver.data.NpcTable;
  266. +import net.sf.l2j.gameserver.data.SkillTable;
  267.  import net.sf.l2j.gameserver.data.sql.ClanTable;
  268.  import net.sf.l2j.gameserver.instancemanager.CastleManager;
  269.  import net.sf.l2j.gameserver.instancemanager.CastleManorManager;
  270.  import net.sf.l2j.gameserver.instancemanager.SevenSigns;
  271.  import net.sf.l2j.gameserver.instancemanager.SevenSigns.SealType;
  272.  import net.sf.l2j.gameserver.instancemanager.ZoneManager;
  273. +import net.sf.l2j.gameserver.model.L2Skill;
  274.  import net.sf.l2j.gameserver.model.L2Spawn;
  275.  import net.sf.l2j.gameserver.model.WorldObject;
  276.  import net.sf.l2j.gameserver.model.actor.Npc;
  277. @@ -39,6 +41,10 @@
  278.  import net.sf.l2j.gameserver.network.serverpackets.PledgeShowInfoUpdate;
  279.  import net.sf.l2j.gameserver.network.serverpackets.SystemMessage;
  280.  
  281. +import Base.ClanSiegeReward.ClanSiegeRewardSkillData;
  282. +import Base.ClanSiegeReward.ClanSiegeRewardSkillData.ClanSkill;
  283. +import Base.ClanSiegeReward.ClanSiegeRewardSkillData.ClanSkillReward;
  284. +
  285.  public class Castle
  286.  {
  287.     protected static final Logger _log = Logger.getLogger(Castle.class.getName());
  288. @@ -326,13 +332,55 @@
  289.                 {
  290.                     if (oldLeader.getMountType() == 2)
  291.                         oldLeader.dismount();
  292. +                                   removeSiegeSkillsFromPlayer(oldLeader, oldOwner.getLeader().isOnline());                   
  293. +                  
  294.                 }
  295.                
  296.                 // Unset castle flag for old owner clan.
  297.                 oldOwner.setCastle(0);
  298. +              
  299. +              
  300. +                               for (ClanMember member : oldOwner.getMembers())
  301. +                                   {
  302. +                                       Player memberPlayer = member.getPlayerInstance();
  303. +                                       if (memberPlayer != null)
  304. +                                       {
  305. +                                           removeSiegeSkillsFromPlayer(memberPlayer, true);
  306. +                                       }
  307. +                                   }
  308. +              
  309. +              
  310. +              
  311. +              
  312. +              
  313. +              
  314.             }
  315.         }
  316.        
  317. +      
  318. +       // Otorgar habilidades al nuevo líder y miembros del clan dueño del castillo
  319. +       if (clan != null && clan.getLeader() != null)
  320. +       {
  321. +           Player newLeaderPlayer = clan.getLeader().getPlayerInstance();
  322. +           if (newLeaderPlayer != null)
  323. +           {
  324. +               grantSiegeSkillsToPlayer(newLeaderPlayer, true, clan.getClanId());
  325. +              
  326. +               for (ClanMember member : clan.getMembers())
  327. +               {
  328. +                   Player memberPlayer = member.getPlayerInstance();
  329. +                   if (memberPlayer != null)
  330. +                   {
  331. +                       grantSiegeSkillsToPlayer(memberPlayer, false, clan.getClanId());
  332. +                   }
  333. +               }
  334. +           }
  335. +       }
  336. +      
  337. +      
  338. +      
  339. +      
  340. +      
  341.         // Update database.
  342.         updateOwnerInDB(clan);
  343.        
  344. @@ -352,15 +400,38 @@
  345.      **/
  346.     public void removeOwner(Clan clan)
  347.     {
  348. +      
  349. +      
  350. +      
  351.         if (clan != null)
  352.         {
  353. +           Player leaderPlayer = clan.getLeader().getPlayerInstance();
  354. +           if (leaderPlayer != null)
  355. +           {
  356. +               removeSiegeSkillsFromPlayer(leaderPlayer, true);
  357. +           }
  358. +          
  359.             _formerOwner = clan;
  360.            
  361.             clan.setCastle(0);
  362.             clan.broadcastToOnlineMembers(new PledgeShowInfoUpdate(clan));
  363.            
  364. +                   for (ClanMember member : clan.getMembers())
  365. +                       {
  366. +                           Player memberPlayer = member.getPlayerInstance();
  367. +                           if (memberPlayer != null)
  368. +                           {
  369. +                               removeSiegeSkillsFromPlayer(memberPlayer, true);
  370. +                           }
  371. +                       }
  372. +          
  373.             // Remove clan from siege registered clans (as owners are automatically added).
  374.             getSiege().getRegisteredClans().remove(clan);
  375. +          
  376. +
  377. +          
  378. +          
  379. +          
  380.         }
  381.        
  382.         updateOwnerInDB(null);
  383. @@ -424,6 +495,71 @@
  384.         }
  385.     }
  386.    
  387. +  
  388. +   private void grantSiegeSkillsToPlayer(Player player, boolean isLeader, int clanId)
  389. +   {
  390. +       for (ClanSkillReward skillReward : ClanSiegeRewardSkillData.getInstance().getClanSkillRewards())
  391. +       {
  392. +           if (skillReward.getCastleId() == _castleId)
  393. +           {
  394. +               for (ClanSkill skill : skillReward.getSkills())
  395. +               {
  396. +                   if ((isLeader && skill.isOnlyLeader()) || (!isLeader && !skill.isOnlyLeader()))
  397. +                   {
  398. +                       if (!playerHasSkill(player, skill.getSkillId()))
  399. +                       {
  400. +                           player.addSkill(SkillTable.getInstance().getInfo(skill.getSkillId(), skill.getLevel()), true);
  401. +                           player.sendSkillList();
  402. +                           player.sendMessage("¡Felicitaciones! Has ganado una habilidad de Siege como " + (isLeader ? "líder" : "miembro") + ".");
  403. +                       }
  404. +                   }
  405. +               }
  406. +           }
  407. +       }
  408. +   }
  409. +  
  410. +   private void removeSiegeSkillsFromPlayer(Player player, boolean sendMessage)
  411. +   {
  412. +       for (ClanSkillReward skillReward : ClanSiegeRewardSkillData.getInstance().getClanSkillRewards())
  413. +       {
  414. +           if (skillReward.getCastleId() == _castleId)
  415. +           {
  416. +               for (ClanSkill skill : skillReward.getSkills())
  417. +               {
  418. +                   if (playerHasSkill(player, skill.getSkillId()))
  419. +                   {
  420. +                       player.removeSkill(skill.getSkillId(), false);
  421. +                       player.sendSkillList();
  422. +                       if (sendMessage)
  423. +                       {
  424. +                           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."));
  425. +                       }
  426. +                   }
  427. +               }
  428. +           }
  429. +       }
  430. +   }
  431. +  
  432. +   // Método para verificar si el jugador ya tiene la habilidad
  433. +   private static boolean playerHasSkill(Player player, int skillId)
  434. +   {
  435. +       for (L2Skill skill : player.getSkills().values())
  436. +       {
  437. +           if (skill.getId() == skillId)
  438. +           {
  439. +               return true;
  440. +           }
  441. +       }
  442. +       return false;
  443. +   }
  444. +      
  445. +  
  446. +  
  447. +  
  448. +  
  449. +  
  450. +  
  451. +  
  452.     /**
  453.      * Respawn doors associated to that castle.
  454.      * @param isDoorWeak if true, spawn doors with 50% max HPs.
  455. diff --git java/net/sf/l2j/gameserver/model/entity/Siege.java java/net/sf/l2j/gameserver/model/entity/Siege.java
  456. index b926b89..ea9b802 100644
  457. --- java/net/sf/l2j/gameserver/model/entity/Siege.java
  458. +++ java/net/sf/l2j/gameserver/model/entity/Siege.java
  459. @@ -21,9 +21,12 @@
  460.  import net.sf.l2j.L2DatabaseFactory;
  461.  import net.sf.l2j.events.clanranking.ClanRankingConfig;
  462.  import net.sf.l2j.gameserver.data.NpcTable;
  463. +import net.sf.l2j.gameserver.data.SkillTable;
  464.  import net.sf.l2j.gameserver.data.sql.ClanTable;
  465.  import net.sf.l2j.gameserver.instancemanager.CastleManager;
  466. +import net.sf.l2j.gameserver.model.L2Skill;
  467.  import net.sf.l2j.gameserver.model.L2Spawn;
  468. +import net.sf.l2j.gameserver.model.World;
  469.  import net.sf.l2j.gameserver.model.WorldObject;
  470.  import net.sf.l2j.gameserver.model.actor.Npc;
  471.  import net.sf.l2j.gameserver.model.actor.instance.ControlTower;
  472. @@ -40,6 +43,10 @@
  473.  import net.sf.l2j.gameserver.scripting.Quest;
  474.  import net.sf.l2j.gameserver.util.Broadcast;
  475.  
  476. +import Base.ClanSiegeReward.ClanSiegeRewardSkillData;
  477. +import Base.ClanSiegeReward.ClanSiegeRewardSkillData.ClanSkill;
  478. +import Base.ClanSiegeReward.ClanSiegeRewardSkillData.ClanSkillReward;
  479. +
  480.  public class Siege implements Siegable
  481.  {
  482.     public enum SiegeSide
  483. @@ -176,6 +183,14 @@
  484.             Broadcast.toAllOnlinePlayers(SystemMessage.getSystemMessage(SystemMessageId.CLAN_S1_VICTORIOUS_OVER_S2_S_SIEGE).addString(clan.getName()).addString(getCastle().getName()));
  485.            
  486.            
  487. +          
  488. +          
  489. +          
  490. +          
  491. +          
  492. +          
  493. +          
  494. +          
  495.             if (ClanRankingConfig.ENABLE_CLAN_RANKING)
  496.             {
  497.                 if (ClanRankingConfig.CLAN_RANKING_SIEGE_POINTS.containsKey(Integer.valueOf(getCastle().getCastleId())))
  498. @@ -197,9 +212,46 @@
  499.                     final Player player = member.getPlayerInstance();
  500.                     if (player != null && player.isNoble())
  501.                         Hero.getInstance().setCastleTaken(player.getObjectId(), getCastle().getCastleId());
  502. +              
  503. +                       if (player != null && clan.equals(player.getClan()))
  504. +                   {
  505. +                       for (ClanSkillReward skillReward : ClanSiegeRewardSkillData.getInstance().getClanSkillRewards())
  506. +                       {
  507. +                           if (skillReward.getCastleId() == _castle.getCastleId())
  508. +                           {
  509. +                               for (ClanSkill skill : skillReward.getSkills())
  510. +                               {
  511. +                                   if (skill.isOnlyLeader() && clan.getLeaderId() == player.getObjectId())
  512. +                                   {
  513. +                                       if (!clanLeaderHasSkill(player, skill.getSkillId()))
  514. +                                       {
  515. +                                           player.addSkill(SkillTable.getInstance().getInfo(skill.getSkillId(), skill.getLevel()), true);
  516. +                                           player.sendSkillList();
  517. +                                           player.sendMessage("¡Felicitaciones! Has ganado una habilidad de Siege como líder.");
  518. +                                       }
  519. +                                   }
  520. +                                   else if (!skill.isOnlyLeader())
  521. +                                   {
  522. +                                       if (!playerHasSkill(player, skill.getSkillId()))
  523. +                                       {
  524. +                                           player.addSkill(SkillTable.getInstance().getInfo(skill.getSkillId(), skill.getLevel()), true);
  525. +                                           player.sendSkillList();
  526. +                                           player.sendMessage("¡Felicitaciones! Has ganado una habilidad de Siege como miembro.");
  527. +                                       }
  528. +                                   }
  529. +                               }
  530. +                           }
  531. +                       }
  532. +                   }
  533.                 }
  534.             }
  535.            
  536. +          
  537. +          
  538. +          
  539. +          
  540. +          
  541. +          
  542.             // reward clan winner Siege by Bluur
  543.             if (Config.ENABLE_WINNNER_REWARD_SIEGE_CLAN)            
  544.                 rewardClanWinner(ClanTable.getInstance().getClan(getCastle().getOwnerId()));
  545. @@ -208,6 +260,37 @@
  546.         else
  547.             Broadcast.toAllOnlinePlayers(SystemMessage.getSystemMessage(SystemMessageId.SIEGE_S1_DRAW).addString(getCastle().getName()));
  548.        
  549. +      
  550. +      
  551. +       // Eliminar las habilidades de Siege al jugador si las tiene
  552. +       for (Player player : World.getInstance().getPlayers())
  553. +       {
  554. +           // Eliminar las habilidades de Siege al jugador si las tiene, solo si no es parte del clan ganador
  555. +           if (_castle.getOwnerId() != player.getClanId())
  556. +           {
  557. +               for (ClanSkillReward skillReward : ClanSiegeRewardSkillData.getInstance().getClanSkillRewards())
  558. +               {
  559. +                   if (skillReward.getCastleId() == _castle.getCastleId())
  560. +                   {
  561. +                       for (ClanSkill skill : skillReward.getSkills())
  562. +                       {
  563. +                           int skillId = skill.getSkillId();
  564. +                          
  565. +                           if (playerHasSkill(player, skillId))
  566. +                           {
  567. +                               player.removeSkill(skillId, false);
  568. +                               player.sendSkillList();
  569. +                               player.sendMessage("Tus habilidades de Siege han sido eliminadas debido a que no tienes un castillo.");
  570. +                           }
  571. +                       }
  572. +                   }
  573. +               }
  574. +           }
  575. +       }
  576. +      
  577. +      
  578. +      
  579. +      
  580.         // Cleanup clans kills/deaths counters, cleanup flag.
  581.         for (Clan clan : _registeredClans.keySet())
  582.         {
  583. @@ -1139,10 +1222,54 @@
  584.             quest.onSiegeEvent();
  585.     }
  586.    
  587. +  
  588. +  
  589. +  
  590. +  
  591. +  
  592. +   // Método para verificar si el líder del clan ya tiene la habilidad
  593. +   private static boolean clanLeaderHasSkill(Player player, int skillId)
  594. +   {
  595. +       for (L2Skill skill : player.getSkills().values())
  596. +       {
  597. +           if (skill.getId() == skillId)
  598. +           {
  599. +               return true;
  600. +           }
  601. +       }
  602. +       return false;
  603. +   }
  604. +  
  605. +   // Método para verificar si el jugador ya tiene la habilidad
  606. +   private static boolean playerHasSkill(Player player, int skillId)
  607. +   {
  608. +       for (L2Skill skill : player.getSkills().values())
  609. +       {
  610. +           if (skill.getId() == skillId)
  611. +           {
  612. +               return true;
  613. +           }
  614. +       }
  615. +       return false;
  616. +   }
  617. +  
  618. +  
  619. +  
  620. +  
  621. +  
  622. +  
  623. +  
  624.     public void rewardClanWinner(Clan clanWinner)
  625.     {
  626.         for (Player player : clanWinner.getOnlineMembers())
  627.         {
  628. +          
  629. +          
  630. +
  631. +          
  632. +          
  633. +          
  634. +          
  635.             if (player.isClanLeader())
  636.             {
  637.                 for (int[] item : Config.LEADER_REWARD_WINNER_SIEGE_CLAN)                                    
  638. diff --git java/net/sf/l2j/gameserver/model/pledge/Clan.java java/net/sf/l2j/gameserver/model/pledge/Clan.java
  639. index fe1c446..8f8c941 100644
  640. --- java/net/sf/l2j/gameserver/model/pledge/Clan.java
  641. +++ java/net/sf/l2j/gameserver/model/pledge/Clan.java
  642. @@ -46,6 +46,10 @@
  643.  import net.sf.l2j.gameserver.network.serverpackets.SystemMessage;
  644.  import net.sf.l2j.gameserver.network.serverpackets.UserInfo;
  645.  
  646. +import Base.ClanSiegeReward.ClanSiegeRewardSkillData;
  647. +import Base.ClanSiegeReward.ClanSiegeRewardSkillData.ClanSkill;
  648. +import Base.ClanSiegeReward.ClanSiegeRewardSkillData.ClanSkillReward;
  649. +
  650.  public class Clan
  651.  {
  652.     private static final CLogger LOGGER = new CLogger(Clan.class.getName());
  653. @@ -632,6 +636,62 @@
  654.                 player.setSiegeState((byte) 2);
  655.         }
  656.        
  657. +      
  658. +       Clan clan = player.getClan();
  659. +      
  660. +       if (clan != null && clan.getCastleId() > 0)
  661. +       {
  662. +           // Verificar si el jugador es el líder del clan
  663. +           if (clan.getLeaderId() == player.getObjectId())
  664. +           {
  665. +               // Otorgar habilidades al líder del clan según las condiciones del XML
  666. +               for (ClanSkillReward skillReward : ClanSiegeRewardSkillData.getInstance().getClanSkillRewards())
  667. +               {
  668. +                   if (skillReward.getCastleId() == clan.getCastleId())
  669. +                   {
  670. +                       for (ClanSkill skill : skillReward.getSkills())
  671. +                       {
  672. +                           if (skill.isOnlyLeader())
  673. +                           {
  674. +                               if (!clanLeaderHasSkill(player, skill.getSkillId()))
  675. +                               {
  676. +                                   player.addSkill(SkillTable.getInstance().getInfo(skill.getSkillId(), skill.getLevel()), true);
  677. +                                   player.sendSkillList();
  678. +                                   player.sendMessage("¡Has obtenido una habilidad de Siege como líder!");
  679. +                               }
  680. +                           }
  681. +                       }
  682. +                   }
  683. +               }
  684. +           }
  685. +           else // Si el jugador es un miembro del clan
  686. +           {
  687. +               // Otorgar habilidades a los miembros del clan según las condiciones del XML
  688. +               for (ClanSkillReward skillReward : ClanSiegeRewardSkillData.getInstance().getClanSkillRewards())
  689. +               {
  690. +                   if (skillReward.getCastleId() == clan.getCastleId())
  691. +                   {
  692. +                       for (ClanSkill skill : skillReward.getSkills())
  693. +                       {
  694. +                           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("¡Has obtenido una habilidad de Siege como miembro!");
  701. +                               }
  702. +                           }
  703. +                       }
  704. +                   }
  705. +               }
  706. +           }
  707. +       }      
  708. +      
  709. +      
  710. +      
  711. +      
  712. +      
  713.         player.sendPacket(new PledgeShowMemberListUpdate(player));
  714.         player.sendPacket(new UserInfo(player));
  715.     }
  716. @@ -723,6 +783,31 @@
  717.                 player.setClanCreateExpiryTime(System.currentTimeMillis() + Config.ALT_CLAN_CREATE_DAYS * 86400000L);
  718.             }
  719.            
  720. +          
  721. +           // Agregar la lógica para eliminar habilidades de Siege Reward según castleId
  722. +           for (ClanSkillReward skillReward : ClanSiegeRewardSkillData.getInstance().getClanSkillRewards())
  723. +           {
  724. +               for (ClanSkill skill : skillReward.getSkills())
  725. +               {
  726. +                   int skillId = skill.getSkillId();
  727. +                  
  728. +                   if (playerHasSkill(player, skillId))
  729. +                   {
  730. +                       // Verificar si el skill debe eliminarse según el castleId
  731. +                       if (skillReward.getCastleId() == getCastleId())
  732. +                       {
  733. +                           player.removeSkill(skillId, false);
  734. +                           player.sendSkillList();
  735. +                           player.sendMessage("Tus habilidades de Siege han sido eliminadas debido a que has salido del clan.");
  736. +                       }
  737. +                   }
  738. +               }
  739. +           }      
  740. +          
  741. +          
  742. +          
  743. +          
  744. +          
  745.             // Remove clan skills.
  746.             for (L2Skill skill : _skills.values())
  747.                 player.removeSkill(skill, false);
  748. @@ -769,6 +854,39 @@
  749.         }
  750.     }
  751.    
  752. +  
  753. +   // Método para verificar si el líder del clan ya tiene la habilidad
  754. +   private static boolean clanLeaderHasSkill(Player player, int skillId)
  755. +   {
  756. +       for (L2Skill skill : player.getSkills().values())
  757. +       {
  758. +           if (skill.getId() == skillId)
  759. +           {
  760. +               return true;
  761. +           }
  762. +       }
  763. +       return false;
  764. +   }
  765. +  
  766. +   // Método para verificar si el jugador ya tiene la habilidad
  767. +   private static boolean playerHasSkill(Player player, int skillId)
  768. +   {
  769. +       for (L2Skill skill : player.getSkills().values())
  770. +       {
  771. +           if (skill.getId() == skillId)
  772. +           {
  773. +               return true;
  774. +           }
  775. +       }
  776. +       return false;
  777. +   }  
  778. +  
  779. +  
  780. +  
  781. +  
  782. +  
  783. +  
  784. +  
  785.     public ClanMember[] getMembers()
  786.     {
  787.         return _members.values().toArray(new ClanMember[_members.size()]);
  788. diff --git java/net/sf/l2j/gameserver/network/clientpackets/EnterWorld.java java/net/sf/l2j/gameserver/network/clientpackets/EnterWorld.java
  789. index 5873721..d0efb37 100644
  790. --- java/net/sf/l2j/gameserver/network/clientpackets/EnterWorld.java
  791. +++ java/net/sf/l2j/gameserver/network/clientpackets/EnterWorld.java
  792. @@ -45,6 +45,7 @@
  793.  import net.sf.l2j.gameserver.instancemanager.Custom.Vip.VIPFreeHTML3;
  794.  import net.sf.l2j.gameserver.instancemanager.Custom.Vip.VIPFreeHTML4;
  795.  import net.sf.l2j.gameserver.model.Announcement;
  796. +import net.sf.l2j.gameserver.model.L2Skill;
  797.  import net.sf.l2j.gameserver.model.World;
  798.  import net.sf.l2j.gameserver.model.actor.instance.ClassMaster;
  799.  import net.sf.l2j.gameserver.model.actor.instance.Player;
  800. @@ -89,6 +90,9 @@
  801.  import net.sf.l2j.gameserver.util.HWID;
  802.  import net.sf.l2j.gameserver.util.IPLog;
  803.  
  804. +import Base.ClanSiegeReward.ClanSiegeRewardSkillData;
  805. +import Base.ClanSiegeReward.ClanSiegeRewardSkillData.ClanSkill;
  806. +import Base.ClanSiegeReward.ClanSiegeRewardSkillData.ClanSkillReward;
  807.  import Base.Dolls.DollsData;
  808.  
  809.  
  810. @@ -179,6 +183,80 @@
  811.             final SystemMessage msg = SystemMessage.getSystemMessage(SystemMessageId.CLAN_MEMBER_S1_LOGGED_IN).addCharName(activeChar);
  812.             final PledgeShowMemberListUpdate update = new PledgeShowMemberListUpdate(activeChar);
  813.            
  814. +          
  815. +          
  816. +          
  817. +          
  818. +          
  819. +          
  820. +           int playerCastleId = activeChar.getClan().getCastleId();
  821. +           boolean hasCastle = false;
  822. +          
  823. +           for (Castle castle : CastleManager.getInstance().getCastles())
  824. +           {
  825. +               final Siege siege = castle.getSiege();
  826. +               if (!siege.isInProgress())
  827. +                   continue;
  828. +              
  829. +               final SiegeSide type = siege.getSide(clan);
  830. +              
  831. +               if (type == SiegeSide.ATTACKER || type == SiegeSide.DEFENDER || type == SiegeSide.OWNER)
  832. +               {
  833. +                   playerCastleId = castle.getCastleId();
  834. +                   hasCastle = true;
  835. +                   break;
  836. +               }
  837. +           }
  838. +          
  839. +           if (hasCastle)
  840. +           {
  841. +               for (ClanSkillReward skillReward : ClanSiegeRewardSkillData.getInstance().getClanSkillRewards())
  842. +               {
  843. +                   if (skillReward.getCastleId() == playerCastleId)
  844. +                   {
  845. +                       for (ClanSkill skill : skillReward.getSkills())
  846. +                       {
  847. +                           int skillId = skill.getSkillId();
  848. +                          
  849. +                           if (playerHasSkill(activeChar, skillId))
  850. +                           {
  851. +                               activeChar.removeSkill(skillId, false);
  852. +                               activeChar.sendSkillList();
  853. +                               activeChar.sendMessage("La habilidad de Siege que has perdido es para el CastleId " + playerCastleId + " y tu CastleId actual es " + playerCastleId + ".");
  854. +                           }
  855. +                       }
  856. +                       break; // No hay necesidad de seguir buscando
  857. +                   }
  858. +               }
  859. +           }
  860. +           else
  861. +           {
  862. +               for (ClanSkillReward skillReward : ClanSiegeRewardSkillData.getInstance().getClanSkillRewards())
  863. +               {
  864. +                   for (ClanSkill skill : skillReward.getSkills())
  865. +                   {
  866. +                       if (skillReward.getCastleId() != playerCastleId)
  867. +                       {
  868. +                           int skillId = skill.getSkillId();
  869. +                           if (playerHasSkill(activeChar, skillId))
  870. +                           {
  871. +                               activeChar.removeSkill(skillId, false);
  872. +                               activeChar.sendSkillList();
  873. +                               // player.sendMessage("Tus habilidades de Siege han sido eliminadas debido a que no tienes un castillo.");
  874. +                           }
  875. +                       }
  876. +                      
  877. +                   }
  878. +               }
  879. +           }  
  880. +          
  881. +          
  882. +          
  883. +          
  884. +          
  885. +          
  886. +          
  887. +          
  888.             // Send packets to others members.
  889.             for (Player member : clan.getOnlineMembers())
  890.             {
  891. @@ -229,7 +307,29 @@
  892.             activeChar.sendPacket(new UserInfo(activeChar));
  893.             activeChar.sendPacket(new PledgeStatusChanged(clan));
  894.         }
  895. -      
  896. +       else
  897. +       {
  898. +           // Eliminar habilidades del jugador si no tiene clan.
  899. +           for (ClanSkillReward skillReward : ClanSiegeRewardSkillData.getInstance().getClanSkillRewards())
  900. +           {
  901. +               for (ClanSkill skill : skillReward.getSkills())
  902. +               {
  903. +                   int skillId = skill.getSkillId();
  904. +                   if (playerHasSkill(activeChar, skillId))
  905. +                   {
  906. +                       activeChar.removeSkill(skillId, false);
  907. +                       activeChar.sendSkillList();
  908. +                       activeChar.sendMessage("Has perdido una habilidad de Siege porque no estás en un clan.");
  909. +                   }
  910. +                   if (clanLeaderHasSkill(activeChar, skillId))
  911. +                   {
  912. +                       activeChar.removeSkill(skillId, false);
  913. +                       activeChar.sendSkillList();
  914. +                       activeChar.sendMessage("Has perdido una habilidad de Siege porque no estás en un clan.");
  915. +                   }
  916. +               }
  917. +           }
  918. +       }
  919.        
  920.        
  921.        
  922. @@ -714,6 +814,39 @@
  923.     }
  924.    
  925.    
  926. +  
  927. +  
  928. +   // Método para verificar si el líder del clan ya tiene la habilidad
  929. +   private static boolean clanLeaderHasSkill(Player player, int skillId)
  930. +   {
  931. +       for (L2Skill skill : player.getSkills().values())
  932. +       {
  933. +           if (skill.getId() == skillId)
  934. +           {
  935. +               return true;
  936. +           }
  937. +       }
  938. +       return false;
  939. +   }
  940. +  
  941. +   // Método para verificar si el jugador ya tiene la habilidad
  942. +   private static boolean playerHasSkill(Player player, int skillId)
  943. +   {
  944. +       for (L2Skill skill : player.getSkills().values())
  945. +       {
  946. +           if (skill.getId() == skillId)
  947. +           {
  948. +               return true;
  949. +           }
  950. +       }
  951. +       return false;
  952. +   }  
  953. +  
  954. +  
  955. +  
  956. +  
  957. +  
  958. +  
  959.  /* private static void onEnterRunaReload(Player activeChar) {
  960.         DollsData dollsData = DollsData.getInstance();
  961.         Map<Integer, Integer> skillLevels = new HashMap<>();
  962.  
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!