Advertisement
tensador125

Dolls and CombineItemNpc Beta

Jul 4th, 2023
1,064
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 64.98 KB | Gaming | 0 0
  1. ### Eclipse Workspace Patch 1.0
  2. #P L2jMega_gameserver2
  3. diff --git java/Base/Combination/CombinationItem.java java/Base/Combination/CombinationItem.java
  4. new file mode 100644
  5. index 0000000..4e395c3
  6. --- /dev/null
  7. +++ java/Base/Combination/CombinationItem.java
  8. @@ -0,0 +1,95 @@
  9. +package Base.Combination;
  10. +
  11. +
  12. +
  13. +import java.util.EnumMap;
  14. +import java.util.Map;
  15. +
  16. +import net.sf.l2j.gameserver.data.ItemTable;
  17. +import net.sf.l2j.gameserver.model.item.kind.Item;
  18. +
  19. +public class CombinationItem {
  20. +    private  int _itemOne;
  21. +  
  22. +    private int _itemTwo;
  23. +    private int _commission;
  24. +    private float _chance;
  25. +    private final Map<CombinationItemType, CombinationItemReward> _rewards = new EnumMap<>(CombinationItemType.class);
  26. +
  27. +    public CombinationItem(int one,  int two, int commission, float chance) {
  28. +        _itemOne = one;
  29. +        _itemTwo = two;
  30. +        _commission = commission;
  31. +        _chance = chance;
  32. +    }
  33. +
  34. +
  35. +    public int getItemOne() {
  36. +        return _itemOne;
  37. +    }
  38. +
  39. +
  40. +
  41. +    public int getItemTwo() {
  42. +        return _itemTwo;
  43. +    }
  44. +    
  45. +    public int setItemOne() {
  46. +        return _itemOne;
  47. +    }
  48. +
  49. +
  50. +
  51. +    public void setItemTwo(int itemtwo) {
  52. +        _itemTwo = itemtwo;
  53. +    }  
  54. +    
  55. +    public void setItemOne(int itemone) {
  56. +        _itemOne = itemone;
  57. +    }
  58. +
  59. +    public int getCommission() {
  60. +        return _commission;
  61. +    }
  62. +
  63. +    public void setCommission(int commission) {
  64. +        _commission = commission;
  65. +    }
  66. +
  67. +    public float getChance() {
  68. +        return _chance;
  69. +    }
  70. +
  71. +    public void setChance(float chance) {
  72. +        _chance = chance;
  73. +    }
  74. +    
  75. +   public String getIconOne()
  76. +   {
  77. +       return getItem().getIcon(_itemOne);
  78. +   }
  79. +  
  80. +   public Item getItem()
  81. +   {
  82. +       return ItemTable.getInstance().getTemplate(_itemOne);
  83. +   }  
  84. +    
  85. +   public String getIconTwo()
  86. +   {
  87. +       return getItem2().getIcon(_itemTwo);
  88. +   }
  89. +  
  90. +   public Item getItem2()
  91. +   {
  92. +       return ItemTable.getInstance().getTemplate(_itemTwo);
  93. +   }
  94. +  
  95. +
  96. +    public void addReward(CombinationItemReward item) {
  97. +        _rewards.put(item.getType(), item);
  98. +    }
  99. +
  100. +    public CombinationItemReward getReward(CombinationItemType type) {
  101. +        return _rewards.get(type);
  102. +    }
  103. +}
  104. diff --git java/Base/Combination/CombinationItemReward.java java/Base/Combination/CombinationItemReward.java
  105. new file mode 100644
  106. index 0000000..925121e
  107. --- /dev/null
  108. +++ java/Base/Combination/CombinationItemReward.java
  109. @@ -0,0 +1,23 @@
  110. +
  111. +package Base.Combination;
  112. +
  113. +import Base.Holder.ItemHolder;
  114. +
  115. +/**
  116. + * @author UnAfraid
  117. + */
  118. +public class CombinationItemReward extends ItemHolder
  119. +{
  120. +   private final CombinationItemType _type;
  121. +  
  122. +   public CombinationItemReward(int id, int count, CombinationItemType type)
  123. +   {
  124. +       super(id, count);
  125. +       _type = type;
  126. +   }
  127. +  
  128. +   public CombinationItemType getType()
  129. +   {
  130. +       return _type;
  131. +   }
  132. +}
  133. diff --git java/Base/Combination/CombinationItemType.java java/Base/Combination/CombinationItemType.java
  134. new file mode 100644
  135. index 0000000..d6c6e89
  136. --- /dev/null
  137. +++ java/Base/Combination/CombinationItemType.java
  138. @@ -0,0 +1,11 @@
  139. +
  140. +package Base.Combination;
  141. +
  142. +/**
  143. + * @author UnAfraid
  144. + */
  145. +public enum CombinationItemType
  146. +{
  147. +   ON_SUCCESS,
  148. +   ON_FAILURE;
  149. +}
  150. diff --git java/Base/Combination/XML/CombinationItemsData.java java/Base/Combination/XML/CombinationItemsData.java
  151. new file mode 100644
  152. index 0000000..5e437ab
  153. --- /dev/null
  154. +++ java/Base/Combination/XML/CombinationItemsData.java
  155. @@ -0,0 +1,100 @@
  156. +package Base.Combination.XML;
  157. +
  158. +import java.io.File;
  159. +import java.util.ArrayList;
  160. +import java.util.List;
  161. +import java.util.logging.Logger;
  162. +
  163. +
  164. +
  165. +import net.sf.l2j.gameserver.data.ItemTable;
  166. +import org.w3c.dom.Document;
  167. +import org.w3c.dom.NamedNodeMap;
  168. +import org.w3c.dom.Node;
  169. +
  170. +import Base.Combination.CombinationItem;
  171. +import Base.Combination.CombinationItemReward;
  172. +import Base.Combination.CombinationItemType;
  173. +import Base.Data.XMLDocument;
  174. +
  175. +
  176. +
  177. +public class CombinationItemsData extends XMLDocument {
  178. +    private static final Logger LOGGER = Logger.getLogger(CombinationItemsData.class.getName());
  179. +    private final List<CombinationItem> _items;
  180. +
  181. +    protected CombinationItemsData() {
  182. +       _items = new ArrayList<>();
  183. +       load();
  184. +    }
  185. +
  186. +    
  187. +   public void reload()
  188. +   {
  189. +       _items.clear();
  190. +       load();
  191. +   }
  192. +    
  193. +    @Override
  194. +    protected void load() {
  195. +        loadDocument("data/xml/CombinationItems.xml");
  196. +        LOGGER.info(getClass().getSimpleName() + ": Loaded " + _items.size() + " combinations.");
  197. +    }
  198. +
  199. +    @Override
  200. +    protected void parseDocument(Document doc, File file) {
  201. +        final Node listNode = doc.getFirstChild();
  202. +        for (Node itemNode = listNode.getFirstChild(); itemNode != null; itemNode = itemNode.getNextSibling()) {
  203. +            if (!"item".equalsIgnoreCase(itemNode.getNodeName())) {
  204. +                continue;
  205. +            }
  206. +
  207. +            NamedNodeMap attrs = itemNode.getAttributes();
  208. +            int one = Integer.parseInt(attrs.getNamedItem("one").getNodeValue());
  209. +            int two = Integer.parseInt(attrs.getNamedItem("two").getNodeValue());
  210. +            int commission = Integer.parseInt(attrs.getNamedItem("commission").getNodeValue());
  211. +            int chance = Integer.parseInt(attrs.getNamedItem("chance").getNodeValue());
  212. +
  213. +            CombinationItem item = new CombinationItem(one, two, commission, chance);
  214. +
  215. +
  216. +
  217. +            for (Node rewardNode = itemNode.getFirstChild(); rewardNode != null; rewardNode = rewardNode.getNextSibling()) {
  218. +                if (!"reward".equalsIgnoreCase(rewardNode.getNodeName())) {
  219. +                    continue;
  220. +                }
  221. +
  222. +                NamedNodeMap rewardAttrs = rewardNode.getAttributes();
  223. +                int id = Integer.parseInt(rewardAttrs.getNamedItem("id").getNodeValue());
  224. +                int count = Integer.parseInt(rewardAttrs.getNamedItem("count").getNodeValue());
  225. +                CombinationItemType type = CombinationItemType.valueOf(rewardAttrs.getNamedItem("type").getNodeValue());
  226. +
  227. +                CombinationItemReward reward = new CombinationItemReward(id, count, type);
  228. +                item.addReward(reward);
  229. +
  230. +                if (ItemTable.getInstance().getTemplate(id) == null) {
  231. +                    LOGGER.info(getClass().getSimpleName() + ": Could not find item with id " + id);
  232. +                }
  233. +            }
  234. +
  235. +            _items.add(item);
  236. +        }
  237. +    }
  238. +
  239. +    public int getLoadedElementsCount() {
  240. +        return _items.size();
  241. +    }
  242. +
  243. +    public List<CombinationItem> getItems() {
  244. +        return _items;
  245. +    }
  246. +
  247. +
  248. +    public static final CombinationItemsData getInstance() {
  249. +        return SingletonHolder.INSTANCE;
  250. +    }
  251. +
  252. +    private static class SingletonHolder {
  253. +        protected static final CombinationItemsData INSTANCE = new CombinationItemsData();
  254. +    }
  255. +}
  256. diff --git java/Base/Data/XMLDocument.java java/Base/Data/XMLDocument.java
  257. new file mode 100644
  258. index 0000000..175b1ca
  259. --- /dev/null
  260. +++ java/Base/Data/XMLDocument.java
  261. @@ -0,0 +1,121 @@
  262. +package Base.Data;
  263. +
  264. +
  265. +
  266. +import java.io.File;
  267. +import java.util.logging.Level;
  268. +import java.util.logging.Logger;
  269. +
  270. +import javax.xml.parsers.DocumentBuilderFactory;
  271. +import javax.xml.transform.OutputKeys;
  272. +import javax.xml.transform.Transformer;
  273. +import javax.xml.transform.TransformerException;
  274. +import javax.xml.transform.TransformerFactory;
  275. +import javax.xml.transform.dom.DOMSource;
  276. +import javax.xml.transform.stream.StreamResult;
  277. +
  278. +import net.sf.l2j.gameserver.templates.StatsSet;
  279. +
  280. +import org.w3c.dom.Document;
  281. +import org.w3c.dom.NamedNodeMap;
  282. +import org.w3c.dom.Node;
  283. +
  284. +/**
  285. + * An XML document, relying on a static and single DocumentBuilderFactory.
  286. + */
  287. +public abstract class XMLDocument
  288. +{
  289. +   protected static final Logger LOG = Logger.getLogger(XMLDocument.class.getName());
  290. +  
  291. +   protected Document document;
  292. +  
  293. +   private static final DocumentBuilderFactory BUILDER;
  294. +   static
  295. +   {
  296. +       BUILDER = DocumentBuilderFactory.newInstance();
  297. +       BUILDER.setValidating(false);
  298. +       BUILDER.setIgnoringComments(true);
  299. +   }
  300. +  
  301. +   abstract protected void load();
  302. +  
  303. +   abstract protected void parseDocument(Document doc, File f);
  304. +  
  305. +   public void loadDocument(String filePath)
  306. +   {
  307. +       loadDocument(new File(filePath));
  308. +   }
  309. +  
  310. +   public void writeDocument(Document doc, String fileName)
  311. +   {
  312. +       try
  313. +       {
  314. +           TransformerFactory transformerFactory = TransformerFactory.newInstance();
  315. +           Transformer transformer = transformerFactory.newTransformer();
  316. +           transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
  317. +           transformer.setOutputProperty(OutputKeys.INDENT, "yes");
  318. +           transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "2");
  319. +          
  320. +           DOMSource source = new DOMSource(doc);
  321. +           StreamResult result = new StreamResult(new File(fileName));
  322. +          
  323. +           transformer.transform(source, result);
  324. +           LOG.info("XML file saved to " + fileName);
  325. +       }
  326. +       catch (TransformerException e)
  327. +       {
  328. +           LOG.warning("Error saving XML file: " + e.getMessage());
  329. +       }
  330. +   }
  331. +  
  332. +   /**
  333. +    * Parse an entire directory or file if found.
  334. +    * @param file
  335. +    */
  336. +   public void loadDocument(File file)
  337. +   {
  338. +       if (!file.exists())
  339. +       {
  340. +           LOG.severe("The following file or directory doesn't exist: " + file.getName());
  341. +           return;
  342. +       }
  343. +      
  344. +       if (file.isDirectory())
  345. +       {
  346. +           for (File f : file.listFiles())
  347. +           {
  348. +               loadDocument(f);
  349. +           }
  350. +       }
  351. +       else if (file.isFile())
  352. +       {
  353. +           try
  354. +           {
  355. +               parseDocument(BUILDER.newDocumentBuilder().parse(file), file);
  356. +           }
  357. +           catch (Exception e)
  358. +           {
  359. +               LOG.log(Level.SEVERE, "Error loading XML file " + file.getName(), e);
  360. +           }
  361. +       }
  362. +   }
  363. +  
  364. +   public Document getDocument()
  365. +   {
  366. +       return document;
  367. +   }
  368. +  
  369. +   /**
  370. +    * This method parses the content of a NamedNodeMap and feed the given StatsSet.
  371. +    * @param attrs : The NamedNodeMap to parse.
  372. +    * @param set : The StatsSet to feed.
  373. +    */
  374. +   public static void parseAndFeed(NamedNodeMap attrs, StatsSet set)
  375. +   {
  376. +       for (int i = 0; i < attrs.getLength(); i++)
  377. +       {
  378. +           final Node attr = attrs.item(i);
  379. +           set.set(attr.getNodeName(), attr.getNodeValue());
  380. +       }
  381. +   }
  382. +}
  383. diff --git java/Base/Dolls/Doll.java java/Base/Dolls/Doll.java
  384. new file mode 100644
  385. index 0000000..7f9f136
  386. --- /dev/null
  387. +++ java/Base/Dolls/Doll.java
  388. @@ -0,0 +1,25 @@
  389. +package Base.Dolls;
  390. +
  391. +public class Doll {
  392. +    private int id;
  393. +    private int skillId;
  394. +    private int skillLvl;
  395. +
  396. +    public Doll(int id, int skillId, int skillLvl) {
  397. +        this.id = id;
  398. +        this.skillId = skillId;
  399. +        this.skillLvl = skillLvl;
  400. +    }
  401. +
  402. +    public int getId() {
  403. +        return id;
  404. +    }
  405. +
  406. +    public int getSkillId() {
  407. +        return skillId;
  408. +    }
  409. +
  410. +    public int getSkillLvl() {
  411. +        return skillLvl;
  412. +    }
  413. +}
  414. diff --git java/Base/Dolls/DollsData.java java/Base/Dolls/DollsData.java
  415. new file mode 100644
  416. index 0000000..f3fc971
  417. --- /dev/null
  418. +++ java/Base/Dolls/DollsData.java
  419. @@ -0,0 +1,71 @@
  420. +package Base.Dolls;
  421. +
  422. +import java.io.File;
  423. +import java.util.HashMap;
  424. +import java.util.Map;
  425. +
  426. +import org.w3c.dom.Document;
  427. +import org.w3c.dom.NamedNodeMap;
  428. +import org.w3c.dom.Node;
  429. +
  430. +import Base.Data.XMLDocument;
  431. +
  432. +public class DollsData extends XMLDocument {
  433. +    private Map<Integer, Doll> dolls;
  434. +
  435. +    public DollsData() {
  436. +        dolls = new HashMap<>();
  437. +        load();
  438. +    }
  439. +
  440. +    public void reload() {
  441. +        dolls.clear();
  442. +        load();
  443. +    }
  444. +
  445. +    public static DollsData getInstance() {
  446. +        return SingletonHolder.INSTANCE;
  447. +    }
  448. +
  449. +    private static class SingletonHolder {
  450. +        protected static final DollsData INSTANCE = new DollsData();
  451. +    }
  452. +
  453. +    @Override
  454. +    protected void load() {
  455. +        loadDocument("./data/xml/Dolls.xml");
  456. +        LOG.info("DollsData: Loaded " + dolls.size() + " dolls.");
  457. +    }
  458. +
  459. +    @Override
  460. +    protected void parseDocument(Document doc, File file) {
  461. +        try {
  462. +            final Node root = doc.getFirstChild();
  463. +
  464. +            for (Node node = root.getFirstChild(); node != null; node = node.getNextSibling()) {
  465. +                if (!"Doll".equalsIgnoreCase(node.getNodeName())) {
  466. +                    continue;
  467. +                }
  468. +
  469. +                NamedNodeMap attrs = node.getAttributes();
  470. +                int id = Integer.parseInt(attrs.getNamedItem("Id").getNodeValue());
  471. +                int skillId = Integer.parseInt(attrs.getNamedItem("SkillId").getNodeValue());
  472. +                int skillLvl = Integer.parseInt(attrs.getNamedItem("SkillLvl").getNodeValue());
  473. +
  474. +                Doll doll = new Doll(id, skillId, skillLvl);
  475. +                dolls.put(id, doll);
  476. +            }
  477. +        } catch (Exception e) {
  478. +            // LOG.warning("DollsData: Error while loading dolls: " + e);
  479. +            e.printStackTrace();
  480. +        }
  481. +    }
  482. +
  483. +    public Map<Integer, Doll> getDolls() {
  484. +        return dolls;
  485. +    }
  486. +
  487. +    public Doll getDollById(int id) {
  488. +        return dolls.get(id);
  489. +    }
  490. +}
  491. diff --git java/Base/Holder/IIdentifiable.java java/Base/Holder/IIdentifiable.java
  492. new file mode 100644
  493. index 0000000..cce0784
  494. --- /dev/null
  495. +++ java/Base/Holder/IIdentifiable.java
  496. @@ -0,0 +1,26 @@
  497. +/*
  498. + * This file is part of the L2J Mobius project.
  499. + *
  500. + * This program is free software: you can redistribute it and/or modify
  501. + * it under the terms of the GNU General Public License as published by
  502. + * the Free Software Foundation, either version 3 of the License, or
  503. + * (at your option) any later version.
  504. + *
  505. + * This program is distributed in the hope that it will be useful,
  506. + * but WITHOUT ANY WARRANTY; without even the implied warranty of
  507. + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  508. + * General Public License for more details.
  509. + *
  510. + * You should have received a copy of the GNU General Public License
  511. + * along with this program. If not, see <http://www.gnu.org/licenses/>.
  512. + */
  513. +package Base.Holder;
  514. +
  515. +/**
  516. + * Identifiable objects interface.
  517. + * @author Zoey76
  518. + */
  519. +public interface IIdentifiable
  520. +{
  521. +   int getId();
  522. +}
  523. diff --git java/Base/Holder/ItemHolder.java java/Base/Holder/ItemHolder.java
  524. new file mode 100644
  525. index 0000000..856d735
  526. --- /dev/null
  527. +++ java/Base/Holder/ItemHolder.java
  528. @@ -0,0 +1,79 @@
  529. +/*
  530. + * This file is part of the L2J Mobius project.
  531. + *
  532. + * This program is free software: you can redistribute it and/or modify
  533. + * it under the terms of the GNU General Public License as published by
  534. + * the Free Software Foundation, either version 3 of the License, or
  535. + * (at your option) any later version.
  536. + *
  537. + * This program is distributed in the hope that it will be useful,
  538. + * but WITHOUT ANY WARRANTY; without even the implied warranty of
  539. + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  540. + * General Public License for more details.
  541. + *
  542. + * You should have received a copy of the GNU General Public License
  543. + * along with this program. If not, see <http://www.gnu.org/licenses/>.
  544. + */
  545. +package Base.Holder;
  546. +
  547. +import net.sf.l2j.gameserver.templates.StatsSet;
  548. +
  549. +/**
  550. + * A simple DTO for items; contains item ID and count.
  551. + * @author UnAfraid
  552. + */
  553. +public class ItemHolder implements IIdentifiable
  554. +{
  555. +   private final int _id;
  556. +   private final int _count;
  557. +  
  558. +   public ItemHolder(StatsSet set)
  559. +   {
  560. +       _id = set.getInteger("id");
  561. +       _count = set.getInteger("count");
  562. +   }
  563. +  
  564. +   public ItemHolder(int id, int count)
  565. +   {
  566. +       _id = id;
  567. +       _count = count;
  568. +   }
  569. +  
  570. +   /**
  571. +    * @return the ID of the item contained in this object
  572. +    */
  573. +   @Override
  574. +   public int getId()
  575. +   {
  576. +       return _id;
  577. +   }
  578. +  
  579. +   /**
  580. +    * @return the count of items contained in this object
  581. +    */
  582. +   public int getCount()
  583. +   {
  584. +       return _count;
  585. +   }
  586. +  
  587. +   @Override
  588. +   public boolean equals(Object obj)
  589. +   {
  590. +       if (!(obj instanceof ItemHolder))
  591. +       {
  592. +           return false;
  593. +       }
  594. +       else if (obj == this)
  595. +       {
  596. +           return true;
  597. +       }
  598. +       final ItemHolder objInstance = (ItemHolder) obj;
  599. +       return (_id == objInstance.getId()) && (_count == objInstance.getCount());
  600. +   }
  601. +  
  602. +   @Override
  603. +   public String toString()
  604. +   {
  605. +       return "[" + getClass().getSimpleName() + "] ID: " + _id + ", count: " + _count;
  606. +   }
  607. +}
  608. diff --git java/net/sf/l2j/gameserver/GameServer.java java/net/sf/l2j/gameserver/GameServer.java
  609. index 900b58f..8aa847e 100644
  610. --- java/net/sf/l2j/gameserver/GameServer.java
  611. +++ java/net/sf/l2j/gameserver/GameServer.java
  612. @@ -142,6 +142,7 @@
  613.  import net.sf.l2j.gameserver.scripting.ScriptManager;
  614.  import net.sf.l2j.gameserver.taskmanager.AttackStanceTaskManager;
  615.  import net.sf.l2j.gameserver.taskmanager.DecayTaskManager;
  616. +//import net.sf.l2j.gameserver.taskmanager.DollsTaskManager;
  617.  import net.sf.l2j.gameserver.taskmanager.GameTimeTaskManager;
  618.  import net.sf.l2j.gameserver.taskmanager.ItemsOnGroundTaskManager;
  619.  import net.sf.l2j.gameserver.taskmanager.MovementTaskManager;
  620. @@ -154,6 +155,8 @@
  621.  import net.sf.l2j.util.IPv4Filter;
  622.  import net.sf.l2j.util.Util;
  623.  
  624. +import Base.Combination.XML.CombinationItemsData;
  625. +import Base.Dolls.DollsData;
  626.  import phantom.PhantomNameManager;
  627.  import phantom.PhantomTitleManager;
  628.  import phantom.PhantomTownAnao;
  629.  
  630. @@ -567,6 +571,13 @@
  631.         LOGGER.info("Loaded {} voiced command handlers.", +VoicedCommandHandler.getInstance().size());
  632.         LOGGER.info("Loaded {} bypass command handlers.", +BypassHandler.getInstance().size());
  633.        
  634. +      
  635. +       StringUtil.printSection("Combine Terius");
  636. +       CombinationItemsData.getInstance();
  637. +      
  638. +       StringUtil.printSection("Dolls Manager - Terius");
  639. +       DollsData.getInstance();
  640. +      
  641.         StringUtil.printSection("Server Work");
  642.         ServerWork.getInstance().StartReset();
  643.         ServerWork.getInstance().loadServer();
  644.  
  645. diff --git java/net/sf/l2j/gameserver/handler/admincommandhandlers/AdminAdmin.java java/net/sf/l2j/gameserver/handler/admincommandhandlers/AdminAdmin.java
  646. index 25ab0dc..6829ba3 100644
  647. --- java/net/sf/l2j/gameserver/handler/admincommandhandlers/AdminAdmin.java
  648. +++ java/net/sf/l2j/gameserver/handler/admincommandhandlers/AdminAdmin.java
  649. @@ -39,6 +39,9 @@
  650.  import net.sf.l2j.gameserver.network.SystemMessageId;
  651.  import net.sf.l2j.gameserver.network.serverpackets.NpcHtmlMessage;
  652.  
  653. +
  654. +import Base.Combination.XML.CombinationItemsData;
  655. +import Base.Dolls.DollsData;
  656.  import phantom.PhantomNameManager;
  657.  import phantom.PhantomTitleManager;
  658.  import phantom.PhantomTownAnao;
  659. @@ -220,6 +223,18 @@
  660.                         CrestCache.getInstance().reload();
  661.                         activeChar.sendMessage("Crests have been reloaded.");
  662.                     }
  663. +                  
  664. +                   else if (type.startsWith("combine"))
  665. +                   {
  666. +                       CombinationItemsData.getInstance().reload();
  667. +                       activeChar.sendMessage("Combine have been reloaded.");
  668. +                   }
  669. +                  
  670. +                   else if (type.startsWith("dolls"))
  671. +                   {
  672. +                       DollsData.getInstance().reload();
  673. +                       activeChar.sendMessage("Dolls have been reloaded.");
  674. +                   }
  675.                     else if (type.startsWith("cw"))
  676.                     {
  677.                         CursedWeaponsManager.getInstance().reload();
  678. diff --git java/net/sf/l2j/gameserver/model/actor/instance/CombineItem.java java/net/sf/l2j/gameserver/model/actor/instance/CombineItem.java
  679. new file mode 100644
  680. index 0000000..d75ceb7
  681. --- /dev/null
  682. +++ java/net/sf/l2j/gameserver/model/actor/instance/CombineItem.java
  683. @@ -0,0 +1,219 @@
  684. +package net.sf.l2j.gameserver.model.actor.instance;
  685. +
  686. +import net.sf.l2j.gameserver.data.ItemTable;
  687. +import net.sf.l2j.gameserver.model.actor.Npc;
  688. +import net.sf.l2j.gameserver.model.actor.ai.CtrlIntention;
  689. +import net.sf.l2j.gameserver.model.actor.template.NpcTemplate;
  690. +import net.sf.l2j.gameserver.model.item.instance.ItemInstance;
  691. +import net.sf.l2j.gameserver.network.serverpackets.ActionFailed;
  692. +import net.sf.l2j.gameserver.network.serverpackets.MoveToPawn;
  693. +import net.sf.l2j.gameserver.network.serverpackets.MyTargetSelected;
  694. +import net.sf.l2j.gameserver.network.serverpackets.NpcHtmlMessage;
  695. +import net.sf.l2j.gameserver.network.serverpackets.ValidateLocation;
  696. +
  697. +import Base.Combination.CombinationItem;
  698. +import Base.Combination.CombinationItemReward;
  699. +import Base.Combination.CombinationItemType;
  700. +import Base.Combination.XML.CombinationItemsData;
  701. +
  702. +import java.util.Set;
  703. +
  704. +public class CombineItem extends Npc {
  705. +    private CombinationItemsData combinationItemsData;
  706. +
  707. +    public CombineItem(int objectId, NpcTemplate template) {
  708. +        super(objectId, template);
  709. +        combinationItemsData = CombinationItemsData.getInstance();
  710. +    }
  711. +
  712. +    @Override
  713. +    public void onAction(Player player) {
  714. +        if (this != player.getTarget()) {
  715. +            player.setTarget(this);
  716. +            player.sendPacket(new MyTargetSelected(getObjectId(), 0));
  717. +            player.sendPacket(new ValidateLocation(this));
  718. +        } else {
  719. +            if (!canInteract(player)) {
  720. +                player.getAI().setIntention(CtrlIntention.INTERACT, this);
  721. +            } else {
  722. +                player.sendPacket(new MoveToPawn(player, this, Npc.INTERACTION_DISTANCE));
  723. +
  724. +                if (hasRandomAnimation()) {
  725. +                    onRandomAnimation(1);
  726. +                }
  727. +
  728. +                showCombineWindow(player);
  729. +
  730. +                player.sendPacket(ActionFailed.STATIC_PACKET);
  731. +            }
  732. +        }
  733. +    }
  734. +
  735. +    @Override
  736. +    public void onBypassFeedback(Player player, String command) {
  737. +        if (command.startsWith("combine")) {
  738. +            String[] params = command.split(" ");
  739. +            if (params.length == 3) {
  740. +                int itemOneId = Integer.parseInt(params[1]);
  741. +                int itemTwoId = Integer.parseInt(params[2]);
  742. +
  743. +                CombinationItem combination = combinationItemsData.getItems().stream()
  744. +                        .filter(item -> item.getItemOne() == itemOneId && item.getItemTwo() == itemTwoId)
  745. +                        .findFirst()
  746. +                        .orElse(null);
  747. +
  748. +                if (combination != null) {
  749. +                    Set<ItemInstance> playerItems = player.getInventory().getItems();
  750. +
  751. +                    boolean hasItemOne = playerItems.stream().anyMatch(item -> item.getItemId() == itemOneId);
  752. +                    boolean hasItemTwo = playerItems.stream().anyMatch(item -> item.getItemId() == itemTwoId);
  753. +
  754. +                    if (hasItemOne && hasItemTwo && player.getAdena() >= combination.getCommission()) {
  755. +                        // Verificar si la combinación tiene éxito según la probabilidad
  756. +                        double chance = Math.random() * 100; // Generar un número aleatorio entre 0 y 100
  757. +                        if (chance <= combination.getChance()) {
  758. +                            // La combinación tuvo éxito
  759. +                            // Quitar los items y la comisión del jugador
  760. +                            player.destroyItemByItemId("CombineItem", itemOneId, 1, null, true);
  761. +                            player.destroyItemByItemId("CombineItem", itemTwoId, 1, null, true);
  762. +                            player.reduceAdena("CombineItem", combination.getCommission(), this, true);
  763. +
  764. +                         // Otorgar las recompensas correspondientes al jugador
  765. +                            CombinationItemReward successReward = combination.getReward(CombinationItemType.ON_SUCCESS);
  766. +                            
  767. +                            if (successReward != null) {
  768. +                                // Otorgar la recompensa por éxito
  769. +                                int successRewardItemId = successReward.getId();
  770. +                                int successRewardCount = successReward.getCount();
  771. +                                
  772. +                                player.addItem(command, successRewardItemId, successRewardCount, player, true);
  773. +                                // Implementa la lógica para dar el item de éxito al jugador
  774. +
  775. +
  776. +                                // Implementa la lógica para dar el item de fallo al jugador
  777. +                            }
  778. +
  779. +
  780. +                            // Mostrar mensaje de éxito al jugador
  781. +                            player.sendMessage("¡La combinación fue exitosa!");
  782. +
  783. +                        } else {
  784. +                            // La combinación falló
  785. +                            // Quitar la comisión del jugador
  786. +                            
  787. +                            player.destroyItemByItemId("CombineItem", itemOneId, 1, null, true);
  788. +                            player.destroyItemByItemId("CombineItem", itemTwoId, 1, null, true);
  789. +                           player.reduceAdena("CombineItem", combination.getCommission(), this, true);
  790. +
  791. +                            // Mostrar mensaje de fallo al jugador
  792. +                            player.sendMessage("¡La combinación falló!");
  793. +
  794. +                            // Otorgar las recompensas correspondientes al jugador por fallo
  795. +                            CombinationItemReward failureReward = combination.getReward(CombinationItemType.ON_FAILURE);
  796. +                            if (failureReward != null) {
  797. +                        
  798. +                                int failureRewardItemId = failureReward.getId();
  799. +                                int failureRewardCount = failureReward.getCount();
  800. +                                player.addItem(command, failureRewardItemId, failureRewardCount, player, true);
  801. +                            }
  802. +                        }
  803. +                    }
  804. +
  805. +                }
  806. +
  807. +            }
  808. +        } else {
  809. +            super.onBypassFeedback(player, command);
  810. +        }
  811. +    }
  812. +
  813. +    private void showCombineWindow(Player player) {
  814. +        StringBuilder html = new StringBuilder();
  815. +        html.append("<html><body>");
  816. +        html.append("<center>Bienvenido a Combine System!</center>");
  817. +        html.append("<br>");
  818. +        html.append("<center>Podrás combinar 2 items para obtener un nivel superior.</center>");
  819. +        html.append("<br>");
  820. +        html.append("<center>Les deseo mucha suerte</center>");
  821. +        html.append("<br>");
  822. +        html.append("<br>");
  823. +
  824. +        Set<ItemInstance> playerItems = player.getInventory().getItems();
  825. +        int combinationCount = 0; // Contador de combinaciones mostradas
  826. +        for (CombinationItem combination : combinationItemsData.getItems()) {
  827. +            int itemOne = combination.getItemOne();
  828. +            int itemTwo = combination.getItemTwo();
  829. +            
  830. +            String itemOneName = ItemTable.getInstance().getTemplate(itemOne).getName();
  831. +            String itemTwoName = ItemTable.getInstance().getTemplate(itemTwo).getName();
  832. +
  833. +            boolean isSameItem = itemOne == itemTwo;
  834. +            boolean hasItems = false;
  835. +
  836. +            if (isSameItem) {
  837. +                long countItems = playerItems.stream()
  838. +                        .filter(item -> item != null && item.getItemId() == itemOne)
  839. +                        .count();
  840. +                hasItems = countItems >= 2;
  841. +            } else {
  842. +                boolean hasItemOne = playerItems.stream()
  843. +                        .anyMatch(item -> item != null && item.getItemId() == itemOne);
  844. +                boolean hasItemTwo = playerItems.stream()
  845. +                        .anyMatch(item -> item != null && item.getItemId() == itemTwo);
  846. +                hasItems = hasItemOne && hasItemTwo;
  847. +            }
  848. +
  849. +            if (hasItems || (isSameItem && playerItems.stream().anyMatch(item -> item != null && item.getItemId() == itemOne && item.getCount() >= 2))) {
  850. +               html.append("<img src=\"L2UI.SquareGray\" width=295 height=1>");
  851. +               html.append("<center>");
  852. +               html.append("<table>");
  853. +               html.append("<tr>");
  854. +
  855. +               // Combinación de iconos
  856. +               html.append("<td><button action=\"bypass -h npc_").append(getObjectId()).append("_combine ")
  857. +                   .append(itemOne).append(" ").append(itemTwo).append("\" width=32 height=32 back=\"icon.skill0000\" fore=\"")
  858. +                   .append(combination.getIconOne()).append("\"></td>");
  859. +
  860. +               html.append("<td width=30></td>");
  861. +
  862. +               html.append("<td><button action=\"bypass -h npc_").append(getObjectId()).append("_combine ")
  863. +                   .append(itemOne).append(" ").append(itemTwo).append("\" width=32 height=32 back=\"icon.skill0000\" fore=\"")
  864. +                   .append(combination.getIconTwo()).append("\"></td>");
  865. +
  866. +               html.append("</tr>");
  867. +               html.append("</table>");
  868. +               html.append("</center>");
  869. +               html.append("<img src=\"L2UI.SquareGray\" width=295 height=1>");
  870. +               html.append("<br>");
  871. +               html.append("<br>");
  872. +               html.append("<br>");
  873. +
  874. +               combinationCount++; // Incrementar el contador de combinaciones mostradas
  875. +
  876. +                if (combinationCount >= 5) {
  877. +                    break; // Detener el bucle si se han mostrado 5 combinaciones
  878. +                }
  879. +
  880. +            }
  881. +        }
  882. +
  883. +        html.append("<br>");
  884. +        html.append("<br>");
  885. +        html.append("</body></html>");
  886. +
  887. +        if (html.length() == 0) {
  888. +            player.sendMessage("No tienes items para combinar.");
  889. +        } else {
  890. +            showHtmlWindow(player, html.toString());
  891. +        }
  892. +    }
  893. +
  894. +
  895. +
  896. +    private void showHtmlWindow(Player player, String htmlContent) {
  897. +        NpcHtmlMessage html = new NpcHtmlMessage(getObjectId());
  898. +        html.setHtml(htmlContent);
  899. +
  900. +        player.sendPacket(html);
  901. +    }
  902. +}
  903. diff --git java/net/sf/l2j/gameserver/model/actor/instance/Player.java java/net/sf/l2j/gameserver/model/actor/instance/Player.java
  904. index 74f78d8..b200372 100644
  905. --- java/net/sf/l2j/gameserver/model/actor/instance/Player.java
  906. +++ java/net/sf/l2j/gameserver/model/actor/instance/Player.java
  907. @@ -266,6 +266,7 @@
  908.  import net.sf.l2j.gameserver.skills.l2skills.L2SkillSiegeFlag;
  909.  import net.sf.l2j.gameserver.skills.l2skills.L2SkillSummon;
  910.  import net.sf.l2j.gameserver.taskmanager.AttackStanceTaskManager;
  911. +//import net.sf.l2j.gameserver.taskmanager.DollsTaskManager;
  912.  import net.sf.l2j.gameserver.taskmanager.GameTimeTaskManager;
  913.  import net.sf.l2j.gameserver.taskmanager.ItemsOnGroundTaskManager;
  914.  import net.sf.l2j.gameserver.taskmanager.PvpFlagTaskManager;
  915. @@ -280,6 +281,8 @@
  916.  import net.sf.l2j.gameserver.util.variables.sub.PlayerVariables;
  917.  import net.sf.l2j.util.CloseUtil;
  918.  
  919. +import Base.Dolls.Doll;
  920. +import Base.Dolls.DollsData;
  921.  import phantom.PhantomTownMage;
  922.  import phantom.Phantom_Archers;
  923.  import phantom.Phantom_Attack;
  924. @@ -2881,6 +2884,39 @@
  925.        
  926.         ItemInstance item = _inventory.getItemByItemId(itemId);
  927.        
  928. +      
  929. +
  930. +       DollsData dollsData = DollsData.getInstance();
  931. +       Map<Integer, Doll> dolls = dollsData.getDolls();
  932. +      
  933. +       for (Doll doll : dolls.values())
  934. +       {
  935. +           if (item.getItemId() == doll.getId())
  936. +           {
  937. +               int skillId = doll.getSkillId();
  938. +               int skillLvl = doll.getSkillLvl();
  939. +              
  940. +               L2Skill skill = SkillTable.getInstance().getInfo(skillId, skillLvl);
  941. +               if (skill != null)
  942. +               {
  943. +                   removeSkill(skill.getId(), true);
  944. +                   sendSkillList();
  945. +               }
  946. +           }
  947. +       }
  948. +
  949. +
  950. +      
  951. +      
  952. +      
  953. +      
  954. +      
  955. +
  956. +      
  957. +
  958. +
  959. +      
  960. +      
  961.         if (item == null || item.getCount() < count || _inventory.destroyItemByItemId(process, itemId, count, this, reference) == null)
  962.         {
  963.             if (sendMessage)
  964. @@ -8632,6 +8668,12 @@
  965.         }
  966.     }
  967.    
  968. +  
  969. +  
  970. +  
  971. +  
  972. +  
  973. +  
  974.     /**
  975.      * Cancel autoshot use for shot itemId
  976.      * @param itemId int id to disable
  977. @@ -8663,6 +8705,18 @@
  978.         _activeSoulShots.clear();
  979.     }
  980.    
  981. +  
  982. +  
  983. +  
  984. +  
  985. +  
  986. +  
  987. +  
  988. +  
  989. +  
  990. +  
  991. +  
  992. +  
  993.     class LookingForFishTask implements Runnable
  994.     {
  995.         boolean _isNoob, _isUpperGrade;
  996. @@ -9493,6 +9547,13 @@
  997.     public void removeItens()
  998.     {
  999.        
  1000. +      
  1001. +      
  1002. +      
  1003. +      
  1004. +      
  1005. +      
  1006. +      
  1007.         // Remove Item TATO
  1008.         if (Config.REMOVE_CHEST)
  1009.         {
  1010. @@ -9833,25 +9894,39 @@
  1011.             if (Config.ALT_RESTORE_EFFECTS_ON_SUBCLASS_CHANGE)
  1012.                 restoreEffects();
  1013.            
  1014. -           // Reload Inventory with runa items
  1015. -           for (ItemInstance item : getInventory().getItems())
  1016. -           {
  1017. -               if (item == null)
  1018. -                   continue;
  1019. -              
  1020. -               for (Entry<Integer, Integer> itemSkill : Config.LIST_RUNE_ITEMS.entrySet())
  1021. -               {
  1022. -                   if (item.getItemId() == itemSkill.getKey())
  1023. -                   {
  1024. -                       L2Skill skill = SkillTable.getInstance().getInfo(itemSkill.getValue(), 1);
  1025. -                       if (skill != null)
  1026. -                       {
  1027. -                           addSkill(skill, false);
  1028. -                           sendSkillList();
  1029. -                       }
  1030. -                   }
  1031. -               }
  1032. +          
  1033. +           DollsData dollsData = DollsData.getInstance();
  1034. +           Map<Integer, Doll> dolls = dollsData.getDolls();
  1035. +
  1036. +           for (ItemInstance item : getInventory().getItems()) {
  1037. +               if (item == null)
  1038. +                   continue;
  1039. +
  1040. +               Doll doll = dolls.get(item.getItemId());
  1041. +               if (doll != null) {
  1042. +                   int skillId = doll.getSkillId();
  1043. +                   int skillLvl = doll.getSkillLvl();
  1044. +
  1045. +                   boolean hasHigherLevelSkill = false;
  1046. +
  1047. +                   // Verificar si el jugador ya tiene un skill con nivel más alto
  1048. +                   for (L2Skill existingSkill : getSkills().values()) {
  1049. +                       if (existingSkill.getId() == skillId && existingSkill.getLevel() > skillLvl) {
  1050. +                           hasHigherLevelSkill = true;
  1051. +                           break;
  1052. +                       }
  1053. +                   }
  1054. +
  1055. +                   if (!hasHigherLevelSkill) {
  1056. +                       L2Skill skill = SkillTable.getInstance().getInfo(skillId, skillLvl);
  1057. +                       if (skill != null) {
  1058. +                           addSkill(skill);
  1059. +                           sendSkillList();
  1060. +                       }
  1061. +                   }
  1062. +               }
  1063.             }
  1064. +
  1065.            
  1066.             updateEffectIcons();
  1067.             sendPacket(new EtcStatusUpdate(this));
  1068. diff --git java/net/sf/l2j/gameserver/model/itemcontainer/PcInventory.java java/net/sf/l2j/gameserver/model/itemcontainer/PcInventory.java
  1069. index fff736e..3359dcf 100644
  1070. --- java/net/sf/l2j/gameserver/model/itemcontainer/PcInventory.java
  1071. +++ java/net/sf/l2j/gameserver/model/itemcontainer/PcInventory.java
  1072. @@ -5,6 +5,7 @@
  1073.  import java.sql.ResultSet;
  1074.  import java.util.ArrayList;
  1075.  import java.util.List;
  1076. +import java.util.Map;
  1077.  import java.util.Map.Entry;
  1078.  import java.util.logging.Level;
  1079.  import java.util.stream.Collectors;
  1080. @@ -25,8 +26,12 @@
  1081.  import net.sf.l2j.gameserver.model.tradelist.TradeList;
  1082.  import net.sf.l2j.gameserver.network.serverpackets.InventoryUpdate;
  1083.  import net.sf.l2j.gameserver.network.serverpackets.StatusUpdate;
  1084. +//import net.sf.l2j.gameserver.taskmanager.DollsTaskManager;
  1085.  import net.sf.l2j.gameserver.taskmanager.ShadowItemTaskManager;
  1086.  
  1087. +import Base.Dolls.Doll;
  1088. +import Base.Dolls.DollsData;
  1089. +
  1090.  public class PcInventory extends Inventory
  1091.  {
  1092.     public static final int ADENA_ID = 57;
  1093. @@ -45,6 +50,7 @@
  1094.         addPaperdollListener(BowRodListener.getInstance());
  1095.         addPaperdollListener(ItemPassiveSkillsListener.getInstance());
  1096.         addPaperdollListener(ShadowItemTaskManager.getInstance());
  1097. +      
  1098.     }
  1099.    
  1100.     @Override
  1101. @@ -402,17 +408,39 @@
  1102.         else if (item.getItemId() == ANCIENT_ADENA_ID && !item.equals(_ancientAdena))
  1103.             _ancientAdena = item;
  1104.        
  1105. -       for (Entry<Integer, Integer> itemSkill : Config.LIST_RUNE_ITEMS.entrySet())
  1106. -       {
  1107. -           if (item.getItemId() == itemSkill.getKey())
  1108. -           {
  1109. -               L2Skill skill = SkillTable.getInstance().getInfo(itemSkill.getValue(), 1); // 1 REFERENCIA AO LEVEL
  1110. -               if (skill != null)
  1111. -               {
  1112. -                   actor.addSkill(skill, false);
  1113. -                   actor.sendSkillList();
  1114. -               }
  1115. -           }
  1116. +       // Después de que un jugador reciba un item de la lista de runas
  1117. +   //  DollsTaskManager.getInstance().addDollItem(actor, item);
  1118. +
  1119. +      
  1120. +       DollsData dollsData = DollsData.getInstance();
  1121. +       for (ItemInstance item2 : actor.getInventory().getItems()) {
  1122. +           if (item2 == null) {
  1123. +               continue;
  1124. +           }
  1125. +
  1126. +           Doll doll = dollsData.getDollById(item.getItemId());
  1127. +           if (doll != null) {
  1128. +               int skillId = doll.getSkillId();
  1129. +               int skillLvl = doll.getSkillLvl();
  1130. +              
  1131. +               boolean hasHigherLevelSkill = false;
  1132. +              
  1133. +               // Comprobar si el jugador ya tiene la skill con un nivel más alto
  1134. +               for (L2Skill playerSkill : actor.getSkills().values()) {
  1135. +                   if (playerSkill.getId() == skillId && playerSkill.getLevel() > skillLvl) {
  1136. +                       hasHigherLevelSkill = true;
  1137. +                       break;
  1138. +                   }
  1139. +               }
  1140. +              
  1141. +               if (!hasHigherLevelSkill) {
  1142. +                   L2Skill skill = SkillTable.getInstance().getInfo(skillId, skillLvl);
  1143. +                   if (skill != null) {
  1144. +                       actor.addSkill(skill);
  1145. +                       actor.sendSkillList();
  1146. +                   }
  1147. +               }
  1148. +           }
  1149.         }
  1150.        
  1151.         return item;
  1152. @@ -450,20 +478,76 @@
  1153.             StatusUpdate su = new StatusUpdate(actor);
  1154.             su.addAttribute(StatusUpdate.CUR_LOAD, actor.getCurrentLoad());
  1155.             actor.sendPacket(su);
  1156. -       }
  1157. +           DollsData dollsData = DollsData.getInstance();
  1158. +           for (ItemInstance item2 : actor.getInventory().getItems()) {
  1159. +               if (item2 == null) {
  1160. +                   continue;
  1161. +               }
  1162.  
  1163. -       for (Entry<Integer, Integer> itemSkill : Config.LIST_RUNE_ITEMS.entrySet())
  1164. -       {
  1165. -           if (item.getItemId() == itemSkill.getKey())
  1166. -           {
  1167. -               L2Skill skill = SkillTable.getInstance().getInfo(itemSkill.getValue(), 1);
  1168. -               if (skill != null)
  1169. -               {
  1170. -                   actor.addSkill(skill, false);
  1171. -                   actor.sendSkillList();
  1172. -               }
  1173. +               Doll doll = dollsData.getDollById(item2.getItemId());
  1174. +               if (doll != null) {
  1175. +                   int skillId = doll.getSkillId();
  1176. +                   int skillLvl = doll.getSkillLvl();
  1177. +
  1178. +                   boolean hasHigherLevelSkill = false;
  1179. +
  1180. +                   // Comprobar si el jugador ya tiene la skill con un nivel más alto
  1181. +                   for (L2Skill playerSkill : actor.getSkills().values()) {
  1182. +                       if (playerSkill.getId() == skillId && playerSkill.getLevel() > skillLvl) {
  1183. +                           hasHigherLevelSkill = true;
  1184. +                           break;
  1185. +                       }
  1186. +                   }
  1187. +
  1188. +                   if (!hasHigherLevelSkill) {
  1189. +                       L2Skill skill = SkillTable.getInstance().getInfo(skillId, skillLvl);
  1190. +                       if (skill != null) {
  1191. +                           if (actor.getSkillLevel(skillId) != skillLvl) {
  1192. +                               actor.removeSkill(skill);
  1193. +                               actor.sendSkillList();
  1194. +                           }
  1195. +                       }
  1196. +                   }
  1197. +               }
  1198.             }
  1199. +
  1200. +           // Comprobar si el actor tiene otros ítems con habilidades y otorgar las habilidades correspondientes
  1201. +           for (ItemInstance item3 : actor.getInventory().getItems()) {
  1202. +               Doll doll = dollsData.getDollById(item3.getItemId());
  1203. +               if (doll != null) {
  1204. +                   int skillId = doll.getSkillId();
  1205. +                   int skillLvl = doll.getSkillLvl();
  1206. +
  1207. +                   boolean hasHigherLevelSkill = false;
  1208. +
  1209. +                   // Verificar si el jugador ya tiene un skill con nivel más alto
  1210. +                   for (L2Skill existingSkill : actor.getSkills().values()) {
  1211. +                       if (existingSkill.getId() == skillId && existingSkill.getLevel() > skillLvl) {
  1212. +                           hasHigherLevelSkill = true;
  1213. +                           break;
  1214. +                       }
  1215. +                   }
  1216. +
  1217. +                   if (!hasHigherLevelSkill) {
  1218. +                       L2Skill skill = SkillTable.getInstance().getInfo(skillId, skillLvl);
  1219. +                       if (skill != null) {
  1220. +                           if (actor.getSkillLevel(skillId) != skillLvl) {
  1221. +                               actor.addSkill(skill);
  1222. +                               actor.sendSkillList();
  1223. +                           }
  1224. +                       }
  1225. +                   }
  1226. +               }
  1227. +           }
  1228. +
  1229. +
  1230. +          
  1231. +          
  1232.         }
  1233. +       // Después de que un jugador reciba un item de la lista de runas
  1234. +   //  DollsTaskManager.getInstance().addDollItem(actor, item);
  1235. +      
  1236. +
  1237.        
  1238.         return item;
  1239.     }
  1240. @@ -482,6 +566,68 @@
  1241.     {
  1242.         ItemInstance item = super.transferItem(process, objectId, count, target, actor, reference);
  1243.        
  1244. +      
  1245. +       DollsData dollsData = DollsData.getInstance();
  1246. +       Map<Integer, Doll> dolls = dollsData.getDolls();
  1247. +
  1248. +       boolean hasOtherItemsWithSkills = false; // Variable para indicar si el jugador tiene otros ítems con habilidades
  1249. +
  1250. +       for (Doll doll : dolls.values()) {
  1251. +           if (item.getItemId() == doll.getId()) {
  1252. +               int skillId = doll.getSkillId();
  1253. +               int skillLvl = doll.getSkillLvl();
  1254. +
  1255. +               L2Skill skill = SkillTable.getInstance().getInfo(skillId, skillLvl);
  1256. +               if (skill != null) {
  1257. +                   if (actor.getSkillLevel(skillId) == skillLvl) {
  1258. +                       actor.removeSkill(skill.getId(), true);
  1259. +                       actor.sendSkillList();
  1260. +                   }
  1261. +               }
  1262. +           }
  1263. +       }
  1264. +
  1265. +       // Comprobar si el jugador tiene otros ítems con habilidades y otorgar las habilidades correspondientes
  1266. +       for (ItemInstance item2 : actor.getInventory().getItems()) {
  1267. +           for (Doll doll : dolls.values()) {
  1268. +               if (item2.getItemId() == doll.getId()) {
  1269. +                   int skillId = doll.getSkillId();
  1270. +                   int skillLvl = doll.getSkillLvl();
  1271. +
  1272. +                   L2Skill skill = SkillTable.getInstance().getInfo(skillId, skillLvl);
  1273. +                   if (skill != null) {
  1274. +                       if (actor.getSkillLevel(skillId) != skillLvl) {
  1275. +                           actor.removeSkill(skill.getId(), false);
  1276. +                           actor.addSkill(skill, false);
  1277. +                           actor.sendSkillList();
  1278. +                       }
  1279. +                       hasOtherItemsWithSkills = true; // El jugador tiene otros ítems con habilidades
  1280. +                   }
  1281. +               }
  1282. +           }
  1283. +       }
  1284. +
  1285. +       // Si el jugador ya no tiene ningún otro item con habilidades, eliminar la habilidad correspondiente
  1286. +       if (!hasOtherItemsWithSkills) {
  1287. +           for (Doll doll : dolls.values()) {
  1288. +               if (item.getItemId() == doll.getId()) {
  1289. +                   int skillId = doll.getSkillId();
  1290. +                   int skillLvl = doll.getSkillLvl();
  1291. +
  1292. +                   L2Skill skill = SkillTable.getInstance().getInfo(skillId, skillLvl);
  1293. +                   if (skill != null) {
  1294. +                       if (actor.getSkillLevel(skillId) == skillLvl) {
  1295. +                           actor.removeSkill(skill.getId(), false);
  1296. +                           actor.sendSkillList();
  1297. +                       }
  1298. +                   }
  1299. +               }
  1300. +           }
  1301. +       }
  1302. +      
  1303. +      
  1304. +      
  1305. +      
  1306.         if (_adena != null && (_adena.getCount() <= 0 || _adena.getOwnerId() != getOwnerId()))
  1307.             _adena = null;
  1308.        
  1309. @@ -518,6 +664,69 @@
  1310.     {
  1311.         item = super.destroyItem(process, item, count, actor, reference);
  1312.        
  1313. +      
  1314. +      
  1315. +       DollsData dollsData = DollsData.getInstance();
  1316. +       Map<Integer, Doll> dolls = dollsData.getDolls();
  1317. +
  1318. +       boolean hasOtherItemsWithSkills = false; // Variable para indicar si el jugador tiene otros ítems con habilidades
  1319. +
  1320. +       for (Doll doll : dolls.values()) {
  1321. +           if (item.getItemId() == doll.getId()) {
  1322. +               int skillId = doll.getSkillId();
  1323. +               int skillLvl = doll.getSkillLvl();
  1324. +
  1325. +               L2Skill skill = SkillTable.getInstance().getInfo(skillId, skillLvl);
  1326. +               if (skill != null) {
  1327. +                   if (actor.getSkillLevel(skillId) == skillLvl) {
  1328. +                       actor.removeSkill(skill.getId(), true);
  1329. +                       actor.sendSkillList();
  1330. +                   }
  1331. +               }
  1332. +           }
  1333. +       }
  1334. +
  1335. +       // Comprobar si el jugador tiene otros ítems con habilidades y otorgar las habilidades correspondientes
  1336. +       for (ItemInstance item2 : actor.getInventory().getItems()) {
  1337. +           for (Doll doll : dolls.values()) {
  1338. +               if (item2.getItemId() == doll.getId()) {
  1339. +                   int skillId = doll.getSkillId();
  1340. +                   int skillLvl = doll.getSkillLvl();
  1341. +
  1342. +                   L2Skill skill = SkillTable.getInstance().getInfo(skillId, skillLvl);
  1343. +                   if (skill != null) {
  1344. +                       if (actor.getSkillLevel(skillId) != skillLvl) {
  1345. +                           actor.removeSkill(skill.getId(), false);
  1346. +                           actor.addSkill(skill, false);
  1347. +                           actor.sendSkillList();
  1348. +                       }
  1349. +                       hasOtherItemsWithSkills = true; // El jugador tiene otros ítems con habilidades
  1350. +                   }
  1351. +               }
  1352. +           }
  1353. +       }
  1354. +
  1355. +       // Si el jugador ya no tiene ningún otro item con habilidades, eliminar la habilidad correspondiente
  1356. +       if (!hasOtherItemsWithSkills) {
  1357. +           for (Doll doll : dolls.values()) {
  1358. +               if (item.getItemId() == doll.getId()) {
  1359. +                   int skillId = doll.getSkillId();
  1360. +                   int skillLvl = doll.getSkillLvl();
  1361. +
  1362. +                   L2Skill skill = SkillTable.getInstance().getInfo(skillId, skillLvl);
  1363. +                   if (skill != null) {
  1364. +                       if (actor.getSkillLevel(skillId) == skillLvl) {
  1365. +                           actor.removeSkill(skill.getId(), false);
  1366. +                           actor.sendSkillList();
  1367. +                       }
  1368. +                   }
  1369. +               }
  1370. +           }
  1371. +       }
  1372. +      
  1373. +      
  1374. +      
  1375. +      
  1376.         if (_adena != null && _adena.getCount() <= 0)
  1377.             _adena = null;
  1378.        
  1379. @@ -540,9 +749,79 @@
  1380.     public ItemInstance destroyItem(String process, int objectId, int count, Player actor, WorldObject reference)
  1381.     {
  1382.         ItemInstance item = getItemByObjectId(objectId);
  1383. +      
  1384. +       DollsData dollsData = DollsData.getInstance();
  1385. +       Map<Integer, Doll> dolls = dollsData.getDolls();
  1386. +
  1387. +       boolean hasOtherItemsWithSkills = false; // Variable para indicar si el jugador tiene otros ítems con habilidades
  1388. +
  1389. +       for (Doll doll : dolls.values()) {
  1390. +           if (item.getItemId() == doll.getId()) {
  1391. +               int skillId = doll.getSkillId();
  1392. +               int skillLvl = doll.getSkillLvl();
  1393. +
  1394. +               L2Skill skill = SkillTable.getInstance().getInfo(skillId, skillLvl);
  1395. +               if (skill != null) {
  1396. +                   if (actor.getSkillLevel(skillId) == skillLvl) {
  1397. +                       actor.removeSkill(skill.getId(), true);
  1398. +                       actor.sendSkillList();
  1399. +                   }
  1400. +               }
  1401. +           }
  1402. +       }
  1403. +
  1404. +       // Comprobar si el jugador tiene otros ítems con habilidades y otorgar las habilidades correspondientes
  1405. +       for (ItemInstance item2 : actor.getInventory().getItems()) {
  1406. +           for (Doll doll : dolls.values()) {
  1407. +               if (item2.getItemId() == doll.getId()) {
  1408. +                   int skillId = doll.getSkillId();
  1409. +                   int skillLvl = doll.getSkillLvl();
  1410. +
  1411. +                   L2Skill skill = SkillTable.getInstance().getInfo(skillId, skillLvl);
  1412. +                   if (skill != null) {
  1413. +                       if (actor.getSkillLevel(skillId) != skillLvl) {
  1414. +                           actor.removeSkill(skill.getId(), false);
  1415. +                           actor.addSkill(skill, false);
  1416. +                           actor.sendSkillList();
  1417. +                       }
  1418. +                       hasOtherItemsWithSkills = true; // El jugador tiene otros ítems con habilidades
  1419. +                   }
  1420. +               }
  1421. +           }
  1422. +       }
  1423. +
  1424. +       // Si el jugador ya no tiene ningún otro item con habilidades, eliminar la habilidad correspondiente
  1425. +       if (!hasOtherItemsWithSkills) {
  1426. +           for (Doll doll : dolls.values()) {
  1427. +               if (item.getItemId() == doll.getId()) {
  1428. +                   int skillId = doll.getSkillId();
  1429. +                   int skillLvl = doll.getSkillLvl();
  1430. +
  1431. +                   L2Skill skill = SkillTable.getInstance().getInfo(skillId, skillLvl);
  1432. +                   if (skill != null) {
  1433. +                       if (actor.getSkillLevel(skillId) == skillLvl) {
  1434. +                           actor.removeSkill(skill.getId(), false);
  1435. +                           actor.sendSkillList();
  1436. +                       }
  1437. +                   }
  1438. +               }
  1439. +           }
  1440. +       }
  1441. +      
  1442.         if (item == null)
  1443.             return null;
  1444.        
  1445. +      
  1446. +      
  1447. +      
  1448. +  
  1449. +      
  1450. +      
  1451. +      
  1452. +      
  1453. +      
  1454. +      
  1455. +      
  1456.         return this.destroyItem(process, item, count, actor, reference);
  1457.     }
  1458.    
  1459. @@ -562,6 +841,68 @@
  1460.         if (item == null)
  1461.             return null;
  1462.        
  1463. +      
  1464. +       DollsData dollsData = DollsData.getInstance();
  1465. +       Map<Integer, Doll> dolls = dollsData.getDolls();
  1466. +
  1467. +       boolean hasOtherItemsWithSkills = false; // Variable para indicar si el jugador tiene otros ítems con habilidades
  1468. +
  1469. +       for (Doll doll : dolls.values()) {
  1470. +           if (item.getItemId() == doll.getId()) {
  1471. +               int skillId = doll.getSkillId();
  1472. +               int skillLvl = doll.getSkillLvl();
  1473. +
  1474. +               L2Skill skill = SkillTable.getInstance().getInfo(skillId, skillLvl);
  1475. +               if (skill != null) {
  1476. +                   if (actor.getSkillLevel(skillId) == skillLvl) {
  1477. +                       actor.removeSkill(skill.getId(), true);
  1478. +                       actor.sendSkillList();
  1479. +                   }
  1480. +               }
  1481. +           }
  1482. +       }
  1483. +
  1484. +       // Comprobar si el jugador tiene otros ítems con habilidades y otorgar las habilidades correspondientes
  1485. +       for (ItemInstance item2 : actor.getInventory().getItems()) {
  1486. +           for (Doll doll : dolls.values()) {
  1487. +               if (item2.getItemId() == doll.getId()) {
  1488. +                   int skillId = doll.getSkillId();
  1489. +                   int skillLvl = doll.getSkillLvl();
  1490. +
  1491. +                   L2Skill skill = SkillTable.getInstance().getInfo(skillId, skillLvl);
  1492. +                   if (skill != null) {
  1493. +                       if (actor.getSkillLevel(skillId) != skillLvl) {
  1494. +                           actor.removeSkill(skill.getId(), false);
  1495. +                           actor.addSkill(skill, false);
  1496. +                           actor.sendSkillList();
  1497. +                       }
  1498. +                       hasOtherItemsWithSkills = true; // El jugador tiene otros ítems con habilidades
  1499. +                   }
  1500. +               }
  1501. +           }
  1502. +       }
  1503. +
  1504. +       // Si el jugador ya no tiene ningún otro item con habilidades, eliminar la habilidad correspondiente
  1505. +       if (!hasOtherItemsWithSkills) {
  1506. +           for (Doll doll : dolls.values()) {
  1507. +               if (item.getItemId() == doll.getId()) {
  1508. +                   int skillId = doll.getSkillId();
  1509. +                   int skillLvl = doll.getSkillLvl();
  1510. +
  1511. +                   L2Skill skill = SkillTable.getInstance().getInfo(skillId, skillLvl);
  1512. +                   if (skill != null) {
  1513. +                       if (actor.getSkillLevel(skillId) == skillLvl) {
  1514. +                           actor.removeSkill(skill.getId(), false);
  1515. +                           actor.sendSkillList();
  1516. +                       }
  1517. +                   }
  1518. +               }
  1519. +           }
  1520. +       }
  1521. +      
  1522. +      
  1523. +      
  1524. +      
  1525.         return this.destroyItem(process, item, count, actor, reference);
  1526.     }
  1527.    
  1528. @@ -578,6 +919,67 @@
  1529.     {
  1530.         item = super.dropItem(process, item, actor, reference);
  1531.        
  1532. +       DollsData dollsData = DollsData.getInstance();
  1533. +       Map<Integer, Doll> dolls = dollsData.getDolls();
  1534. +
  1535. +       boolean hasOtherItemsWithSkills = false; // Variable para indicar si el jugador tiene otros ítems con habilidades
  1536. +
  1537. +       for (Doll doll : dolls.values()) {
  1538. +           if (item.getItemId() == doll.getId()) {
  1539. +               int skillId = doll.getSkillId();
  1540. +               int skillLvl = doll.getSkillLvl();
  1541. +
  1542. +               L2Skill skill = SkillTable.getInstance().getInfo(skillId, skillLvl);
  1543. +               if (skill != null) {
  1544. +                   if (actor.getSkillLevel(skillId) == skillLvl) {
  1545. +                       actor.removeSkill(skill.getId(), true);
  1546. +                       actor.sendSkillList();
  1547. +                   }
  1548. +               }
  1549. +           }
  1550. +       }
  1551. +
  1552. +       // Comprobar si el jugador tiene otros ítems con habilidades y otorgar las habilidades correspondientes
  1553. +       for (ItemInstance item2 : actor.getInventory().getItems()) {
  1554. +           for (Doll doll : dolls.values()) {
  1555. +               if (item2.getItemId() == doll.getId()) {
  1556. +                   int skillId = doll.getSkillId();
  1557. +                   int skillLvl = doll.getSkillLvl();
  1558. +
  1559. +                   L2Skill skill = SkillTable.getInstance().getInfo(skillId, skillLvl);
  1560. +                   if (skill != null) {
  1561. +                       if (actor.getSkillLevel(skillId) != skillLvl) {
  1562. +                           actor.removeSkill(skill.getId(), false);
  1563. +                           actor.addSkill(skill, false);
  1564. +                           actor.sendSkillList();
  1565. +                       }
  1566. +                       hasOtherItemsWithSkills = true; // El jugador tiene otros ítems con habilidades
  1567. +                   }
  1568. +               }
  1569. +           }
  1570. +       }
  1571. +
  1572. +       // Si el jugador ya no tiene ningún otro item con habilidades, eliminar la habilidad correspondiente
  1573. +       if (!hasOtherItemsWithSkills) {
  1574. +           for (Doll doll : dolls.values()) {
  1575. +               if (item.getItemId() == doll.getId()) {
  1576. +                   int skillId = doll.getSkillId();
  1577. +                   int skillLvl = doll.getSkillLvl();
  1578. +
  1579. +                   L2Skill skill = SkillTable.getInstance().getInfo(skillId, skillLvl);
  1580. +                   if (skill != null) {
  1581. +                       if (actor.getSkillLevel(skillId) == skillLvl) {
  1582. +                           actor.removeSkill(skill.getId(), false);
  1583. +                           actor.sendSkillList();
  1584. +                       }
  1585. +                   }
  1586. +               }
  1587. +           }
  1588. +       }
  1589. +      
  1590. +      
  1591. +      
  1592. +      
  1593.         if (_adena != null && (_adena.getCount() <= 0 || _adena.getOwnerId() != getOwnerId()))
  1594.             _adena = null;
  1595.        
  1596. @@ -601,6 +1003,66 @@
  1597.     {
  1598.         ItemInstance item = super.dropItem(process, objectId, count, actor, reference);
  1599.        
  1600. +      
  1601. +       DollsData dollsData = DollsData.getInstance();
  1602. +       Map<Integer, Doll> dolls = dollsData.getDolls();
  1603. +
  1604. +       boolean hasOtherItemsWithSkills = false; // Variable para indicar si el jugador tiene otros ítems con habilidades
  1605. +
  1606. +       for (Doll doll : dolls.values()) {
  1607. +           if (item.getItemId() == doll.getId()) {
  1608. +               int skillId = doll.getSkillId();
  1609. +               int skillLvl = doll.getSkillLvl();
  1610. +
  1611. +               L2Skill skill = SkillTable.getInstance().getInfo(skillId, skillLvl);
  1612. +               if (skill != null) {
  1613. +                   if (actor.getSkillLevel(skillId) == skillLvl) {
  1614. +                       actor.removeSkill(skill.getId(), true);
  1615. +                       actor.sendSkillList();
  1616. +                   }
  1617. +               }
  1618. +           }
  1619. +       }
  1620. +
  1621. +       // Comprobar si el jugador tiene otros ítems con habilidades y otorgar las habilidades correspondientes
  1622. +       for (ItemInstance item2 : actor.getInventory().getItems()) {
  1623. +           for (Doll doll : dolls.values()) {
  1624. +               if (item2.getItemId() == doll.getId()) {
  1625. +                   int skillId = doll.getSkillId();
  1626. +                   int skillLvl = doll.getSkillLvl();
  1627. +
  1628. +                   L2Skill skill = SkillTable.getInstance().getInfo(skillId, skillLvl);
  1629. +                   if (skill != null) {
  1630. +                       if (actor.getSkillLevel(skillId) != skillLvl) {
  1631. +                           actor.removeSkill(skill.getId(), false);
  1632. +                           actor.addSkill(skill, false);
  1633. +                           actor.sendSkillList();
  1634. +                       }
  1635. +                       hasOtherItemsWithSkills = true; // El jugador tiene otros ítems con habilidades
  1636. +                   }
  1637. +               }
  1638. +           }
  1639. +       }
  1640. +
  1641. +       // Si el jugador ya no tiene ningún otro item con habilidades, eliminar la habilidad correspondiente
  1642. +       if (!hasOtherItemsWithSkills) {
  1643. +           for (Doll doll : dolls.values()) {
  1644. +               if (item.getItemId() == doll.getId()) {
  1645. +                   int skillId = doll.getSkillId();
  1646. +                   int skillLvl = doll.getSkillLvl();
  1647. +
  1648. +                   L2Skill skill = SkillTable.getInstance().getInfo(skillId, skillLvl);
  1649. +                   if (skill != null) {
  1650. +                       if (actor.getSkillLevel(skillId) == skillLvl) {
  1651. +                           actor.removeSkill(skill.getId(), false);
  1652. +                           actor.sendSkillList();
  1653. +                       }
  1654. +                   }
  1655. +               }
  1656. +           }
  1657. +       }
  1658. +      
  1659. +      
  1660.         if (_adena != null && (_adena.getCount() <= 0 || _adena.getOwnerId() != getOwnerId()))
  1661.             _adena = null;
  1662.        
  1663. diff --git java/net/sf/l2j/gameserver/model/tradelist/TradeList.java java/net/sf/l2j/gameserver/model/tradelist/TradeList.java
  1664. index e6fafc6..d5a8786 100644
  1665. --- java/net/sf/l2j/gameserver/model/tradelist/TradeList.java
  1666. +++ java/net/sf/l2j/gameserver/model/tradelist/TradeList.java
  1667. @@ -2,6 +2,7 @@
  1668.  
  1669.  import java.util.ArrayList;
  1670.  import java.util.List;
  1671. +import java.util.Map;
  1672.  import java.util.Map.Entry;
  1673.  import java.util.Set;
  1674.  import java.util.concurrent.CopyOnWriteArrayList;
  1675. @@ -21,8 +22,12 @@
  1676.  import net.sf.l2j.gameserver.network.serverpackets.InventoryUpdate;
  1677.  import net.sf.l2j.gameserver.network.serverpackets.StatusUpdate;
  1678.  import net.sf.l2j.gameserver.network.serverpackets.SystemMessage;
  1679. +//import net.sf.l2j.gameserver.taskmanager.DollsTaskManager;
  1680.  import net.sf.l2j.gameserver.util.TradeLog;
  1681.  
  1682. +import Base.Dolls.Doll;
  1683. +import Base.Dolls.DollsData;
  1684. +
  1685.  public class TradeList
  1686.  {
  1687.     private final Player _owner;
  1688. @@ -433,33 +438,75 @@
  1689.                 else
  1690.                     partnerIU.addNewItem(newItem);
  1691.             }
  1692. +
  1693.            
  1694. -           for (Entry<Integer, Integer> itemSkill : Config.LIST_RUNE_ITEMS.entrySet())
  1695. -           {
  1696. -               if (oldItem.getItemId() == itemSkill.getKey())
  1697. -               {
  1698. -                   L2Skill skill = SkillTable.getInstance().getInfo(itemSkill.getValue(), 1);
  1699. -                   if (skill != null)
  1700. -                   {
  1701. -                       _owner.removeSkill(skill, false);
  1702. -                       _owner.sendSkillList();
  1703. -                   }
  1704. -               }
  1705. +           DollsData dollsData = DollsData.getInstance();
  1706. +           Map<Integer, Doll> dolls = dollsData.getDolls();
  1707. +
  1708. +           for (Doll doll : dolls.values()) {
  1709. +               if (oldItem.getItemId() == doll.getId()) {
  1710. +                   int skillId = doll.getSkillId();
  1711. +                   int skillLvl = doll.getSkillLvl();
  1712. +
  1713. +                   L2Skill skill = SkillTable.getInstance().getInfo(skillId, skillLvl);
  1714. +                   if (skill != null) {
  1715. +                       if (_owner.getSkillLevel(skillId) == skillLvl) {
  1716. +                           _owner.removeSkill(skill, false);
  1717. +                           _owner.sendSkillList();
  1718. +                       }
  1719. +                   }
  1720. +               }
  1721. +
  1722. +               if (newItem.getItemId() == doll.getId()) {
  1723. +                   int skillId = doll.getSkillId();
  1724. +                   int skillLvl = doll.getSkillLvl();
  1725. +
  1726. +                   boolean hasHigherLevelSkill = false;
  1727. +
  1728. +                   // Verificar si el jugador ya tiene un skill con nivel más alto
  1729. +                   for (L2Skill existingSkill : _partner.getSkills().values()) {
  1730. +                       if (existingSkill.getId() == skillId && existingSkill.getLevel() > skillLvl) {
  1731. +                           hasHigherLevelSkill = true;
  1732. +                           break;
  1733. +                       }
  1734. +                   }
  1735. +
  1736. +                   if (!hasHigherLevelSkill) {
  1737. +                       L2Skill skill = SkillTable.getInstance().getInfo(skillId, skillLvl);
  1738. +                       if (skill != null) {
  1739. +                           if (_partner.getSkillLevel(skillId) != skillLvl) {
  1740. +                               _partner.removeSkill(skill, false);
  1741. +                               _partner.addSkill(skill, false);
  1742. +                               _partner.sendSkillList();
  1743. +                           }
  1744. +                       }
  1745. +                   }
  1746. +               }
  1747.             }
  1748. -          
  1749. -           for (Entry<Integer, Integer> itemSkill : Config.LIST_RUNE_ITEMS.entrySet())
  1750. -           {
  1751. -               if (newItem.getItemId() == itemSkill.getKey())
  1752. -               {
  1753. -                   L2Skill skill = SkillTable.getInstance().getInfo(itemSkill.getValue(), 1);
  1754. -                   if (skill != null)
  1755. -                   {
  1756. -                       _partner.addSkill(skill, false);
  1757. -                       _partner.sendSkillList();
  1758. -                   }
  1759. -               }
  1760. +
  1761. +           // Comprobar si el _owner tiene otros ítems con habilidades y otorgar las habilidades correspondientes
  1762. +           for (ItemInstance item : _owner.getInventory().getItems()) {
  1763. +              
  1764. +                   for (Doll doll : dolls.values()) {
  1765. +                       if (item.getItemId() == doll.getId()) {
  1766. +                           int skillId = doll.getSkillId();
  1767. +                           int skillLvl = doll.getSkillLvl();
  1768. +
  1769. +                           L2Skill skill = SkillTable.getInstance().getInfo(skillId, skillLvl);
  1770. +                           if (skill != null) {
  1771. +                               if (_owner.getSkillLevel(skillId) != skillLvl) {
  1772. +                                   _owner.addSkill(skill, false);
  1773. +                                   _owner.sendSkillList();
  1774. +                               }
  1775. +                           }
  1776. +                      
  1777. +                   }
  1778. +               }
  1779.             }
  1780.  
  1781. +
  1782. +
  1783. +
  1784.             TradeLog.Log(_owner.getName(), _partner.getName(), oldItem.getItemName(), oldItem.getEnchantLevel(), oldItem.getCount(), oldItem.getObjectId());
  1785.             TradeLog.Log(_partner.getName(), _owner.getName(), oldItem.getItemName(), oldItem.getEnchantLevel(), oldItem.getCount(), oldItem.getObjectId());
  1786.            
  1787. diff --git java/net/sf/l2j/gameserver/network/clientpackets/EnterWorld.java java/net/sf/l2j/gameserver/network/clientpackets/EnterWorld.java
  1788. index d8fffd4..6d8f82f 100644
  1789. --- java/net/sf/l2j/gameserver/network/clientpackets/EnterWorld.java
  1790. +++ java/net/sf/l2j/gameserver/network/clientpackets/EnterWorld.java
  1791. @@ -6,6 +6,8 @@
  1792.  import java.sql.ResultSet;
  1793.  import java.text.SimpleDateFormat;
  1794.  import java.util.Date;
  1795. +import java.util.HashMap;
  1796. +import java.util.Map;
  1797.  import java.util.Map.Entry;
  1798.  import java.util.logging.Level;
  1799.  
  1800. @@ -85,10 +87,14 @@
  1801.  import net.sf.l2j.gameserver.scripting.Quest;
  1802.  import net.sf.l2j.gameserver.scripting.QuestState;
  1803.  import net.sf.l2j.gameserver.scripting.ScriptManager;
  1804. +//import net.sf.l2j.gameserver.taskmanager.DollsTaskManager;
  1805.  import net.sf.l2j.gameserver.taskmanager.GameTimeTaskManager;
  1806.  import net.sf.l2j.gameserver.util.HWID;
  1807.  import net.sf.l2j.gameserver.util.IPLog;
  1808.  
  1809. +import Base.Dolls.Doll;
  1810. +import Base.Dolls.DollsData;
  1811. +
  1812.  public class EnterWorld extends L2GameClientPacket
  1813.  {
  1814.     long _daysleft;
  1815. @@ -495,7 +501,8 @@
  1816.                 VoicedDonate.showMainHtml(activeChar);
  1817.         }
  1818.        
  1819.  
  1820. +       onEnterRunaReload(activeChar); 
  1821.        
  1822.         activeChar.setPlayer(true);
  1823.         activeChar.sendPacket(ActionFailed.STATIC_PACKET);
  1824. @@ -665,14 +672,50 @@
  1825.     }
  1826.    
  1827.    
  1828. -   private void onEnterRunaReload(Player activeChar)
  1829. +   private static void onEnterRunaReload(Player activeChar) {
  1830. +       DollsData dollsData = DollsData.getInstance();
  1831. +       Map<Integer, Integer> skillLevels = new HashMap<>();
  1832. +
  1833. +       for (ItemInstance item : activeChar.getInventory().getItems()) {
  1834. +           if (item == null) {
  1835. +               continue;
  1836. +           }
  1837. +
  1838. +           Doll doll = dollsData.getDollById(item.getItemId());
  1839. +           if (doll != null) {
  1840. +               int skillId = doll.getSkillId();
  1841. +               int skillLvl = doll.getSkillLvl();
  1842. +
  1843. +               // Priorizar siempre el nivel más alto de habilidad
  1844. +               if (!skillLevels.containsKey(skillId) || skillLvl > skillLevels.get(skillId)) {
  1845. +                   skillLevels.put(skillId, skillLvl);
  1846. +               }
  1847. +           }
  1848. +       }
  1849. +
  1850. +       for (Map.Entry<Integer, Integer> entry : skillLevels.entrySet()) {
  1851. +           int skillId = entry.getKey();
  1852. +           int skillLvl = entry.getValue();
  1853. +
  1854. +           L2Skill skill = SkillTable.getInstance().getInfo(skillId, skillLvl);
  1855. +           if (skill != null) {
  1856. +               activeChar.addSkill(skill);
  1857. +           }
  1858. +       }
  1859. +
  1860. +       activeChar.sendSkillList();
  1861. +   }
  1862. +
  1863. +
  1864. +  
  1865.  
  1866.    
  1867.     @Override
  1868.     protected boolean triggersOnActionRequest()
  1869. diff --git java/net/sf/l2j/gameserver/network/clientpackets/RequestDestroyItem.java java/net/sf/l2j/gameserver/network/clientpackets/RequestDestroyItem.java
  1870. index d9bd04b..7ad6442 100644
  1871. --- java/net/sf/l2j/gameserver/network/clientpackets/RequestDestroyItem.java
  1872. +++ java/net/sf/l2j/gameserver/network/clientpackets/RequestDestroyItem.java
  1873. @@ -2,6 +2,7 @@
  1874.  
  1875.  import java.sql.Connection;
  1876.  import java.sql.PreparedStatement;
  1877. +import java.util.Map;
  1878.  import java.util.Map.Entry;
  1879.  import java.util.logging.Level;
  1880.  
  1881. @@ -17,6 +18,10 @@
  1882.  import net.sf.l2j.gameserver.network.serverpackets.InventoryUpdate;
  1883.  import net.sf.l2j.gameserver.network.serverpackets.StatusUpdate;
  1884.  
  1885. +import Base.Dolls.Doll;
  1886. +import Base.Dolls.DollsData;
  1887. +
  1888. +
  1889.  public final class RequestDestroyItem extends L2GameClientPacket
  1890.  {
  1891.     private int _objectId;
  1892. @@ -121,19 +126,63 @@
  1893.                 _log.log(Level.WARNING, "could not delete pet objectid: ", e);
  1894.             }
  1895.         }
  1896. +
  1897.        
  1898. -       for (Entry<Integer, Integer> itemSkill : Config.LIST_RUNE_ITEMS.entrySet())
  1899. -       {
  1900. -           if (itemToRemove.getItemId() == itemSkill.getKey())
  1901. -           {
  1902. -               L2Skill skill = SkillTable.getInstance().getInfo(itemSkill.getValue(), 1);
  1903. -               if (skill != null)
  1904. -               {
  1905. -                   activeChar.removeSkill(skill, false);
  1906. -                   activeChar.sendSkillList();
  1907. -               }
  1908. -           }
  1909. +       DollsData dollsData = DollsData.getInstance();
  1910. +       Map<Integer, Doll> dolls = dollsData.getDolls();
  1911. +
  1912. +       for (Doll doll : dolls.values()) {
  1913. +           if (itemToRemove.getItemId() == doll.getId()) {
  1914. +               int skillId = doll.getSkillId();
  1915. +               int skillLvl = doll.getSkillLvl();
  1916. +
  1917. +               boolean hasHigherLevelSkill = false;
  1918. +
  1919. +               // Verificar si el jugador ya tiene un skill con nivel más alto
  1920. +               for (L2Skill existingSkill : activeChar.getSkills().values()) {
  1921. +                   if (existingSkill.getId() == skillId && existingSkill.getLevel() > skillLvl) {
  1922. +                       hasHigherLevelSkill = true;
  1923. +                       break;
  1924. +                   }
  1925. +               }
  1926. +
  1927. +               if (!hasHigherLevelSkill) {
  1928. +                   L2Skill skill = SkillTable.getInstance().getInfo(skillId, skillLvl);
  1929. +                   if (skill != null) {
  1930. +                       activeChar.removeSkill(skill);
  1931. +                       activeChar.sendSkillList();
  1932. +                   }
  1933. +               }
  1934. +           }
  1935.         }
  1936. +
  1937. +       // Comprobar si el jugador tiene otros ítems con habilidades y otorgar las habilidades correspondientes
  1938. +       for (ItemInstance item : activeChar.getInventory().getItems()) {
  1939. +           Doll doll = dollsData.getDollById(item.getItemId());
  1940. +           if (doll != null) {
  1941. +               int skillId = doll.getSkillId();
  1942. +               int skillLvl = doll.getSkillLvl();
  1943. +
  1944. +               boolean hasHigherLevelSkill = false;
  1945. +
  1946. +               // Verificar si el jugador ya tiene un skill con nivel más alto
  1947. +               for (L2Skill existingSkill : activeChar.getSkills().values()) {
  1948. +                   if (existingSkill.getId() == skillId && existingSkill.getLevel() > skillLvl) {
  1949. +                       hasHigherLevelSkill = true;
  1950. +                       break;
  1951. +                   }
  1952. +               }
  1953. +
  1954. +               if (!hasHigherLevelSkill) {
  1955. +                   L2Skill skill = SkillTable.getInstance().getInfo(skillId, skillLvl);
  1956. +                   if (skill != null) {
  1957. +                       activeChar.addSkill(skill);
  1958. +                       activeChar.sendSkillList();
  1959. +                   }
  1960. +               }
  1961. +           }
  1962. +       }
  1963. +
  1964.        
  1965.         ItemInstance removedItem = activeChar.getInventory().destroyItem("Destroy", _objectId, _count, activeChar, null);
  1966.         if (removedItem == null)
  1967.  
  1968.  
  1969.  
  1970.  
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement