API tools faq
paste
Advertisement
tensador125

Black Coupon Essence in Interlude l2jorion

tensador125
Jun 19th, 2023 (edited)
1,593
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 29.83 KB | Gaming | 0 0
raw download clone embed print report
  1. el sql
  2.  
  3. /*
  4. Navicat MySQL Data Transfer
  5.  
  6. Source Server         : localhost
  7. Source Server Version : 50740
  8. Source Host           : localhost:3306
  9. Source Database       : l2j
  10.  
  11. Target Server Type    : MYSQL
  12. Target Server Version : 50740
  13. File Encoding         : 65001
  14.  
  15. Date: 2023-06-19 14:40:34
  16. */
  17.  
  18. SET FOREIGN_KEY_CHECKS=0;
  19.  
  20. -- ----------------------------
  21. -- Table structure for item_recover
  22. -- ----------------------------
  23. DROP TABLE IF EXISTS `item_recover`;
  24. CREATE TABLE `item_recover` (
  25.   `id` int(11) NOT NULL AUTO_INCREMENT,
  26.   `object_id` int(11) NOT NULL,
  27.   `item_id` int(11) NOT NULL,
  28.   `item_name` varchar(255) DEFAULT NULL,
  29.   `enchant_level` int(11) NOT NULL,
  30.   `item_type` varchar(255) DEFAULT NULL,
  31.   PRIMARY KEY (`id`),
  32.   KEY `object_id_index` (`object_id`)
  33. ) ENGINE=InnoDB AUTO_INCREMENT=51 DEFAULT CHARSET=latin1;
  34.  
  35.  
  36.  
  37. ### Eclipse Workspace Patch 1.0
  38. #P OrionRev28
  39.  
  40. diff --git src/l2jorion/game/handler/ItemHandler.java src/l2jorion/game/handler/ItemHandler.java
  41. index d009bbf..8eec4e5 100644
  42. --- src/l2jorion/game/handler/ItemHandler.java
  43. +++ src/l2jorion/game/handler/ItemHandler.java
  44. @@ -23,7 +23,6 @@
  45.  import l2jorion.game.handler.item.ClanSkillsCustomItem;
  46.  import l2jorion.game.handler.item.CrystalCarol;
  47.  import l2jorion.game.handler.item.Crystals;
  48. -import l2jorion.game.handler.item.CustomAugmentationSystem;
  49.  import l2jorion.game.handler.item.CustomItemForFighter;
  50.  import l2jorion.game.handler.item.CustomItemForMage;
  51.  import l2jorion.game.handler.item.CustomPotions;
  52. @@ -40,6 +39,7 @@
  53.  import l2jorion.game.handler.item.HeroCustom365DaysItem;
  54.  import l2jorion.game.handler.item.HeroCustom7DaysItem;
  55.  import l2jorion.game.handler.item.HsItems;
  56. +import l2jorion.game.handler.item.Item_Recover;
  57.  import l2jorion.game.handler.item.JackpotSeed;
  58.  import l2jorion.game.handler.item.MOSKey;
  59.  import l2jorion.game.handler.item.MapForestOfTheDead;
  60. @@ -133,6 +133,7 @@
  61.         registerItemHandler(new BreakingArrow());
  62.         registerItemHandler(new ChristmasTree());
  63.         registerItemHandler(new Crystals());
  64. +       registerItemHandler(new Item_Recover());
  65.         registerItemHandler(new HsItems());
  66.         registerItemHandler(new ClanPointCustomItem());
  67.         registerItemHandler(new ClanSkillsCustomItem());
  68.  
  69.  
  70. diff --git files/game/config/main/L2jOrion.ini files/game/config/main/L2jOrion.ini
  71. index 32991a0..97ef069 100644
  72. --- files/game/config/main/L2jOrion.ini
  73. +++ files/game/config/main/L2jOrion.ini
  74. @@ -503,3 +503,11 @@
  75.  # ItemId
  76.  # Format: Id,min,max,chance;Id,min,max,chance
  77.  GlobalDropItem = 3470,10,15,100
  78. +
  79. +
  80. +#==========================================================================
  81. +#   BLACK COUPON RECOVERY 1 ITEM ENCHANT FAILED
  82. +#==========================================================================
  83. +
  84. +BlackCouponId = 6392
  85. +
  86. diff --git src/Base/Data/IconTable.java src/Base/Data/IconTable.java
  87. new file mode 100644
  88. index 0000000..fdce5d7
  89. --- /dev/null
  90. +++ src/Base/Data/IconTable.java
  91. @@ -0,0 +1,62 @@
  92. +package Base.Data;
  93. +
  94. +import java.io.File;
  95. +import java.util.HashMap;
  96. +import java.util.Map;
  97. +
  98. +import org.w3c.dom.Document;
  99. +import org.w3c.dom.NamedNodeMap;
  100. +import org.w3c.dom.Node;
  101. +
  102. +public class IconTable extends XMLDocument
  103. +{
  104. +   private static final Map<Integer, String> itemIcons = new HashMap<>();
  105. +  
  106. +   public IconTable()
  107. +   {
  108. +       load();
  109. +   }
  110. +  
  111. +   @Override
  112. +   protected void load()
  113. +   {
  114. +       loadDocument("./data/xml/icons.xml");
  115. +       LOG.info("Loaded " + itemIcons.size() + " icons.");
  116. +   }
  117. +  
  118. +   @Override
  119. +   protected void parseDocument(Document doc, File f)
  120. +   {
  121. +       // First element is never read.
  122. +       final Node n = doc.getFirstChild();
  123. +      
  124. +       for (Node o = n.getFirstChild(); o != null; o = o.getNextSibling())
  125. +       {
  126. +           if (!"icon".equalsIgnoreCase(o.getNodeName()))
  127. +           {
  128. +               continue;
  129. +           }
  130. +          
  131. +           final NamedNodeMap attrs = o.getAttributes();
  132. +           final int itemId = Integer.valueOf(attrs.getNamedItem("Id").getNodeValue());
  133. +           final String value = String.valueOf(attrs.getNamedItem("value").getNodeValue());
  134. +          
  135. +           itemIcons.put(itemId, value);
  136. +       }
  137. +   }
  138. +  
  139. +   public String getIcon(int id)
  140. +   {
  141. +       return itemIcons.get(id) == null ? "icon.noimage" : itemIcons.get(id);
  142. +   }
  143. +  
  144. +   public static IconTable getInstance()
  145. +   {
  146. +       return SingletonHolder._instance;
  147. +   }
  148. +  
  149. +   private static class SingletonHolder
  150. +   {
  151. +       protected static final IconTable _instance = new IconTable();
  152. +   }
  153. +}
  154. diff --git src/Base/Data/XMLDocument.java src/Base/Data/XMLDocument.java
  155. new file mode 100644
  156. index 0000000..476a41d
  157. --- /dev/null
  158. +++ src/Base/Data/XMLDocument.java
  159. @@ -0,0 +1,119 @@
  160. +package Base.Data;
  161. +
  162. +import java.io.File;
  163. +import java.util.logging.Level;
  164. +import java.util.logging.Logger;
  165. +
  166. +import javax.xml.parsers.DocumentBuilderFactory;
  167. +import javax.xml.transform.OutputKeys;
  168. +import javax.xml.transform.Transformer;
  169. +import javax.xml.transform.TransformerException;
  170. +import javax.xml.transform.TransformerFactory;
  171. +import javax.xml.transform.dom.DOMSource;
  172. +import javax.xml.transform.stream.StreamResult;
  173. +
  174. +import org.w3c.dom.Document;
  175. +import org.w3c.dom.NamedNodeMap;
  176. +import org.w3c.dom.Node;
  177. +
  178. +import l2jorion.game.templates.StatsSet;
  179. +
  180. +/**
  181. + * An XML document, relying on a static and single DocumentBuilderFactory.
  182. + */
  183. +public abstract class XMLDocument
  184. +{
  185. +   protected static final Logger LOG = Logger.getLogger(XMLDocument.class.getName());
  186. +  
  187. +   protected Document document;
  188. +  
  189. +   private static final DocumentBuilderFactory BUILDER;
  190. +   static
  191. +   {
  192. +       BUILDER = DocumentBuilderFactory.newInstance();
  193. +       BUILDER.setValidating(false);
  194. +       BUILDER.setIgnoringComments(true);
  195. +   }
  196. +  
  197. +   abstract protected void load();
  198. +  
  199. +   abstract protected void parseDocument(Document doc, File f);
  200. +  
  201. +   public void loadDocument(String filePath)
  202. +   {
  203. +       loadDocument(new File(filePath));
  204. +   }
  205. +  
  206. +   public void writeDocument(Document doc, String fileName)
  207. +   {
  208. +       try
  209. +       {
  210. +           TransformerFactory transformerFactory = TransformerFactory.newInstance();
  211. +           Transformer transformer = transformerFactory.newTransformer();
  212. +           transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
  213. +           transformer.setOutputProperty(OutputKeys.INDENT, "yes");
  214. +           transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "2");
  215. +          
  216. +           DOMSource source = new DOMSource(doc);
  217. +           StreamResult result = new StreamResult(new File(fileName));
  218. +          
  219. +           transformer.transform(source, result);
  220. +           LOG.info("XML file saved to " + fileName);
  221. +       }
  222. +       catch (TransformerException e)
  223. +       {
  224. +           LOG.warning("Error saving XML file: " + e.getMessage());
  225. +       }
  226. +   }
  227. +  
  228. +   /**
  229. +    * Parse an entire directory or file if found.
  230. +    * @param file
  231. +    */
  232. +   public void loadDocument(File file)
  233. +   {
  234. +       if (!file.exists())
  235. +       {
  236. +           LOG.severe("The following file or directory doesn't exist: " + file.getName());
  237. +           return;
  238. +       }
  239. +      
  240. +       if (file.isDirectory())
  241. +       {
  242. +           for (File f : file.listFiles())
  243. +           {
  244. +               loadDocument(f);
  245. +           }
  246. +       }
  247. +       else if (file.isFile())
  248. +       {
  249. +           try
  250. +           {
  251. +               parseDocument(BUILDER.newDocumentBuilder().parse(file), file);
  252. +           }
  253. +           catch (Exception e)
  254. +           {
  255. +               LOG.log(Level.SEVERE, "Error loading XML file " + file.getName(), e);
  256. +           }
  257. +       }
  258. +   }
  259. +  
  260. +   public Document getDocument()
  261. +   {
  262. +       return document;
  263. +   }
  264. +  
  265. +   /**
  266. +    * This method parses the content of a NamedNodeMap and feed the given StatsSet.
  267. +    * @param attrs : The NamedNodeMap to parse.
  268. +    * @param set : The StatsSet to feed.
  269. +    */
  270. +   public static void parseAndFeed(NamedNodeMap attrs, StatsSet set)
  271. +   {
  272. +       for (int i = 0; i < attrs.getLength(); i++)
  273. +       {
  274. +           final Node attr = attrs.item(i);
  275. +           set.set(attr.getNodeName(), attr.getNodeValue());
  276. +       }
  277. +   }
  278. +}
  279. diff --git src/Base/RecoverySystem/ItemRecoveryManager.java src/Base/RecoverySystem/ItemRecoveryManager.java
  280. new file mode 100644
  281. index 0000000..d6448d1
  282. --- /dev/null
  283. +++ src/Base/RecoverySystem/ItemRecoveryManager.java
  284. @@ -0,0 +1,271 @@
  285. +package Base.RecoverySystem;
  286. +
  287. +import java.sql.Connection;
  288. +import java.sql.PreparedStatement;
  289. +import java.sql.ResultSet;
  290. +import java.sql.SQLException;
  291. +import java.util.HashMap;
  292. +import java.util.Map;
  293. +
  294. +import l2jorion.Config;
  295. +import l2jorion.game.datatables.sql.ItemTable;
  296. +import l2jorion.game.model.actor.instance.L2ItemInstance;
  297. +import l2jorion.game.model.actor.instance.L2PcInstance;
  298. +import l2jorion.game.network.serverpackets.ItemList;
  299. +import l2jorion.util.database.L2DatabaseFactory;
  300. +
  301. +public class ItemRecoveryManager
  302. +{
  303. +   private Map<Integer, Integer> validEnchantLevels; // Almacena los niveles de enchant válidos para cada artículo recuperable
  304. +  
  305. +   public ItemRecoveryManager()
  306. +   {
  307. +       validEnchantLevels = new HashMap<>();
  308. +       loadValidEnchantLevels(); // Carga los niveles de enchant válidos desde la base de datos o cualquier otra fuente de datos
  309. +   }
  310. +  
  311. +   public void recoverSelectedItem(L2PcInstance player, int itemId, int enchantLevel)
  312. +   {
  313. +       // Comprueba si el jugador tiene suficientes items del ID 6392
  314. +       L2ItemInstance recoveryItem = player.getInventory().getItemByItemId(Config.BLACK_COUPON_ID);
  315. +       if (recoveryItem == null || recoveryItem.getCount() < 1)
  316. +       {
  317. +           player.sendMessage("No tienes suficientes items para recuperar este item.");
  318. +           return;
  319. +       }
  320. +      
  321. +       // Verifica el nivel de enchant del item recuperable en la base de datos
  322. +       if (!isValidEnchantLevel(itemId, enchantLevel, player.getObjectId()))
  323. +       {
  324. +           player.sendMessage("No puedes recuperar este item con ese nivel de enchant.");
  325. +           return;
  326. +       }
  327. +      
  328. +       // Verifica que el artículo que se está recuperando coincide con el artículo original
  329. +       if (!isValidRecoveryItem(itemId, player.getObjectId()))
  330. +       {
  331. +           player.sendMessage("No puedes recuperar este item.");
  332. +           return;
  333. +       }
  334. +      
  335. +       // Crea el item a recuperar con el ID y enchantLevel proporcionados
  336. +       L2ItemInstance recoveredItem = ItemTable.getInstance().createItem("RecoverItem", itemId, 1, player);
  337. +       recoveredItem.setEnchantLevel(enchantLevel);
  338. +      
  339. +       // Agrega el item recuperado al inventario del jugador
  340. +       player.getInventory().addItem("RecoverItem", recoveredItem, player, player);
  341. +      
  342. +       // Cobra 1 item del ID 6392
  343. +       player.getInventory().destroyItemByItemId("RecoveryCost", Config.BLACK_COUPON_ID, 1, player, player);
  344. +      
  345. +       // Elimina el item recuperado de la base de datos
  346. +       removeRecoverableItem(itemId, player.getObjectId());
  347. +      
  348. +       // Actualiza el inventario del jugador para que aparezca el item recuperado
  349. +       player.sendPacket(new ItemList(player, true));
  350. +      
  351. +       // Envía un mensaje al jugador con el nombre del item y su nivel de enchant
  352. +       String itemName = recoveredItem.getItemName();
  353. +       String message = "Has recuperado el item " + itemName;
  354. +       if (enchantLevel > 0)
  355. +       {
  356. +           message += " +" + enchantLevel;
  357. +       }
  358. +       player.sendMessage(message);
  359. +   }
  360. +  
  361. +   public boolean isValidRecoveryItem(int itemId, int objectId)
  362. +   {
  363. +       Connection con = null;
  364. +       PreparedStatement statement = null;
  365. +       ResultSet resultSet = null;
  366. +      
  367. +       try
  368. +       {
  369. +           con = L2DatabaseFactory.getInstance().getConnection();
  370. +           String sql = "SELECT item_id FROM item_recover WHERE object_id = ? AND item_id = ?";
  371. +           statement = con.prepareStatement(sql);
  372. +           statement.setInt(1, objectId);
  373. +           statement.setInt(2, itemId);
  374. +           resultSet = statement.executeQuery();
  375. +          
  376. +           return resultSet.next(); // Si hay un resultado, el artículo es válido
  377. +          
  378. +       }
  379. +       catch (SQLException e)
  380. +       {
  381. +           // Manejo de excepciones en caso de error al obtener el artículo recuperable de la base de datos
  382. +           e.printStackTrace();
  383. +       }
  384. +       finally
  385. +       {
  386. +           try
  387. +           {
  388. +               if (resultSet != null)
  389. +               {
  390. +                   resultSet.close();
  391. +               }
  392. +               if (statement != null)
  393. +               {
  394. +                   statement.close();
  395. +               }
  396. +               if (con != null)
  397. +               {
  398. +                   con.close();
  399. +               }
  400. +           }
  401. +           catch (SQLException e)
  402. +           {
  403. +               // Manejo de excepciones en caso de error al cerrar la conexión a la base de datos
  404. +               e.printStackTrace();
  405. +           }
  406. +       }
  407. +      
  408. +       return false; // Si ocurre alguna excepción o no se encuentra el artículo, se considera inválido
  409. +   }
  410. +  
  411. +   public boolean isValidEnchantLevel(int itemId, int enchantLevel, int objectId)
  412. +   {
  413. +       Connection con = null;
  414. +       PreparedStatement statement = null;
  415. +       ResultSet resultSet = null;
  416. +      
  417. +       try
  418. +       {
  419. +           con = L2DatabaseFactory.getInstance().getConnection();
  420. +           String sql = "SELECT enchant_level FROM item_recover WHERE object_id = ? AND item_id = ?";
  421. +           statement = con.prepareStatement(sql);
  422. +           statement.setInt(1, objectId);
  423. +           statement.setInt(2, itemId);
  424. +           resultSet = statement.executeQuery();
  425. +          
  426. +           if (resultSet.next())
  427. +           {
  428. +               int validEnchantLevel = resultSet.getInt("enchant_level");
  429. +               return enchantLevel == validEnchantLevel;
  430. +           }
  431. +       }
  432. +       catch (SQLException e)
  433. +       {
  434. +           // Manejo de excepciones en caso de error al obtener el nivel de enchant válido de la base de datos
  435. +           e.printStackTrace();
  436. +       }
  437. +       finally
  438. +       {
  439. +           try
  440. +           {
  441. +               if (resultSet != null)
  442. +               {
  443. +                   resultSet.close();
  444. +               }
  445. +               if (statement != null)
  446. +               {
  447. +                   statement.close();
  448. +               }
  449. +               if (con != null)
  450. +               {
  451. +                   con.close();
  452. +               }
  453. +           }
  454. +           catch (SQLException e)
  455. +           {
  456. +               // Manejo de excepciones en caso de error al cerrar la conexión a la base de datos
  457. +               e.printStackTrace();
  458. +           }
  459. +       }
  460. +      
  461. +       return false;
  462. +   }
  463. +  
  464. +   public void removeRecoverableItem(int itemId, int objectId)
  465. +   {
  466. +       Connection con = null;
  467. +       PreparedStatement statement = null;
  468. +      
  469. +       try
  470. +       {
  471. +           con = L2DatabaseFactory.getInstance().getConnection();
  472. +           String sql = "DELETE FROM item_recover WHERE item_id = ? AND object_id = ?";
  473. +           statement = con.prepareStatement(sql);
  474. +           statement.setInt(1, itemId);
  475. +           statement.setInt(2, objectId);
  476. +           statement.executeUpdate();
  477. +       }
  478. +       catch (SQLException e)
  479. +       {
  480. +           // Manejo de excepciones en caso de error al eliminar el item recuperable de la base de datos
  481. +           e.printStackTrace();
  482. +       }
  483. +       finally
  484. +       {
  485. +           try
  486. +           {
  487. +               if (statement != null)
  488. +               {
  489. +                   statement.close();
  490. +               }
  491. +               if (con != null)
  492. +               {
  493. +                   con.close();
  494. +               }
  495. +           }
  496. +           catch (SQLException e)
  497. +           {
  498. +               // Manejo de excepciones en caso de error al cerrar la conexión a la base de datos
  499. +               e.printStackTrace();
  500. +           }
  501. +       }
  502. +   }
  503. +  
  504. +   private void loadValidEnchantLevels()
  505. +   {
  506. +       Connection con = null;
  507. +       PreparedStatement statement = null;
  508. +       ResultSet resultSet = null;
  509. +      
  510. +       try
  511. +       {
  512. +           con = L2DatabaseFactory.getInstance().getConnection();
  513. +           String sql = "SELECT item_id, enchant_level FROM item_recover";
  514. +           statement = con.prepareStatement(sql);
  515. +           resultSet = statement.executeQuery();
  516. +          
  517. +           while (resultSet.next())
  518. +           {
  519. +               int itemId = resultSet.getInt("item_id");
  520. +               int enchantLevel = resultSet.getInt("enchant_level");
  521. +              
  522. +               validEnchantLevels.put(itemId, enchantLevel);
  523. +           }
  524. +       }
  525. +       catch (SQLException e)
  526. +       {
  527. +           // Manejo de excepciones en caso de error al obtener los niveles de enchant válidos de la base de datos
  528. +           e.printStackTrace();
  529. +       }
  530. +       finally
  531. +       {
  532. +           try
  533. +           {
  534. +               if (resultSet != null)
  535. +               {
  536. +                   resultSet.close();
  537. +               }
  538. +               if (statement != null)
  539. +               {
  540. +                   statement.close();
  541. +               }
  542. +               if (con != null)
  543. +               {
  544. +                   con.close();
  545. +               }
  546. +           }
  547. +           catch (SQLException e)
  548. +           {
  549. +               // Manejo de excepciones en caso de error al cerrar la conexión a la base de datos
  550. +               e.printStackTrace();
  551. +           }
  552. +       }
  553. +   }
  554. +  
  555. +}
  556. diff --git src/Base/RecoverySystem/RecoverableItem.java src/Base/RecoverySystem/RecoverableItem.java
  557. new file mode 100644
  558. index 0000000..22182f7
  559. --- /dev/null
  560. +++ src/Base/RecoverySystem/RecoverableItem.java
  561. @@ -0,0 +1,111 @@
  562. +package Base.RecoverySystem;
  563. +
  564. +import java.sql.Connection;
  565. +import java.sql.PreparedStatement;
  566. +import java.sql.SQLException;
  567. +
  568. +import l2jorion.game.datatables.sql.ItemTable;
  569. +import l2jorion.game.templates.L2Item;
  570. +import l2jorion.util.database.L2DatabaseFactory;
  571. +
  572. +public class RecoverableItem
  573. +{
  574. +   private int objectId;
  575. +   private int itemId;
  576. +   private String itemName;
  577. +   private int enchantLevel;
  578. +   private boolean selected; // New field for selection status
  579. +  
  580. +   public RecoverableItem(int objectId, int itemId, String itemName, int enchantLevel)
  581. +   {
  582. +       this.objectId = objectId;
  583. +       this.itemId = itemId;
  584. +       this.itemName = itemName;
  585. +       this.enchantLevel = enchantLevel;
  586. +       this.selected = false; // Default selection status is false
  587. +   }
  588. +  
  589. +   public int getObjectId()
  590. +   {
  591. +       return objectId;
  592. +   }
  593. +  
  594. +   public int getItemId()
  595. +   {
  596. +       return itemId;
  597. +   }
  598. +  
  599. +   public String getItemName()
  600. +   {
  601. +       return itemName;
  602. +   }
  603. +  
  604. +   public int getEnchantLevel()
  605. +   {
  606. +       return enchantLevel;
  607. +   }
  608. +  
  609. +   public void saveBrokenItemInfo()
  610. +   {
  611. +       Connection con = null;
  612. +       PreparedStatement statement = null;
  613. +      
  614. +       try
  615. +       {
  616. +           con = L2DatabaseFactory.getInstance().getConnection();
  617. +           String sql = "INSERT INTO item_recover (object_id, item_id, item_name, enchant_level) VALUES (?, ?, ?, ?)";
  618. +           statement = con.prepareStatement(sql);
  619. +           statement.setInt(1, objectId);
  620. +           statement.setInt(2, itemId);
  621. +           statement.setString(3, itemName);
  622. +           statement.setInt(4, enchantLevel);
  623. +           statement.execute();
  624. +       }
  625. +       catch (SQLException e)
  626. +       {
  627. +           // Manejo de excepciones en caso de error al guardar en la base de datos
  628. +           e.printStackTrace();
  629. +       }
  630. +       finally
  631. +       {
  632. +           // Cierra la conexión y el statement
  633. +           try
  634. +           {
  635. +               if (statement != null)
  636. +               {
  637. +                   statement.close();
  638. +               }
  639. +               if (con != null)
  640. +               {
  641. +                   con.close();
  642. +               }
  643. +           }
  644. +           catch (SQLException e)
  645. +           {
  646. +               // Manejo de excepciones en caso de error al cerrar la conexión
  647. +               e.printStackTrace();
  648. +           }
  649. +       }
  650. +   }
  651. +  
  652. +   public boolean isSelected()
  653. +   {
  654. +       return selected;
  655. +   }
  656. +  
  657. +   public void setSelected(boolean selected)
  658. +   {
  659. +       this.selected = selected;
  660. +   }
  661. +  
  662. +   public String getIcon()
  663. +   {
  664. +       return getItem().getIcon();
  665. +   }
  666. +  
  667. +   public L2Item getItem()
  668. +   {
  669. +       return ItemTable.getInstance().getTemplate(itemId);
  670. +   }
  671. +  
  672. +}
  673. diff --git src/l2jorion/Config.java src/l2jorion/Config.java
  674. index 922ad04..06bdba7 100644
  675. --- src/l2jorion/Config.java
  676. +++ src/l2jorion/Config.java
  677. @@ -2528,6 +2528,8 @@
  678.     public static List<Integer> GLOBAL_DROP_NPC_ID;
  679.     public static List<RewardHolder> GLOBAL_REWARD_ITEM;
  680.    
  681. +   public static int BLACK_COUPON_ID;
  682. +  
  683.     public static void loadL2jOrionConfig()
  684.     {
  685.         final String L2jOrion = ConfigLoader.L2jOrion_CONFIG_FILE;
  686. @@ -2546,6 +2548,9 @@
  687.             RED_SKY = Boolean.parseBoolean(L2jOrionSettings.getProperty("RedSky", "False"));
  688.             FREE_TELEPORT_UNTIL = Integer.parseInt(L2jOrionSettings.getProperty("FreeTeleportUntil", "1"));
  689.             REMOVAL_AUGMENTATION_FREE = Boolean.parseBoolean(L2jOrionSettings.getProperty("RemovalAugmentationFree", "False"));
  690. +          
  691. +           BLACK_COUPON_ID = Integer.parseInt(L2jOrionSettings.getProperty("BlackCouponId", "6392"));
  692. +          
  693.             ALLOW_FREIGHT_AUGMENTED = Boolean.parseBoolean(L2jOrionSettings.getProperty("AllowFreightAugmentedItem", "False"));
  694.             ANNOUNCE_BOSS_UNDER_ATTACK = Boolean.parseBoolean(L2jOrionSettings.getProperty("AnnounceBossUnderAttack", "False"));
  695.             LIVE_CASTING_CHECK = Boolean.parseBoolean(L2jOrionSettings.getProperty("LiveCastingCheck", "False"));
  696. diff --git src/l2jorion/game/GameServer.java src/l2jorion/game/GameServer.java
  697. index 52faa7e..543cccd 100644
  698. --- src/l2jorion/game/GameServer.java
  699. +++ src/l2jorion/game/GameServer.java
  700. @@ -11,6 +11,7 @@
  701.  import java.util.Date;
  702.  import java.util.logging.LogManager;
  703.  
  704. +import Base.Data.IconTable;
  705.  import l2jorion.Config;
  706.  import l2jorion.ConfigLoader;
  707.  import l2jorion.ServerType;
  708. @@ -495,6 +496,8 @@
  709.         VoicedCommandHandler.getInstance();
  710.         CommunityBoardManager.getInstance();
  711.        
  712. +       IconTable.getInstance();
  713. +      
  714.         LOG.info("AutoChatHandler: Loaded " + AutoChatHandler.getInstance().size() + " handlers");
  715.         LOG.info("AutoSpawnHandler: Loaded " + AutoSpawn.getInstance().size() + " handlers");
  716.        
  717. diff --git src/l2jorion/game/handler/item/Item_Recover.java src/l2jorion/game/handler/item/Item_Recover.java
  718. new file mode 100644
  719. index 0000000..2398bb3
  720. --- /dev/null
  721. +++ src/l2jorion/game/handler/item/Item_Recover.java
  722. @@ -0,0 +1,175 @@
  723. +package l2jorion.game.handler.item;
  724. +
  725. +import java.sql.Connection;
  726. +import java.sql.PreparedStatement;
  727. +import java.sql.ResultSet;
  728. +import java.sql.SQLException;
  729. +import java.util.ArrayList;
  730. +import java.util.List;
  731. +
  732. +import Base.RecoverySystem.RecoverableItem;
  733. +import l2jorion.Config;
  734. +import l2jorion.game.handler.IItemHandler;
  735. +import l2jorion.game.model.actor.instance.L2ItemInstance;
  736. +import l2jorion.game.model.actor.instance.L2PcInstance;
  737. +import l2jorion.game.model.actor.instance.L2PlayableInstance;
  738. +import l2jorion.game.network.serverpackets.ActionFailed;
  739. +import l2jorion.game.network.serverpackets.NpcHtmlMessage;
  740. +import l2jorion.util.database.L2DatabaseFactory;
  741. +
  742. +/**
  743. + * @author Terius
  744. + */
  745. +public class Item_Recover implements IItemHandler
  746. +{
  747. +   private static final int[] ITEM_IDS = new int[]
  748. +   {
  749. +       Config.BLACK_COUPON_ID
  750. +   };
  751. +  
  752. +   @Override
  753. +   public void useItem(L2PlayableInstance playable, L2ItemInstance item)
  754. +   {
  755. +       if (!(playable instanceof L2PcInstance))
  756. +       {
  757. +           return;
  758. +       }
  759. +      
  760. +       L2PcInstance activeChar = (L2PcInstance) playable;
  761. +      
  762. +       // Abre la ventana de recuperación y muestra los últimos 10 items recuperables
  763. +       openRecoveryWindow(activeChar);
  764. +   }
  765. +  
  766. +   private static void openRecoveryWindow(L2PcInstance player)
  767. +   {
  768. +       // Obtén los últimos 10 items recuperables de la base de datos para el object_id del jugador
  769. +       List<RecoverableItem> recoverableItems = getRecoverableItems(player.getObjectId());
  770. +      
  771. +       // Verifica si hay items recuperables
  772. +       if (recoverableItems.isEmpty())
  773. +       {
  774. +           // No hay items recuperables, muestra un mensaje al jugador
  775. +           player.sendMessage("No hay items recuperables disponibles.");
  776. +           return;
  777. +       }
  778. +      
  779. +       // Crea una instancia de NpcHtmlMessage para mostrar la ventana
  780. +       NpcHtmlMessage html = new NpcHtmlMessage(1);
  781. +      
  782. +       // Genera el contenido HTML de la ventana con la lista de los últimos 10 items recuperables
  783. +       String content = generateRecoveryList(recoverableItems);
  784. +       html.setHtml(content);
  785. +      
  786. +       // Envía la ventana al jugador
  787. +       player.sendPacket(html);
  788. +       player.sendPacket(ActionFailed.STATIC_PACKET);
  789. +   }
  790. +  
  791. +   @Override
  792. +   public int[] getItemIds()
  793. +   {
  794. +       return ITEM_IDS;
  795. +   }
  796. +  
  797. +   private static String generateRecoveryList(List<RecoverableItem> recoverableItems)
  798. +   {
  799. +      
  800. +       // Genera el contenido HTML de la ventana con la lista de los últimos 10 items recuperables
  801. +       StringBuilder sb = new StringBuilder();
  802. +       sb.append("<html><body><center><font color=\"LEVEL\">Items Recuperables</font><br><br>");
  803. +      
  804. +       // Mensaje de advertencia sobre la recuperación de solo 1 item a la vez
  805. +       sb.append("<font color=\"FF0000\">Solo puedes recuperar 1 item a la vez.</font><br>");
  806. +      
  807. +       // Itera sobre los items recuperables
  808. +       for (RecoverableItem item : recoverableItems)
  809. +       {
  810. +           sb.append("<img src=\"L2UI.SquareGray\" width=295 height=1>");
  811. +           sb.append("<table>");
  812. +          
  813. +           sb.append("<tr>");
  814. +           sb.append("<td>");
  815. +           sb.append("<img src=\"").append(item.getIcon()).append("\" width=32 height=32>");
  816. +           sb.append("</td>");
  817. +           sb.append("<td width=210><font color=\"FFFFFF\">").append(item.getItemName()).append("</font>");
  818. +          
  819. +           int enchantLevel = item.getEnchantLevel();
  820. +           if (enchantLevel > 0)
  821. +           {
  822. +               sb.append(" <font color=\"00FF00\">+").append(enchantLevel).append("</font>");
  823. +           }
  824. +          
  825. +           sb.append("</td>");
  826. +          
  827. +           int itemId = item.getItemId();
  828. +           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>");
  829. +          
  830. +           sb.append("</tr>");
  831. +          
  832. +           sb.append("</table>");
  833. +           sb.append("<img src=\"L2UI.SquareGray\" width=295 height=1>");
  834. +           sb.append("<br>"); // Agrega un espacio después de cada tabla
  835. +       }
  836. +      
  837. +       sb.append("</center></body></html>");
  838. +       return sb.toString();
  839. +   }
  840. +  
  841. +   private static List<RecoverableItem> getRecoverableItems(int objectId)
  842. +   {
  843. +       List<RecoverableItem> recoverableItems = new ArrayList<>();
  844. +       Connection con = null;
  845. +       PreparedStatement statement = null;
  846. +       ResultSet resultSet = null;
  847. +      
  848. +       try
  849. +       {
  850. +           con = L2DatabaseFactory.getInstance().getConnection();
  851. +           String sql = "SELECT item_id, item_name, enchant_level FROM item_recover WHERE object_id = ? ORDER BY id DESC LIMIT 10";
  852. +           statement = con.prepareStatement(sql);
  853. +           statement.setInt(1, objectId);
  854. +           resultSet = statement.executeQuery();
  855. +          
  856. +           while (resultSet.next())
  857. +           {
  858. +               int itemId = resultSet.getInt("item_id");
  859. +               String itemName = resultSet.getString("item_name");
  860. +               int enchantLevel = resultSet.getInt("enchant_level");
  861. +              
  862. +               RecoverableItem item = new RecoverableItem(objectId, itemId, itemName, enchantLevel);
  863. +               recoverableItems.add(item);
  864. +           }
  865. +       }
  866. +       catch (SQLException e)
  867. +       {
  868. +           // Manejo de excepciones en caso de error al obtener los items recuperables de la base de datos
  869. +           e.printStackTrace();
  870. +       }
  871. +       finally
  872. +       {
  873. +           try
  874. +           {
  875. +               if (resultSet != null)
  876. +               {
  877. +                   resultSet.close();
  878. +               }
  879. +               if (statement != null)
  880. +               {
  881. +                   statement.close();
  882. +               }
  883. +               if (con != null)
  884. +               {
  885. +                   con.close();
  886. +               }
  887. +           }
  888. +           catch (SQLException e)
  889. +           {
  890. +               // Manejo de excepciones en caso de error al cerrar la conexión a la base de datos
  891. +               e.printStackTrace();
  892. +           }
  893. +       }
  894. +      
  895. +       return recoverableItems;
  896. +   }
  897. +}
  898. diff --git src/l2jorion/game/network/clientpackets/RequestBypassToServer.java src/l2jorion/game/network/clientpackets/RequestBypassToServer.java
  899. index d48c078..88e85e4 100644
  900. --- src/l2jorion/game/network/clientpackets/RequestBypassToServer.java
  901. +++ src/l2jorion/game/network/clientpackets/RequestBypassToServer.java
  902. @@ -26,6 +26,7 @@
  903.  import java.util.stream.Collectors;
  904.  import java.util.stream.Stream;
  905.  
  906. +import Base.RecoverySystem.ItemRecoveryManager;
  907.  import javolution.text.TextBuilder;
  908.  import l2jorion.Config;
  909.  import l2jorion.game.cache.HtmCache;
  910. @@ -592,6 +593,20 @@
  911.                     LOG.info(this.getClass().getSimpleName() + ": (" + activeChar.getName() + ") error: " + e);
  912.                 }
  913.             }
  914. +          
  915. +           else if (bp.bypass.startsWith("recoverSelectedItem"))
  916. +           {
  917. +               String[] bypassParts = bp.bypass.split(" ");
  918. +               if (bypassParts.length >= 3)
  919. +               {
  920. +                   int itemId = Integer.parseInt(bypassParts[1]);
  921. +                   int enchantLevel = Integer.parseInt(bypassParts[2]);
  922. +                  
  923. +                   ItemRecoveryManager itemRecoveryManager = new ItemRecoveryManager();
  924. +                   itemRecoveryManager.recoverSelectedItem(activeChar, itemId, enchantLevel);
  925. +               }
  926. +           }
  927. +          
  928.             else if (bp.bypass.equals("Draw"))
  929.             {
  930.                 L2Object object = activeChar.getTarget();
  931. diff --git src/l2jorion/game/network/clientpackets/RequestEnchantItem.java src/l2jorion/game/network/clientpackets/RequestEnchantItem.java
  932. index fb6a5cb..e775287 100644
  933. --- src/l2jorion/game/network/clientpackets/RequestEnchantItem.java
  934. +++ src/l2jorion/game/network/clientpackets/RequestEnchantItem.java
  935. @@ -17,6 +17,10 @@
  936.   */
  937.  package l2jorion.game.network.clientpackets;
  938.  
  939. +import java.sql.Connection;
  940. +import java.sql.PreparedStatement;
  941. +import java.sql.SQLException;
  942. +
  943.  import l2jorion.Config;
  944.  import l2jorion.game.datatables.xml.AugmentationData;
  945.  import l2jorion.game.datatables.xml.AugmentationScrollData;
  946. @@ -43,6 +47,7 @@
  947.  import l2jorion.game.util.Util;
  948.  import l2jorion.logger.Logger;
  949.  import l2jorion.logger.LoggerFactory;
  950. +import l2jorion.util.database.L2DatabaseFactory;
  951.  import l2jorion.util.random.Rnd;
  952.  
  953.  public final class RequestEnchantItem extends PacketClient
  954. @@ -826,6 +831,10 @@
  955.                         activeChar.sendPacket(sm);
  956.                     }
  957.                     activeChar.getAchievement().increase(AchType.ENCHANT_FAILED);
  958. +                  
  959. +                   // Agrega el código para guardar la información del item roto en la tabla de la base de datos
  960. +                   saveBrokenItemInfo(activeChar.getObjectId(), item.getItemId(), item.getItemName(), item.getEnchantLevel(), item.getItem().getItemType().name());
  961. +                  
  962.                 }
  963.                
  964.                 if (!blessedScroll && !crystalScroll)
  965. @@ -1077,6 +1086,50 @@
  966.         }
  967.     }
  968.    
  969. +   private void saveBrokenItemInfo(int objectId, int itemId, String itemName, int enchantLevel, String itemType)
  970. +   {
  971. +       Connection con = null;
  972. +       PreparedStatement statement = null;
  973. +      
  974. +       try
  975. +       {
  976. +           con = L2DatabaseFactory.getInstance().getConnection();
  977. +           String sql = "INSERT INTO item_recover (object_id, item_id, item_name, enchant_level, item_type) VALUES (?, ?, ?, ?, ?)";
  978. +           statement = con.prepareStatement(sql);
  979. +           statement.setInt(1, objectId);
  980. +           statement.setInt(2, itemId);
  981. +           statement.setString(3, itemName);
  982. +           statement.setInt(4, enchantLevel);
  983. +           statement.setString(5, itemType);
  984. +           statement.execute();
  985. +       }
  986. +       catch (SQLException e)
  987. +       {
  988. +           // Manejo de excepciones en caso de error al guardar en la base de datos
  989. +           e.printStackTrace();
  990. +       }
  991. +       finally
  992. +       {
  993. +           // Cierra la conexión y el statement
  994. +           try
  995. +           {
  996. +               if (statement != null)
  997. +               {
  998. +                   statement.close();
  999. +               }
  1000. +               if (con != null)
  1001. +               {
  1002. +                   con.close();
  1003. +               }
  1004. +           }
  1005. +           catch (SQLException e)
  1006. +           {
  1007. +               // Manejo de excepciones en caso de error al cerrar la conexión
  1008. +               e.printStackTrace();
  1009. +           }
  1010. +       }
  1011. +   }
  1012. +  
  1013.     @Override
  1014.     public String getType()
  1015.     {
  1016. diff --git src/l2jorion/game/templates/L2Item.java src/l2jorion/game/templates/L2Item.java
  1017. index 5a2ada5..2656f9b 100644
  1018. --- src/l2jorion/game/templates/L2Item.java
  1019. +++ src/l2jorion/game/templates/L2Item.java
  1020. @@ -27,6 +27,7 @@
  1021.  import java.util.List;
  1022.  import java.util.Map;
  1023.  
  1024. +import Base.Data.IconTable;
  1025.  import javolution.util.FastList;
  1026.  import l2jorion.Config;
  1027.  import l2jorion.game.datatables.sql.ItemTable;
  1028. @@ -591,4 +592,9 @@
  1029.             CloseUtil.close(con);
  1030.         }
  1031.     }
  1032. +  
  1033. +   public String getIcon()
  1034. +   {
  1035. +       return IconTable.getInstance().getIcon(getItemId());
  1036. +   }
  1037.  }
  1038.  
  1039.  
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!