API tools faq
paste
Advertisement
tensador125

Dolls and CombineItemNpc Beta

tensador125
Jul 4th, 2023
973
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 64.98 KB | Gaming | 0 0
raw download clone embed print report
  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
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!