API tools faq
paste
Advertisement
tensador125

Item Recovery acis 372

tensador125
Jun 21st, 2023
1,423
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 25.86 KB | Gaming | 0 0
raw download clone embed print report
  1. ### Eclipse Workspace Patch 1.0
  2. #P aCis_gameserver
  3. diff --git config/players.properties config/players.properties
  4. index e52d795..25e8695 100644
  5. --- config/players.properties
  6. +++ config/players.properties
  7. @@ -260,4 +260,10 @@
  8.  MaxBuffsAmount = 20
  9.  
  10.  # Store buffs/debuffs on user logout. Default: True
  11. -StoreSkillCooltime = True
  12. \ No newline at end of file
  13. +StoreSkillCooltime = True
  14. +
  15. +#==========================================================================
  16. +#   BLACK COUPON RECOVERY 1 ITEM ENCHANT FAILED
  17. +#==========================================================================
  18. +
  19. +BlackCouponId = 6392
  20. diff --git java/Base/Data/IconTable.java java/Base/Data/IconTable.java
  21. new file mode 100644
  22. index 0000000..fa75062
  23. --- /dev/null
  24. +++ java/Base/Data/IconTable.java
  25. @@ -0,0 +1,62 @@
  26. +package Base.Data;
  27. +
  28. +import java.io.File;
  29. +import java.util.HashMap;
  30. +import java.util.Map;
  31. +
  32. +import org.w3c.dom.Document;
  33. +import org.w3c.dom.NamedNodeMap;
  34. +import org.w3c.dom.Node;
  35. +
  36. +public class IconTable extends XMLDocument
  37. +{
  38. +   private static final Map<Integer, String> itemIcons = new HashMap<>();
  39. +  
  40. +   public IconTable()
  41. +   {
  42. +       load();
  43. +   }
  44. +  
  45. +   @Override
  46. +   protected void load()
  47. +   {
  48. +       loadDocument("./data/xml/icons.xml");
  49. +       LOG.info("Loaded " + itemIcons.size() + " icons.");
  50. +   }
  51. +  
  52. +   @Override
  53. +   protected void parseDocument(Document doc, File f)
  54. +   {
  55. +  
  56. +       final Node n = doc.getFirstChild();
  57. +      
  58. +       for (Node o = n.getFirstChild(); o != null; o = o.getNextSibling())
  59. +       {
  60. +           if (!"icon".equalsIgnoreCase(o.getNodeName()))
  61. +           {
  62. +               continue;
  63. +           }
  64. +          
  65. +           final NamedNodeMap attrs = o.getAttributes();
  66. +           final int itemId = Integer.valueOf(attrs.getNamedItem("Id").getNodeValue());
  67. +           final String value = String.valueOf(attrs.getNamedItem("value").getNodeValue());
  68. +          
  69. +           itemIcons.put(itemId, value);
  70. +       }
  71. +   }
  72. +  
  73. +   public String getIcon(int id)
  74. +   {
  75. +       return itemIcons.get(id) == null ? "icon.noimage" : itemIcons.get(id);
  76. +   }
  77. +  
  78. +   public static IconTable getInstance()
  79. +   {
  80. +       return SingletonHolder._instance;
  81. +   }
  82. +  
  83. +   private static class SingletonHolder
  84. +   {
  85. +       protected static final IconTable _instance = new IconTable();
  86. +   }
  87. +}
  88. diff --git java/Base/Data/XMLDocument.java java/Base/Data/XMLDocument.java
  89. new file mode 100644
  90. index 0000000..6d491db
  91. --- /dev/null
  92. +++ java/Base/Data/XMLDocument.java
  93. @@ -0,0 +1,121 @@
  94. +package Base.Data;
  95. +
  96. +import java.io.File;
  97. +import java.util.logging.Level;
  98. +import java.util.logging.Logger;
  99. +
  100. +import javax.xml.parsers.DocumentBuilderFactory;
  101. +import javax.xml.transform.OutputKeys;
  102. +import javax.xml.transform.Transformer;
  103. +import javax.xml.transform.TransformerException;
  104. +import javax.xml.transform.TransformerFactory;
  105. +import javax.xml.transform.dom.DOMSource;
  106. +import javax.xml.transform.stream.StreamResult;
  107. +
  108. +import net.sf.l2j.gameserver.templates.StatsSet;
  109. +
  110. +import org.w3c.dom.Document;
  111. +import org.w3c.dom.NamedNodeMap;
  112. +import org.w3c.dom.Node;
  113. +
  114. +
  115. +
  116. +/**
  117. + * An XML document, relying on a static and single DocumentBuilderFactory.
  118. + */
  119. +public abstract class XMLDocument
  120. +{
  121. +   protected static final Logger LOG = Logger.getLogger(XMLDocument.class.getName());
  122. +  
  123. +   protected Document document;
  124. +  
  125. +   private static final DocumentBuilderFactory BUILDER;
  126. +   static
  127. +   {
  128. +       BUILDER = DocumentBuilderFactory.newInstance();
  129. +       BUILDER.setValidating(false);
  130. +       BUILDER.setIgnoringComments(true);
  131. +   }
  132. +  
  133. +   abstract protected void load();
  134. +  
  135. +   abstract protected void parseDocument(Document doc, File f);
  136. +  
  137. +   public void loadDocument(String filePath)
  138. +   {
  139. +       loadDocument(new File(filePath));
  140. +   }
  141. +  
  142. +   public void writeDocument(Document doc, String fileName)
  143. +   {
  144. +       try
  145. +       {
  146. +           TransformerFactory transformerFactory = TransformerFactory.newInstance();
  147. +           Transformer transformer = transformerFactory.newTransformer();
  148. +           transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
  149. +           transformer.setOutputProperty(OutputKeys.INDENT, "yes");
  150. +           transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "2");
  151. +          
  152. +           DOMSource source = new DOMSource(doc);
  153. +           StreamResult result = new StreamResult(new File(fileName));
  154. +          
  155. +           transformer.transform(source, result);
  156. +           LOG.info("XML file saved to " + fileName);
  157. +       }
  158. +       catch (TransformerException e)
  159. +       {
  160. +           LOG.warning("Error saving XML file: " + e.getMessage());
  161. +       }
  162. +   }
  163. +  
  164. +   /**
  165. +    * Parse an entire directory or file if found.
  166. +    * @param file
  167. +    */
  168. +   public void loadDocument(File file)
  169. +   {
  170. +       if (!file.exists())
  171. +       {
  172. +           LOG.severe("The following file or directory doesn't exist: " + file.getName());
  173. +           return;
  174. +       }
  175. +      
  176. +       if (file.isDirectory())
  177. +       {
  178. +           for (File f : file.listFiles())
  179. +           {
  180. +               loadDocument(f);
  181. +           }
  182. +       }
  183. +       else if (file.isFile())
  184. +       {
  185. +           try
  186. +           {
  187. +               parseDocument(BUILDER.newDocumentBuilder().parse(file), file);
  188. +           }
  189. +           catch (Exception e)
  190. +           {
  191. +               LOG.log(Level.SEVERE, "Error loading XML file " + file.getName(), e);
  192. +           }
  193. +       }
  194. +   }
  195. +  
  196. +   public Document getDocument()
  197. +   {
  198. +       return document;
  199. +   }
  200. +  
  201. +   /**
  202. +    * This method parses the content of a NamedNodeMap and feed the given StatsSet.
  203. +    * @param attrs : The NamedNodeMap to parse.
  204. +    * @param set : The StatsSet to feed.
  205. +    */
  206. +   public static void parseAndFeed(NamedNodeMap attrs, StatsSet set)
  207. +   {
  208. +       for (int i = 0; i < attrs.getLength(); i++)
  209. +       {
  210. +           final Node attr = attrs.item(i);
  211. +           set.set(attr.getNodeName(), attr.getNodeValue());
  212. +       }
  213. +   }
  214. +}
  215. diff --git java/Base/RecoverySystem/ItemRecoveryManager.java java/Base/RecoverySystem/ItemRecoveryManager.java
  216. new file mode 100644
  217. index 0000000..050c6cc
  218. --- /dev/null
  219. +++ java/Base/RecoverySystem/ItemRecoveryManager.java
  220. @@ -0,0 +1,275 @@
  221. +package Base.RecoverySystem;
  222. +
  223. +import java.sql.Connection;
  224. +import java.sql.PreparedStatement;
  225. +import java.sql.ResultSet;
  226. +import java.sql.SQLException;
  227. +import java.util.HashMap;
  228. +import java.util.Map;
  229. +
  230. +import net.sf.l2j.Config;
  231. +import net.sf.l2j.L2DatabaseFactory;
  232. +import net.sf.l2j.gameserver.data.ItemTable;
  233. +import net.sf.l2j.gameserver.model.actor.instance.Player;
  234. +import net.sf.l2j.gameserver.model.item.instance.ItemInstance;
  235. +import net.sf.l2j.gameserver.network.serverpackets.ItemList;
  236. +
  237. +
  238. +
  239. +public class ItemRecoveryManager
  240. +{
  241. +   private Map<Integer, Integer> validEnchantLevels;
  242. +  
  243. +   public ItemRecoveryManager()
  244. +   {
  245. +       validEnchantLevels = new HashMap<>();
  246. +       loadValidEnchantLevels();
  247. +   }
  248. +  
  249. +   public void recoverSelectedItem(Player player, int itemId, int enchantLevel)
  250. +   {
  251. +
  252. +       ItemInstance recoveryItem = player.getInventory().getItemByItemId(Config.BLACK_COUPON_ID);
  253. +       if (recoveryItem == null || recoveryItem.getCount() < 1)
  254. +       {
  255. +           player.sendMessage("No tienes suficientes items para recuperar este item.");
  256. +           return;
  257. +       }
  258. +      
  259. +      
  260. +       if (!isValidEnchantLevel(itemId, enchantLevel, player.getObjectId()))
  261. +       {
  262. +           player.sendMessage("No puedes recuperar este item con ese nivel de enchant.");
  263. +           return;
  264. +       }
  265. +      
  266. +      
  267. +       if (!isValidRecoveryItem(itemId, player.getObjectId()))
  268. +       {
  269. +           player.sendMessage("No puedes recuperar este item.");
  270. +           return;
  271. +       }
  272. +      
  273. +      
  274. +       ItemInstance recoveredItem = ItemTable.getInstance().createItem("RecoverItem", itemId, 1, player, null);
  275. +       recoveredItem.setEnchantLevel(enchantLevel);
  276. +      
  277. +      
  278. +       player.getInventory().addItem("RecoverItem", recoveredItem, player, player);
  279. +      
  280. +      
  281. +       player.getInventory().destroyItemByItemId("RecoveryCost", Config.BLACK_COUPON_ID, 1, player, player);
  282. +      
  283. +      
  284. +       removeRecoverableItem(itemId, player.getObjectId());
  285. +      
  286. +  
  287. +       player.sendPacket(new ItemList(player, true));
  288. +      
  289. +  
  290. +       String itemName = recoveredItem.getItemName();
  291. +       String message = "Has recuperado el item " + itemName;
  292. +       if (enchantLevel > 0)
  293. +       {
  294. +           message += " +" + enchantLevel;
  295. +       }
  296. +       player.sendMessage(message);
  297. +   }
  298. +  
  299. +   @SuppressWarnings("resource")
  300. +   public boolean isValidRecoveryItem(int itemId, int objectId)
  301. +   {
  302. +       Connection con = null;
  303. +       PreparedStatement statement = null;
  304. +       ResultSet resultSet = null;
  305. +      
  306. +       try
  307. +       {
  308. +           con = L2DatabaseFactory.getInstance().getConnection();
  309. +           String sql = "SELECT item_id FROM item_recover WHERE object_id = ? AND item_id = ?";
  310. +           statement = con.prepareStatement(sql);
  311. +           statement.setInt(1, objectId);
  312. +           statement.setInt(2, itemId);
  313. +           resultSet = statement.executeQuery();
  314. +          
  315. +           return resultSet.next();
  316. +          
  317. +       }
  318. +       catch (SQLException e)
  319. +       {
  320. +          
  321. +           e.printStackTrace();
  322. +       }
  323. +       finally
  324. +       {
  325. +           try
  326. +           {
  327. +               if (resultSet != null)
  328. +               {
  329. +                   resultSet.close();
  330. +               }
  331. +               if (statement != null)
  332. +               {
  333. +                   statement.close();
  334. +               }
  335. +               if (con != null)
  336. +               {
  337. +                   con.close();
  338. +               }
  339. +           }
  340. +           catch (SQLException e)
  341. +           {
  342. +              
  343. +               e.printStackTrace();
  344. +           }
  345. +       }
  346. +      
  347. +       return false;
  348. +   }
  349. +  
  350. +   @SuppressWarnings("resource")
  351. +   public boolean isValidEnchantLevel(int itemId, int enchantLevel, int objectId)
  352. +   {
  353. +       Connection con = null;
  354. +       PreparedStatement statement = null;
  355. +       ResultSet resultSet = null;
  356. +      
  357. +       try
  358. +       {
  359. +           con = L2DatabaseFactory.getInstance().getConnection();
  360. +           String sql = "SELECT enchant_level FROM item_recover WHERE object_id = ? AND item_id = ?";
  361. +           statement = con.prepareStatement(sql);
  362. +           statement.setInt(1, objectId);
  363. +           statement.setInt(2, itemId);
  364. +           resultSet = statement.executeQuery();
  365. +          
  366. +           if (resultSet.next())
  367. +           {
  368. +               int validEnchantLevel = resultSet.getInt("enchant_level");
  369. +               return enchantLevel == validEnchantLevel;
  370. +           }
  371. +       }
  372. +       catch (SQLException e)
  373. +       {
  374. +          
  375. +           e.printStackTrace();
  376. +       }
  377. +       finally
  378. +       {
  379. +           try
  380. +           {
  381. +               if (resultSet != null)
  382. +               {
  383. +                   resultSet.close();
  384. +               }
  385. +               if (statement != null)
  386. +               {
  387. +                   statement.close();
  388. +               }
  389. +               if (con != null)
  390. +               {
  391. +                   con.close();
  392. +               }
  393. +           }
  394. +           catch (SQLException e)
  395. +           {
  396. +              
  397. +               e.printStackTrace();
  398. +           }
  399. +       }
  400. +      
  401. +       return false;
  402. +   }
  403. +  
  404. +   public void removeRecoverableItem(int itemId, int objectId)
  405. +   {
  406. +       Connection con = null;
  407. +       PreparedStatement statement = null;
  408. +      
  409. +       try
  410. +       {
  411. +           con = L2DatabaseFactory.getInstance().getConnection();
  412. +           String sql = "DELETE FROM item_recover WHERE item_id = ? AND object_id = ?";
  413. +           statement = con.prepareStatement(sql);
  414. +           statement.setInt(1, itemId);
  415. +           statement.setInt(2, objectId);
  416. +           statement.executeUpdate();
  417. +       }
  418. +       catch (SQLException e)
  419. +       {
  420. +          
  421. +           e.printStackTrace();
  422. +       }
  423. +       finally
  424. +       {
  425. +           try
  426. +           {
  427. +               if (statement != null)
  428. +               {
  429. +                   statement.close();
  430. +               }
  431. +               if (con != null)
  432. +               {
  433. +                   con.close();
  434. +               }
  435. +           }
  436. +           catch (SQLException e)
  437. +           {
  438. +              
  439. +               e.printStackTrace();
  440. +           }
  441. +       }
  442. +   }
  443. +  
  444. +   private void loadValidEnchantLevels()
  445. +   {
  446. +       Connection con = null;
  447. +       PreparedStatement statement = null;
  448. +       ResultSet resultSet = null;
  449. +      
  450. +       try
  451. +       {
  452. +           con = L2DatabaseFactory.getInstance().getConnection();
  453. +           String sql = "SELECT item_id, enchant_level FROM item_recover";
  454. +           statement = con.prepareStatement(sql);
  455. +           resultSet = statement.executeQuery();
  456. +          
  457. +           while (resultSet.next())
  458. +           {
  459. +               int itemId = resultSet.getInt("item_id");
  460. +               int enchantLevel = resultSet.getInt("enchant_level");
  461. +              
  462. +               validEnchantLevels.put(itemId, enchantLevel);
  463. +           }
  464. +       }
  465. +       catch (SQLException e)
  466. +       {
  467. +          
  468. +           e.printStackTrace();
  469. +       }
  470. +       finally
  471. +       {
  472. +           try
  473. +           {
  474. +               if (resultSet != null)
  475. +               {
  476. +                   resultSet.close();
  477. +               }
  478. +               if (statement != null)
  479. +               {
  480. +                   statement.close();
  481. +               }
  482. +               if (con != null)
  483. +               {
  484. +                   con.close();
  485. +               }
  486. +           }
  487. +           catch (SQLException e)
  488. +           {
  489. +              
  490. +               e.printStackTrace();
  491. +           }
  492. +       }
  493. +   }
  494. +  
  495. +}
  496. diff --git java/Base/RecoverySystem/RecoverableItem.java java/Base/RecoverySystem/RecoverableItem.java
  497. new file mode 100644
  498. index 0000000..a13f0e8
  499. --- /dev/null
  500. +++ java/Base/RecoverySystem/RecoverableItem.java
  501. @@ -0,0 +1,113 @@
  502. +package Base.RecoverySystem;
  503. +
  504. +import java.sql.Connection;
  505. +import java.sql.PreparedStatement;
  506. +import java.sql.SQLException;
  507. +
  508. +import net.sf.l2j.L2DatabaseFactory;
  509. +import net.sf.l2j.gameserver.data.ItemTable;
  510. +import net.sf.l2j.gameserver.model.item.kind.Item;
  511. +
  512. +
  513. +
  514. +public class RecoverableItem
  515. +{
  516. +   private int objectId;
  517. +   private int itemId;
  518. +   private String itemName;
  519. +   private int enchantLevel;
  520. +   private boolean selected;
  521. +  
  522. +   public RecoverableItem(int objectId, int itemId, String itemName, int enchantLevel)
  523. +   {
  524. +       this.objectId = objectId;
  525. +       this.itemId = itemId;
  526. +       this.itemName = itemName;
  527. +       this.enchantLevel = enchantLevel;
  528. +       this.selected = false;
  529. +   }
  530. +  
  531. +   public int getObjectId()
  532. +   {
  533. +       return objectId;
  534. +   }
  535. +  
  536. +   public int getItemId()
  537. +   {
  538. +       return itemId;
  539. +   }
  540. +  
  541. +   public String getItemName()
  542. +   {
  543. +       return itemName;
  544. +   }
  545. +  
  546. +   public int getEnchantLevel()
  547. +   {
  548. +       return enchantLevel;
  549. +   }
  550. +  
  551. +   public void saveBrokenItemInfo()
  552. +   {
  553. +       Connection con = null;
  554. +       PreparedStatement statement = null;
  555. +      
  556. +       try
  557. +       {
  558. +           con = L2DatabaseFactory.getInstance().getConnection();
  559. +           String sql = "INSERT INTO item_recover (object_id, item_id, item_name, enchant_level) VALUES (?, ?, ?, ?)";
  560. +           statement = con.prepareStatement(sql);
  561. +           statement.setInt(1, objectId);
  562. +           statement.setInt(2, itemId);
  563. +           statement.setString(3, itemName);
  564. +           statement.setInt(4, enchantLevel);
  565. +           statement.execute();
  566. +       }
  567. +       catch (SQLException e)
  568. +       {
  569. +          
  570. +           e.printStackTrace();
  571. +       }
  572. +       finally
  573. +       {
  574. +          
  575. +           try
  576. +           {
  577. +               if (statement != null)
  578. +               {
  579. +                   statement.close();
  580. +               }
  581. +               if (con != null)
  582. +               {
  583. +                   con.close();
  584. +               }
  585. +           }
  586. +           catch (SQLException e)
  587. +           {
  588. +              
  589. +               e.printStackTrace();
  590. +           }
  591. +       }
  592. +   }
  593. +  
  594. +   public boolean isSelected()
  595. +   {
  596. +       return selected;
  597. +   }
  598. +  
  599. +   public void setSelected(boolean selected)
  600. +   {
  601. +       this.selected = selected;
  602. +   }
  603. +  
  604. +   public String getIcon()
  605. +   {
  606. +       return getItem().getIcon();
  607. +   }
  608. +  
  609. +   public Item getItem()
  610. +   {
  611. +       return ItemTable.getInstance().getTemplate(itemId);
  612. +   }
  613. +  
  614. +}
  615. diff --git java/net/sf/l2j/Config.java java/net/sf/l2j/Config.java
  616. index 91fc0f1..85901f5 100644
  617. --- java/net/sf/l2j/Config.java
  618. +++ java/net/sf/l2j/Config.java
  619. @@ -44,6 +44,12 @@
  620.     // Clans settings
  621.     // --------------------------------------------------
  622.    
  623. +  
  624. +  
  625. +  
  626. +   public static int BLACK_COUPON_ID; 
  627. +  
  628. +  
  629.     /** Clans */
  630.     public static int ALT_CLAN_JOIN_DAYS;
  631.     public static int ALT_CLAN_CREATE_DAYS;
  632. @@ -1069,6 +1075,9 @@
  633.     {
  634.         final ExProperties players = initProperties(PLAYERS_FILE);
  635.         EFFECT_CANCELING = players.getProperty("CancelLesserEffect", true);
  636. +       BLACK_COUPON_ID = players.getProperty("BlackCouponId", 6392);
  637. +
  638. +      
  639.         HP_REGEN_MULTIPLIER = players.getProperty("HpRegenMultiplier", 1.);
  640.         MP_REGEN_MULTIPLIER = players.getProperty("MpRegenMultiplier", 1.);
  641.         CP_REGEN_MULTIPLIER = players.getProperty("CpRegenMultiplier", 1.);
  642. diff --git java/net/sf/l2j/gameserver/GameServer.java java/net/sf/l2j/gameserver/GameServer.java
  643. index 65bf5ef..2f1e305 100644
  644. --- java/net/sf/l2j/gameserver/GameServer.java
  645. +++ java/net/sf/l2j/gameserver/GameServer.java
  646. @@ -108,6 +108,8 @@
  647.  import net.sf.l2j.util.DeadLockDetector;
  648.  import net.sf.l2j.util.IPv4Filter;
  649.  
  650. +import Base.Data.IconTable;
  651. +
  652.  public class GameServer
  653.  {
  654.     private static final Logger _log = Logger.getLogger(GameServer.class.getName());
  655. @@ -285,6 +287,10 @@
  656.         DerbyTrackManager.getInstance();
  657.         LotteryManager.getInstance();
  658.        
  659. +      
  660. +       IconTable.getInstance();
  661. +        
  662. +      
  663.         if (Config.ALLOW_WEDDING)
  664.             CoupleManager.getInstance();
  665.        
  666. diff --git java/net/sf/l2j/gameserver/handler/ItemHandler.java java/net/sf/l2j/gameserver/handler/ItemHandler.java
  667. index 07bb3f7..0020d2a 100644
  668. --- java/net/sf/l2j/gameserver/handler/ItemHandler.java
  669. +++ java/net/sf/l2j/gameserver/handler/ItemHandler.java
  670. @@ -14,6 +14,7 @@
  671.  import net.sf.l2j.gameserver.handler.itemhandlers.FishShots;
  672.  import net.sf.l2j.gameserver.handler.itemhandlers.Harvester;
  673.  import net.sf.l2j.gameserver.handler.itemhandlers.ItemSkills;
  674. +import net.sf.l2j.gameserver.handler.itemhandlers.Item_Recover;
  675.  import net.sf.l2j.gameserver.handler.itemhandlers.Keys;
  676.  import net.sf.l2j.gameserver.handler.itemhandlers.Maps;
  677.  import net.sf.l2j.gameserver.handler.itemhandlers.MercTicket;
  678. @@ -62,6 +63,7 @@
  679.         registerItemHandler(new PetFood());
  680.         registerItemHandler(new Recipes());
  681.         registerItemHandler(new RollingDice());
  682. +       registerItemHandler(new Item_Recover());
  683.         registerItemHandler(new ScrollOfResurrection());
  684.         registerItemHandler(new SeedHandler());
  685.         registerItemHandler(new SevenSignsRecord());
  686. diff --git java/net/sf/l2j/gameserver/handler/itemhandlers/Item_Recover.java java/net/sf/l2j/gameserver/handler/itemhandlers/Item_Recover.java
  687. new file mode 100644
  688. index 0000000..47f23fe
  689. --- /dev/null
  690. +++ java/net/sf/l2j/gameserver/handler/itemhandlers/Item_Recover.java
  691. @@ -0,0 +1,170 @@
  692. +package net.sf.l2j.gameserver.handler.itemhandlers;
  693. +
  694. +import java.sql.Connection;
  695. +import java.sql.PreparedStatement;
  696. +import java.sql.ResultSet;
  697. +import java.sql.SQLException;
  698. +import java.util.ArrayList;
  699. +import java.util.List;
  700. +
  701. +import net.sf.l2j.L2DatabaseFactory;
  702. +import net.sf.l2j.gameserver.handler.IItemHandler;
  703. +import net.sf.l2j.gameserver.model.actor.Playable;
  704. +import net.sf.l2j.gameserver.model.actor.instance.Player;
  705. +import net.sf.l2j.gameserver.model.item.instance.ItemInstance;
  706. +import net.sf.l2j.gameserver.network.serverpackets.ActionFailed;
  707. +import net.sf.l2j.gameserver.network.serverpackets.NpcHtmlMessage;
  708. +
  709. +import Base.RecoverySystem.RecoverableItem;
  710. +
  711. +
  712. +
  713. +/**
  714. + * @author Terius
  715. + */
  716. +public class Item_Recover implements IItemHandler
  717. +{
  718. +
  719. +  
  720. +   @Override
  721. +   public void useItem(Playable playable, ItemInstance item, boolean forceUse)
  722. +   {
  723. +       if (!(playable instanceof Player))
  724. +       {
  725. +           return;
  726. +       }
  727. +      
  728. +       Player activeChar = (Player) playable;
  729. +      
  730. +      
  731. +       openRecoveryWindow(activeChar);
  732. +   }
  733. +  
  734. +   private static void openRecoveryWindow(Player player)
  735. +   {
  736. +      
  737. +       List<RecoverableItem> recoverableItems = getRecoverableItems(player.getObjectId());
  738. +      
  739. +  
  740. +       if (recoverableItems.isEmpty())
  741. +       {
  742. +          
  743. +           player.sendMessage("No hay items recuperables disponibles.");
  744. +           return;
  745. +       }
  746. +      
  747. +      
  748. +       NpcHtmlMessage html = new NpcHtmlMessage(1);
  749. +      
  750. +      
  751. +       String content = generateRecoveryList(recoverableItems);
  752. +       html.setHtml(content);
  753. +      
  754. +      
  755. +       player.sendPacket(html);
  756. +       player.sendPacket(ActionFailed.STATIC_PACKET);
  757. +   }
  758. +  
  759. +
  760. +  
  761. +   private static String generateRecoveryList(List<RecoverableItem> recoverableItems)
  762. +   {
  763. +      
  764. +      
  765. +       StringBuilder sb = new StringBuilder();
  766. +       sb.append("<html><body><center><font color=\"LEVEL\">Items Recuperables</font><br><br>");
  767. +      
  768. +  
  769. +       sb.append("<font color=\"FF0000\">Solo puedes recuperar 1 item a la vez.</font><br>");
  770. +      
  771. +      
  772. +       for (RecoverableItem item : recoverableItems)
  773. +       {
  774. +           sb.append("<img src=\"L2UI.SquareGray\" width=295 height=1>");
  775. +           sb.append("<table>");
  776. +          
  777. +           sb.append("<tr>");
  778. +           sb.append("<td>");
  779. +           sb.append("<img src=\"").append(item.getIcon()).append("\" width=32 height=32>");
  780. +           sb.append("</td>");
  781. +           sb.append("<td width=210><font color=\"FFFFFF\">").append(item.getItemName()).append("</font>");
  782. +          
  783. +           int enchantLevel = item.getEnchantLevel();
  784. +           if (enchantLevel > 0)
  785. +           {
  786. +               sb.append(" <font color=\"00FF00\">+").append(enchantLevel).append("</font>");
  787. +           }
  788. +          
  789. +           sb.append("</td>");
  790. +          
  791. +           int itemId = item.getItemId();
  792. +           sb.append("<td><button value=\"Recuperar\" action=\"bypass -h recoverSelectedItem ").append(itemId).append(" ").append(enchantLevel).append("\" width=75 height=21 back=\"L2UI.DefaultButton_click\" fore=\"L2UI.DefaultButton\"></td>");
  793. +          
  794. +           sb.append("</tr>");
  795. +          
  796. +           sb.append("</table>");
  797. +           sb.append("<img src=\"L2UI.SquareGray\" width=295 height=1>");
  798. +           sb.append("<br>");
  799. +       }
  800. +      
  801. +       sb.append("</center></body></html>");
  802. +       return sb.toString();
  803. +   }
  804. +  
  805. +   private static List<RecoverableItem> getRecoverableItems(int objectId)
  806. +   {
  807. +       List<RecoverableItem> recoverableItems = new ArrayList<>();
  808. +       Connection con = null;
  809. +       PreparedStatement statement = null;
  810. +       ResultSet resultSet = null;
  811. +      
  812. +       try
  813. +       {
  814. +           con = L2DatabaseFactory.getInstance().getConnection();
  815. +           String sql = "SELECT item_id, item_name, enchant_level FROM item_recover WHERE object_id = ? ORDER BY id DESC LIMIT 10";
  816. +           statement = con.prepareStatement(sql);
  817. +           statement.setInt(1, objectId);
  818. +           resultSet = statement.executeQuery();
  819. +          
  820. +           while (resultSet.next())
  821. +           {
  822. +               int itemId = resultSet.getInt("item_id");
  823. +               String itemName = resultSet.getString("item_name");
  824. +               int enchantLevel = resultSet.getInt("enchant_level");
  825. +              
  826. +               RecoverableItem item = new RecoverableItem(objectId, itemId, itemName, enchantLevel);
  827. +               recoverableItems.add(item);
  828. +           }
  829. +       }
  830. +       catch (SQLException e)
  831. +       {
  832. +          
  833. +           e.printStackTrace();
  834. +       }
  835. +       finally
  836. +       {
  837. +           try
  838. +           {
  839. +               if (resultSet != null)
  840. +               {
  841. +                   resultSet.close();
  842. +               }
  843. +               if (statement != null)
  844. +               {
  845. +                   statement.close();
  846. +               }
  847. +               if (con != null)
  848. +               {
  849. +                   con.close();
  850. +               }
  851. +           }
  852. +           catch (SQLException e)
  853. +           {
  854. +
  855. +               e.printStackTrace();
  856. +           }
  857. +       }
  858. +      
  859. +       return recoverableItems;
  860. +   }
  861. +}
  862. diff --git java/net/sf/l2j/gameserver/model/item/kind/Item.java java/net/sf/l2j/gameserver/model/item/kind/Item.java
  863. index f72530e..a7d1556 100644
  864. --- java/net/sf/l2j/gameserver/model/item/kind/Item.java
  865. +++ java/net/sf/l2j/gameserver/model/item/kind/Item.java
  866. @@ -28,6 +28,8 @@
  867.  import net.sf.l2j.gameserver.skills.conditions.Condition;
  868.  import net.sf.l2j.gameserver.templates.StatsSet;
  869.  
  870. +import Base.Data.IconTable;
  871. +
  872.  /**
  873.   * This class contains all informations concerning the item (weapon, armor, etc). Mother class of :
  874.   * <ul>
  875. @@ -577,4 +579,11 @@
  876.     {
  877.         return _questEvents;
  878.     }
  879. +  
  880. +  
  881. +      public String getIcon()
  882. +      {
  883. +          return IconTable.getInstance().getIcon(getItemId());
  884. +      }
  885. +  
  886.  }
  887. \ No newline at end of file
  888. diff --git java/net/sf/l2j/gameserver/network/clientpackets/RequestBypassToServer.java java/net/sf/l2j/gameserver/network/clientpackets/RequestBypassToServer.java
  889. index 7e74c2b..634bace 100644
  890. --- java/net/sf/l2j/gameserver/network/clientpackets/RequestBypassToServer.java
  891. +++ java/net/sf/l2j/gameserver/network/clientpackets/RequestBypassToServer.java
  892. @@ -24,6 +24,8 @@
  893.  import net.sf.l2j.gameserver.network.serverpackets.ActionFailed;
  894.  import net.sf.l2j.gameserver.network.serverpackets.NpcHtmlMessage;
  895.  
  896. +import Base.RecoverySystem.ItemRecoveryManager;
  897. +
  898.  public final class RequestBypassToServer extends L2GameClientPacket
  899.  {
  900.     private static final Logger GMAUDIT_LOG = Logger.getLogger("gmaudit");
  901. @@ -85,6 +87,20 @@
  902.             {
  903.                 playerHelp(activeChar, _command.substring(12));
  904.             }
  905. +          
  906. +           else if (_command.startsWith("recoverSelectedItem"))
  907. +           {
  908. +           String[] bypassParts = _command.split(" ");
  909. +           if (bypassParts.length >= 3)
  910. +           {
  911. +                 int itemId = Integer.parseInt(bypassParts[1]);
  912. +               int enchantLevel = Integer.parseInt(bypassParts[2]);
  913. +                                  
  914. +                ItemRecoveryManager itemRecoveryManager = new ItemRecoveryManager();
  915. +                  itemRecoveryManager.recoverSelectedItem(activeChar, itemId, enchantLevel);
  916. +            }
  917. +           }
  918. +          
  919.             else if (_command.startsWith("npc_"))
  920.             {
  921.                 if (!activeChar.validateBypass(_command))
  922. diff --git java/net/sf/l2j/gameserver/network/clientpackets/RequestEnchantItem.java java/net/sf/l2j/gameserver/network/clientpackets/RequestEnchantItem.java
  923. index 2a78f67..706b4f4 100644
  924. --- java/net/sf/l2j/gameserver/network/clientpackets/RequestEnchantItem.java
  925. +++ java/net/sf/l2j/gameserver/network/clientpackets/RequestEnchantItem.java
  926. @@ -1,7 +1,12 @@
  927.  package net.sf.l2j.gameserver.network.clientpackets;
  928.  
  929. +import java.sql.Connection;
  930. +import java.sql.PreparedStatement;
  931. +import java.sql.SQLException;
  932. +
  933.  import net.sf.l2j.commons.random.Rnd;
  934.  
  935. +import net.sf.l2j.L2DatabaseFactory;
  936.  import net.sf.l2j.gameserver.data.SkillTable;
  937.  import net.sf.l2j.gameserver.data.xml.ArmorSetData;
  938.  import net.sf.l2j.gameserver.model.L2Skill;
  939. @@ -263,6 +268,13 @@
  940.                     su.addAttribute(StatusUpdate.CUR_LOAD, activeChar.getCurrentLoad());
  941.                     activeChar.sendPacket(su);
  942.                 }
  943. +              
  944. +              
  945. +                
  946. +                 saveBrokenItemInfo(activeChar.getObjectId(), item.getItemId(), item.getItemName(), item.getEnchantLevel());
  947. +                  
  948. +              
  949. +              
  950.             }
  951.            
  952.             activeChar.sendPacket(new ItemList(activeChar, false));
  953. @@ -270,4 +282,55 @@
  954.             activeChar.setActiveEnchantItem(null);
  955.         }
  956.     }
  957. +  
  958. +  
  959. +      private static void saveBrokenItemInfo(int objectId, int itemId, String itemName, int enchantLevel)
  960. +      {
  961. +          Connection con = null;
  962. +          PreparedStatement statement = null;
  963. +          
  964. +          try
  965. +          {
  966. +              con = L2DatabaseFactory.getInstance().getConnection();
  967. +              String sql = "INSERT INTO item_recover (object_id, item_id, item_name, enchant_level) VALUES (?, ?, ?, ?)";
  968. +              statement = con.prepareStatement(sql);
  969. +              statement.setInt(1, objectId);
  970. +              statement.setInt(2, itemId);
  971. +              statement.setString(3, itemName);
  972. +              statement.setInt(4, enchantLevel);
  973. +              statement.execute();
  974. +          }
  975. +          catch (SQLException e)
  976. +          {
  977. +              
  978. +              e.printStackTrace();
  979. +          }
  980. +          finally
  981. +          {
  982. +            
  983. +              try
  984. +              {
  985. +                  if (statement != null)
  986. +                  {
  987. +                      statement.close();
  988. +                  }
  989. +                  if (con != null)
  990. +                  {
  991. +                      con.close();
  992. +                  }
  993. +              }
  994. +              catch (SQLException e)
  995. +              {
  996. +                  
  997. +                  e.printStackTrace();
  998. +              }
  999. +          }
  1000. +      }
  1001. +      
  1002. +  
  1003. +  
  1004. +  
  1005. +  
  1006. +  
  1007. +  
  1008.  }
  1009. \ No newline at end of file
  1010.  
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!