API tools faq
paste
Guest User

wh sorting!

a guest
Oct 28th, 2011
394
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 40.51 KB | None | 0 0
raw download clone embed print report
  1. Index: /l2j-private/l2j-private/java/com/l2jarchid/Config.java
  2. ===================================================================
  3. --- /l2j-private/l2j-private/java/com/l2jarchid/Config.java (revision 301)
  4. +++ /l2j-private/l2j-private/java/com/l2jarchid/Config.java (revision 310)
  5. @@ -2110,4 +2110,6 @@
  6.     public static float         POLE_VS_ROBE;
  7.     public static boolean       L2F_SAVE_BUFF_AFTER_DEATH;
  8. +    public static boolean  L2F_ENABLE_WAREHOUSESORTING;   
  9. +  
  10.     // *******************************************************************************************
  11.     public static void loadL2JArchidConfig()
  12. @@ -2383,4 +2385,8 @@
  13.             L2F_SAVE_BUFF_AFTER_DEATH = Boolean.parseBoolean(L2JArchidSettings.getProperty("SaveBuffsAfterDeath", "False"));
  14.            
  15. +           L2F_ENABLE_WAREHOUSESORTING     = Boolean.valueOf(L2JArchidSettings.getProperty("EnableWarehouseSorting", "False"));
  16. +            
  17. +            
  18. +          
  19.            
  20.         }
  21. Index: /l2j-private/l2j-private/java/com/l2jarchid/gameserver/network/serverpackets/SortedWareHouseWithdrawalList.java
  22. ===================================================================
  23. --- /l2j-private/l2j-private/java/com/l2jarchid/gameserver/network/serverpackets/SortedWareHouseWithdrawalList.java (revision 310)
  24. +++ /l2j-private/l2j-private/java/com/l2jarchid/gameserver/network/serverpackets/SortedWareHouseWithdrawalList.java (revision 310)
  25. @@ -0,0 +1,731 @@
  26. +/*
  27. + * This program is free software; you can redistribute it and/or modify
  28. + * it under the terms of the GNU General Public License as published by
  29. + * the Free Software Foundation; either version 2, or (at your option)
  30. + * any later version.
  31. + *
  32. + * This program is distributed in the hope that it will be useful,
  33. + * but WITHOUT ANY WARRANTY; without even the implied warranty of
  34. + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  35. + * GNU General Public License for more details.
  36. + *
  37. + * You should have received a copy of the GNU General Public License
  38. + * along with this program; if not, write to the Free Software
  39. + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  40. + * 02111-1307, USA.
  41. + *
  42. + * http://www.gnu.org/copyleft/gpl.html
  43. + */
  44. +package com.l2jarchid.gameserver.network.serverpackets;
  45. +
  46. +import java.util.Collections;
  47. +import java.util.Comparator;
  48. +import java.util.List;
  49. +import java.util.logging.Logger;
  50. +
  51. +import javolution.util.FastList;
  52. +import com.l2jarchid.gameserver.RecipeController;
  53. +import com.l2jarchid.gameserver.model.L2ItemInstance;
  54. +import com.l2jarchid.gameserver.model.L2RecipeList;
  55. +import com.l2jarchid.gameserver.model.actor.instance.L2PcInstance;
  56. +import com.l2jarchid.gameserver.templates.L2EtcItemType;
  57. +import com.l2jarchid.gameserver.templates.L2Item;
  58. +import com.l2jarchid.gameserver.templates.L2WarehouseItem;
  59. +
  60. +/**
  61. + * 0x42 WarehouseWithdrawalList  dh (h dddhh dhhh d)
  62. + *
  63. + * @version $Revision: 1.3.2.1.2.5 $ $Date: 2005/03/29 23:15:10 $
  64. + */
  65. +
  66. +public class SortedWareHouseWithdrawalList extends L2GameServerPacket
  67. +{
  68. +   public static final int PRIVATE = 1;
  69. +   public static final int CLAN = 2;
  70. +   public static final int CASTLE = 3; //not sure
  71. +   public static final int FREIGHT = 4; //not sure
  72. +   private static Logger _log = Logger.getLogger(SortedWareHouseWithdrawalList.class.getName());
  73. +   private static final String _S__54_SORTEDWAREHOUSEWITHDRAWALLIST = "[S] 42 SortedWareHouseWithdrawalList";
  74. +   private L2PcInstance _activeChar;
  75. +   private int _playerAdena;
  76. +   private List<L2WarehouseItem> _objects = new FastList<L2WarehouseItem>();
  77. +   private int _whType;
  78. +   private byte _sortorder;
  79. +   private WarehouseListType _itemtype;
  80. +  
  81. +   public static enum WarehouseListType
  82. +    {
  83. +        WEAPON,
  84. +        ARMOR,
  85. +        ETCITEM,
  86. +        MATERIAL,
  87. +        RECIPE,
  88. +        AMULETT,
  89. +        SPELLBOOK,
  90. +        SHOT,
  91. +        SCROLL,
  92. +        CONSUMABLE,
  93. +        SEED,
  94. +        POTION,
  95. +        QUEST,
  96. +        PET,
  97. +        OTHER,
  98. +        ALL
  99. +    }
  100. +  
  101. +   /** sort order A..Z */
  102. +    public static final byte A2Z = 1;
  103. +    /** sort order Z..A */
  104. +    public static final byte Z2A = -1;
  105. +    /** sort order Grade non..S */
  106. +    public static final byte GRADE = 2;
  107. +    /** sort order Recipe Level 1..9 */
  108. +    public static final byte LEVEL = 3;
  109. +    /** sort order type */
  110. +    public static final byte TYPE = 4;
  111. +    /** sort order body part (wearing) */
  112. +    public static final byte WEAR = 5;
  113. +    /** Maximum Items to put into list */
  114. +    public static final int MAX_SORT_LIST_ITEMS = 300;
  115. +    
  116. +    private int ENDmarker = 0x00;
  117. +
  118. +    /**
  119. +     * This will instantiate the Warehouselist the Player asked for
  120. +     * @param player who calls for the itemlist
  121. +     * @param type is the Warehouse Type
  122. +     * @param itemtype is the Itemtype to sort for
  123. +     * @param sortorder is the integer Sortorder like 1 for A..Z (use public constant)
  124. +     */
  125. +   public SortedWareHouseWithdrawalList(L2PcInstance player, int type, WarehouseListType itemtype, byte sortorder)
  126. +   {
  127. +        _activeChar = player;
  128. +       _whType = type;
  129. +        _itemtype = itemtype;
  130. +        _sortorder = sortorder;
  131. +
  132. +        _playerAdena = _activeChar.getAdena();
  133. +        if (_activeChar.getActiveWarehouse() == null)
  134. +        {
  135. +            // Something went wrong!
  136. +            _log.warning("error while sending withdraw request to: " + _activeChar.getName());
  137. +            return;
  138. +        }
  139. +
  140. +        switch (_itemtype)
  141. +        {
  142. +            case WEAPON:
  143. +                _objects = createWeaponList(_activeChar.getActiveWarehouse().getItems());
  144. +                break;
  145. +            case ARMOR:
  146. +                _objects = createArmorList(_activeChar.getActiveWarehouse().getItems());
  147. +                break;
  148. +            case ETCITEM:
  149. +                _objects = createEtcItemList(_activeChar.getActiveWarehouse().getItems());
  150. +                break;
  151. +            case MATERIAL:
  152. +                _objects = createMatList(_activeChar.getActiveWarehouse().getItems());
  153. +                break;
  154. +            case RECIPE:
  155. +                _objects = createRecipeList(_activeChar.getActiveWarehouse().getItems());
  156. +                break;
  157. +            case AMULETT:
  158. +                _objects = createAmulettList(_activeChar.getActiveWarehouse().getItems());
  159. +                break;
  160. +            case SPELLBOOK:
  161. +                _objects = createSpellbookList(_activeChar.getActiveWarehouse().getItems());
  162. +                break;
  163. +            case CONSUMABLE:
  164. +                _objects = createConsumableList(_activeChar.getActiveWarehouse().getItems());
  165. +                break;
  166. +            case SHOT:
  167. +                _objects = createShotList(_activeChar.getActiveWarehouse().getItems());
  168. +                break;
  169. +            case SCROLL:
  170. +                _objects = createScrollList(_activeChar.getActiveWarehouse().getItems());
  171. +                break;
  172. +            case SEED:
  173. +                _objects = createSeedList(_activeChar.getActiveWarehouse().getItems());
  174. +                break;
  175. +            case OTHER:
  176. +                _objects = createOtherList(_activeChar.getActiveWarehouse().getItems());
  177. +                break;
  178. +            case ALL:
  179. +                default:
  180. +                    _objects = createAllList(_activeChar.getActiveWarehouse().getItems());
  181. +                break;
  182. +        }
  183. +
  184. +        try
  185. +        {
  186. +            switch (_sortorder)
  187. +            {
  188. +                case A2Z:
  189. +                case Z2A:
  190. +                    Collections.sort(_objects, new WarehouseItemNameComparator(_sortorder));
  191. +                    break;
  192. +                case GRADE:
  193. +                    if (_itemtype == WarehouseListType.ARMOR || _itemtype == WarehouseListType.WEAPON)
  194. +                    {
  195. +                        Collections.sort(_objects, new WarehouseItemNameComparator(A2Z));
  196. +                        Collections.sort(_objects, new WarehouseItemGradeComparator(A2Z));
  197. +                    }
  198. +                    break;
  199. +                case LEVEL:
  200. +                    if (_itemtype == WarehouseListType.RECIPE)
  201. +                    {
  202. +                        Collections.sort(_objects, new WarehouseItemNameComparator(A2Z));
  203. +                        Collections.sort(_objects, new WarehouseItemRecipeComparator(A2Z));
  204. +                    }
  205. +                    break;
  206. +                case TYPE:
  207. +                    if (_itemtype==WarehouseListType.MATERIAL)
  208. +                    {
  209. +                        Collections.sort(_objects, new WarehouseItemNameComparator(A2Z));
  210. +                        Collections.sort(_objects, new WarehouseItemTypeComparator(A2Z));
  211. +                    }
  212. +                    break;
  213. +                case WEAR:
  214. +                    if (_itemtype==WarehouseListType.ARMOR)
  215. +                    {
  216. +                        Collections.sort(_objects, new WarehouseItemNameComparator(A2Z));
  217. +                        Collections.sort(_objects, new WarehouseItemBodypartComparator(A2Z));
  218. +                    }
  219. +                    break;
  220. +            }
  221. +        }
  222. +        catch(Exception e) {}
  223. +    }
  224. +  
  225. +   /**
  226. +     * This public method return the integer of the Sortorder by its name.
  227. +     * If you want to have another, add the Comparator and the Constant.
  228. +     * @param order
  229. +     * @return the integer of the sortorder or 1 as default value
  230. +     */
  231. +    public static byte getOrder(String order)
  232. +    {
  233. +        if (order == null)
  234. +            return A2Z;
  235. +        else if (order.startsWith("A2Z"))
  236. +            return A2Z;
  237. +        else if (order.startsWith("Z2A"))
  238. +            return Z2A;
  239. +        else if (order.startsWith("GRADE"))
  240. +            return GRADE;
  241. +        else if (order.startsWith("TYPE"))
  242. +            return TYPE;
  243. +        else if (order.startsWith("WEAR"))
  244. +            return WEAR;
  245. +        else
  246. +        {
  247. +            try
  248. +            {
  249. +                return Byte.parseByte(order);
  250. +            }
  251. +            catch (NumberFormatException ex) {return A2Z;}
  252. +        }
  253. +    }
  254. +
  255. +    /**
  256. +     * This is the common Comparator to sort the items by Name
  257. +     */
  258. +    private static class WarehouseItemNameComparator implements Comparator<L2WarehouseItem>
  259. +    {
  260. +        private byte order = 0;
  261. +        
  262. +        protected WarehouseItemNameComparator(byte sortOrder)
  263. +        {
  264. +            order = sortOrder;
  265. +        }
  266. +        
  267. +        public int compare(L2WarehouseItem o1, L2WarehouseItem o2)
  268. +        {
  269. +            if (o1.getType2() == L2Item.TYPE2_MONEY && o2.getType2() != L2Item.TYPE2_MONEY)
  270. +                return (order == A2Z ? Z2A : A2Z);
  271. +            if (o2.getType2() == L2Item.TYPE2_MONEY && o1.getType2() != L2Item.TYPE2_MONEY)
  272. +                return (order == A2Z ? A2Z : Z2A);
  273. +            String s1 = o1.getItemName();
  274. +            String s2 = o2.getItemName();
  275. +            return (order == A2Z ? s1.compareTo(s2) : s2.compareTo(s1));
  276. +        }
  277. +    }
  278. +
  279. +    /**
  280. +     * This Comparator is used to sort by Recipe Level
  281. +     */
  282. +    private static class WarehouseItemRecipeComparator implements Comparator<L2WarehouseItem>
  283. +    {
  284. +        private int order = 0;
  285. +
  286. +        private RecipeController rc = null;
  287. +
  288. +        protected WarehouseItemRecipeComparator(int sortOrder)
  289. +        {
  290. +            order = sortOrder;
  291. +            rc = RecipeController.getInstance();
  292. +        }
  293. +
  294. +        public int compare(L2WarehouseItem o1, L2WarehouseItem o2)
  295. +        {
  296. +            if (o1.getType2() == L2Item.TYPE2_MONEY && o2.getType2() != L2Item.TYPE2_MONEY)
  297. +                return (order == A2Z ? Z2A : A2Z);
  298. +            if (o2.getType2() == L2Item.TYPE2_MONEY && o1.getType2() != L2Item.TYPE2_MONEY)
  299. +                return (order == A2Z ? A2Z : Z2A);
  300. +            if ((o1.isEtcItem() && o1.getItemType() == L2EtcItemType.RECEIPE) && (o2.isEtcItem() && o2.getItemType() == L2EtcItemType.RECEIPE))
  301. +            {
  302. +                try
  303. +                {
  304. +                    L2RecipeList rp1 = rc.getRecipeByItemId(o1.getItemId());
  305. +                    L2RecipeList rp2 = rc.getRecipeByItemId(o2.getItemId());
  306. +
  307. +                    if (rp1 == null) return (order == A2Z ? A2Z : Z2A);
  308. +                    if (rp2 == null) return (order == A2Z ? Z2A : A2Z);
  309. +
  310. +                    Integer i1 = rp1.getLevel();
  311. +                    Integer i2 = rp2.getLevel();
  312. +
  313. +                    return (order == A2Z ? i1.compareTo(i2) : i2.compareTo(i1));
  314. +                }
  315. +                catch(Exception e) {return 0;}
  316. +            }
  317. +            else
  318. +            {
  319. +                String s1 = o1.getItemName();
  320. +                String s2 = o2.getItemName();
  321. +                return (order == A2Z ? s1.compareTo(s2) : s2.compareTo(s1));
  322. +            }
  323. +        }
  324. +    }
  325. +
  326. +    /**
  327. +     * This Comparator is used to sort the Items by BodyPart
  328. +     */
  329. +    private static class WarehouseItemBodypartComparator implements Comparator<L2WarehouseItem>
  330. +    {
  331. +        private byte order = 0;
  332. +
  333. +        protected WarehouseItemBodypartComparator(byte sortOrder)
  334. +        {
  335. +            order = sortOrder;
  336. +        }
  337. +
  338. +        public int compare(L2WarehouseItem o1, L2WarehouseItem o2)
  339. +        {
  340. +            if (o1.getType2() == L2Item.TYPE2_MONEY && o2.getType2() != L2Item.TYPE2_MONEY)
  341. +                return (order==A2Z ? Z2A : A2Z);
  342. +            if (o2.getType2() == L2Item.TYPE2_MONEY && o1.getType2() != L2Item.TYPE2_MONEY)
  343. +                return (order==A2Z ? A2Z : Z2A);
  344. +            Integer i1 = o1.getBodyPart();
  345. +            Integer i2 = o2.getBodyPart();
  346. +            return (order == A2Z ? i1.compareTo(i2) : i2.compareTo(i1));
  347. +        }
  348. +    }
  349. +
  350. +    /**
  351. +     * This Comparator is used to sort by the Item Grade (e.g. Non..S-Grade)
  352. +     */
  353. +    private static class WarehouseItemGradeComparator implements Comparator<L2WarehouseItem>
  354. +    {
  355. +        byte order = 0;
  356. +
  357. +        protected WarehouseItemGradeComparator(byte sortOrder)
  358. +        {
  359. +            order = sortOrder;
  360. +        }
  361. +
  362. +        public int compare(L2WarehouseItem o1, L2WarehouseItem o2)
  363. +        {
  364. +            if (o1.getType2() == L2Item.TYPE2_MONEY && o2.getType2() != L2Item.TYPE2_MONEY)
  365. +                return (order == A2Z ? Z2A : A2Z);
  366. +            if (o2.getType2() == L2Item.TYPE2_MONEY && o1.getType2() != L2Item.TYPE2_MONEY)
  367. +                return (order ==A2Z ? A2Z : Z2A);
  368. +            Integer i1 = o1.getItemGrade();
  369. +            Integer i2 = o2.getItemGrade();
  370. +            return (order == A2Z ? i1.compareTo(i2) : i2.compareTo(i1));
  371. +        }
  372. +    }
  373. +
  374. +    /**
  375. +     * This Comparator will sort by Item Type. Unfortunatly this will only have a
  376. +     * good result if the Database Table for the ETCITEM.TYPE column is fixed!
  377. +     */
  378. +    private static class WarehouseItemTypeComparator implements Comparator<L2WarehouseItem>
  379. +    {
  380. +        byte order = 0;
  381. +
  382. +        protected WarehouseItemTypeComparator(byte sortOrder)
  383. +        {
  384. +            order = sortOrder;
  385. +        }
  386. +
  387. +        public int compare(L2WarehouseItem o1, L2WarehouseItem o2)
  388. +        {
  389. +            if (o1.getType2() == L2Item.TYPE2_MONEY && o2.getType2() != L2Item.TYPE2_MONEY)
  390. +                return (order == A2Z ? Z2A : A2Z);
  391. +            if (o2.getType2() == L2Item.TYPE2_MONEY && o1.getType2() != L2Item.TYPE2_MONEY)
  392. +                return (order== A2Z ? A2Z : Z2A);
  393. +            try
  394. +            {
  395. +                Integer i1 = o1.getItem().getMaterialType();
  396. +                Integer i2 = o2.getItem().getMaterialType();
  397. +                return (order==A2Z ? i1.compareTo(i2) : i2.compareTo(i1));
  398. +            }
  399. +            catch(Exception e) {return 0;}
  400. +        }
  401. +    }
  402. +
  403. +    // ========================================================================
  404. +
  405. +    /**
  406. +     * This method is used to limit the given Warehouse List to:
  407. +     * <li>Weapon</li>
  408. +     * <li>Arrow</li>
  409. +     * <li>Money</li>
  410. +     * @param _items complete Warehouse List
  411. +     * @return limited Item List
  412. +     */
  413. +    private List<L2WarehouseItem> createWeaponList(L2ItemInstance[] _items)
  414. +    {
  415. +        List<L2WarehouseItem> _list = new FastList<L2WarehouseItem>();
  416. +        for (L2ItemInstance item : _items)
  417. +        {
  418. +            if (item.isWeapon() || item.getItem().getType2() == L2Item.TYPE2_WEAPON || (item.isEtcItem() && item.getItemType() == L2EtcItemType.ARROW) || item.getItem().getType2() == L2Item.TYPE2_MONEY )
  419. +            {
  420. +                if (_list.size() < MAX_SORT_LIST_ITEMS)
  421. +                    _list.add(new L2WarehouseItem(item));
  422. +                else
  423. +                    continue;
  424. +            }
  425. +        }
  426. +        return _list;
  427. +    }
  428. +
  429. +    /**
  430. +     * This method is used to limit the given Warehouse List to:
  431. +     * <li>Armor</li>
  432. +     * <li>Money</li>
  433. +     * @param _items complete Warehouse List
  434. +     * @return limited Item List
  435. +     */
  436. +    private List<L2WarehouseItem> createArmorList(L2ItemInstance[] _items)
  437. +    {
  438. +        List<L2WarehouseItem> _list = new FastList<L2WarehouseItem>();
  439. +        for (L2ItemInstance item : _items)
  440. +        {
  441. +            if (item.isArmor() || item.getItem().getType2() == L2Item.TYPE2_MONEY)
  442. +            {
  443. +                if (_list.size() < MAX_SORT_LIST_ITEMS)
  444. +                    _list.add(new L2WarehouseItem(item));
  445. +                else
  446. +                    continue;
  447. +            }
  448. +        }
  449. +        return _list;
  450. +    }
  451. +
  452. +    /**
  453. +     * This method is used to limit the given Warehouse List to:
  454. +     * <li>Everything which is no Weapon/Armor</li>
  455. +     * <li>Money</li>
  456. +     * @param _items complete Warehouse List
  457. +     * @return limited Item List
  458. +     */
  459. +    private List<L2WarehouseItem> createEtcItemList(L2ItemInstance[] _items)
  460. +    {
  461. +        List<L2WarehouseItem> _list = new FastList<L2WarehouseItem>();
  462. +        for (L2ItemInstance item : _items)
  463. +        {
  464. +            if (item.isEtcItem() || item.getItem().getType2() == L2Item.TYPE2_MONEY)
  465. +            {
  466. +                if (_list.size() < MAX_SORT_LIST_ITEMS)
  467. +                    _list.add(new L2WarehouseItem(item));
  468. +                else
  469. +                    continue;
  470. +            }
  471. +        }
  472. +        return _list;
  473. +    }
  474. +
  475. +    /**
  476. +     * This method is used to limit the given Warehouse List to:
  477. +     * <li>Materials</li>
  478. +     * <li>Money</li>
  479. +     * @param _items complete Warehouse List
  480. +     * @return limited Item List
  481. +     */
  482. +    private List<L2WarehouseItem> createMatList(L2ItemInstance[] _items)
  483. +    {
  484. +        List<L2WarehouseItem> _list = new FastList<L2WarehouseItem>();
  485. +        for (L2ItemInstance item : _items)
  486. +        {
  487. +            if(item.isEtcItem() && item.getEtcItem().getItemType() == L2EtcItemType.MATERIAL || item.getItem().getType2() == L2Item.TYPE2_MONEY)
  488. +            {
  489. +                if (_list.size() < MAX_SORT_LIST_ITEMS)
  490. +                    _list.add(new L2WarehouseItem(item));
  491. +                else
  492. +                    continue;
  493. +            }
  494. +        }
  495. +        return _list;
  496. +    }
  497. +
  498. +    /**
  499. +     * This method is used to limit the given Warehouse List to:
  500. +     * <li>Recipes</li>
  501. +     * <li>Money</li>
  502. +     * @param _items complete Warehouse List
  503. +     * @return limited Item List
  504. +     */
  505. +    private List<L2WarehouseItem> createRecipeList(L2ItemInstance[] _items)
  506. +    {
  507. +        List<L2WarehouseItem> _list = new FastList<L2WarehouseItem>();
  508. +        for (L2ItemInstance item : _items)
  509. +        {
  510. +            if (item.isEtcItem() && item.getEtcItem().getItemType() == L2EtcItemType.RECEIPE || item.getItem().getType2() == L2Item.TYPE2_MONEY)
  511. +            {
  512. +                if (_list.size() < MAX_SORT_LIST_ITEMS)
  513. +                    _list.add(new L2WarehouseItem(item));
  514. +                else
  515. +                    continue;
  516. +            }
  517. +        }
  518. +        return _list;
  519. +    }
  520. +
  521. +    /**
  522. +     * This method is used to limit the given Warehouse List to:
  523. +     * <li>Amulett</li>
  524. +     * <li>Money</li>
  525. +     * @param _items complete Warehouse List
  526. +     * @return limited Item List
  527. +     */
  528. +    private List<L2WarehouseItem> createAmulettList(L2ItemInstance[] _items)
  529. +    {
  530. +        List<L2WarehouseItem> _list = new FastList<L2WarehouseItem>();
  531. +        for (L2ItemInstance item : _items)
  532. +        {
  533. +            if (item.isEtcItem() && (item.getEtcItem().getItemType() == L2EtcItemType.SPELLBOOK && item.getItemName().toUpperCase().startsWith("AMULET")) || item.getItem().getType2() == L2Item.TYPE2_MONEY)
  534. +            {
  535. +                if (_list.size() < MAX_SORT_LIST_ITEMS)
  536. +                    _list.add(new L2WarehouseItem(item));
  537. +                else
  538. +                    continue;
  539. +            }
  540. +        }
  541. +        return _list;
  542. +    }
  543. +
  544. +    /**
  545. +     * This method is used to limit the given Warehouse List to:
  546. +     * <li>Spellbook & Dwarven Drafts</li>
  547. +     * <li>Money</li>
  548. +     * @param _items complete Warehouse List
  549. +     * @return limited Item List
  550. +     */
  551. +    private List<L2WarehouseItem> createSpellbookList(L2ItemInstance[] _items)
  552. +    {
  553. +        List<L2WarehouseItem> _list = new FastList<L2WarehouseItem>();
  554. +        for (L2ItemInstance item : _items)
  555. +        {
  556. +            if (item.isEtcItem() && (item.getEtcItem().getItemType() == L2EtcItemType.SPELLBOOK && !item.getItemName().toUpperCase().startsWith("AMULET")) || item.getItem().getType2() == L2Item.TYPE2_MONEY )
  557. +            {
  558. +                if (_list.size() < MAX_SORT_LIST_ITEMS)
  559. +                    _list.add(new L2WarehouseItem(item));
  560. +                else
  561. +                    continue;
  562. +            }
  563. +        }
  564. +        return _list;
  565. +    }
  566. +
  567. +    /**
  568. +     * This method is used to limit the given Warehouse List to:
  569. +     * <li>Consumables (Potions, Shots, ...)</li>
  570. +     * <li>Money</li>
  571. +     * @param _items complete Warehouse List
  572. +     * @return limited Item List
  573. +     */
  574. +    private List<L2WarehouseItem> createConsumableList(L2ItemInstance[] _items)
  575. +    {
  576. +        List<L2WarehouseItem> _list = new FastList<L2WarehouseItem>();
  577. +        for (L2ItemInstance item : _items)
  578. +        {
  579. +            if (item.isEtcItem() && (item.getEtcItem().getItemType() == L2EtcItemType.SCROLL || item.getEtcItem().getItemType() == L2EtcItemType.SHOT) || item.getItem().getType2() == L2Item.TYPE2_MONEY)
  580. +            {
  581. +                if (_list.size() < MAX_SORT_LIST_ITEMS)
  582. +                    _list.add(new L2WarehouseItem(item));
  583. +                else
  584. +                    continue;
  585. +            }
  586. +        }
  587. +        return _list;
  588. +    }
  589. +
  590. +    /**
  591. +     * This method is used to limit the given Warehouse List to:
  592. +     * <li>Shots</li>
  593. +     * <li>Money</li>
  594. +     * @param _items complete Warehouse List
  595. +     * @return limited Item List
  596. +     */
  597. +    private List<L2WarehouseItem> createShotList(L2ItemInstance[] _items)
  598. +    {
  599. +        List<L2WarehouseItem> _list = new FastList<L2WarehouseItem>();
  600. +        for (L2ItemInstance item : _items)
  601. +        {
  602. +            if (item.isEtcItem() && item.getEtcItem().getItemType()==L2EtcItemType.SHOT || item.getItem().getType2() == L2Item.TYPE2_MONEY)
  603. +            {
  604. +                if (_list.size() < MAX_SORT_LIST_ITEMS)
  605. +                    _list.add(new L2WarehouseItem(item));
  606. +                else
  607. +                    continue;
  608. +            }
  609. +        }
  610. +        return _list;
  611. +    }
  612. +
  613. +    /**
  614. +     * This method is used to limit the given Warehouse List to:
  615. +     * <li>Scrolls/Potions</li>
  616. +     * <li>Money</li>
  617. +     * @param _items complete Warehouse List
  618. +     * @return limited Item List
  619. +     */
  620. +    private List<L2WarehouseItem> createScrollList(L2ItemInstance[] _items)
  621. +    {
  622. +        List<L2WarehouseItem> _list = new FastList<L2WarehouseItem>();
  623. +        for (L2ItemInstance item : _items)
  624. +        {
  625. +            if (item.isEtcItem() && item.getEtcItem().getItemType() == L2EtcItemType.SCROLL || item.getItem().getType2() == L2Item.TYPE2_MONEY)
  626. +            {
  627. +                if (_list.size() < MAX_SORT_LIST_ITEMS)
  628. +                    _list.add(new L2WarehouseItem(item));
  629. +                else
  630. +                    continue;
  631. +            }
  632. +        }
  633. +        return _list;
  634. +    }
  635. +
  636. +    /**
  637. +     * This method is used to limit the given Warehouse List to:
  638. +     * <li>Seeds</li>
  639. +     * <li>Money</li>
  640. +     * @param _items complete Warehouse List
  641. +     * @return limited Item List
  642. +     */
  643. +    private List<L2WarehouseItem> createSeedList(L2ItemInstance[] _items)
  644. +    {
  645. +        List<L2WarehouseItem> _list = new FastList<L2WarehouseItem>();
  646. +        for (L2ItemInstance item : _items)
  647. +        {
  648. +            if (item.isEtcItem() && item.getEtcItem().getItemType() == L2EtcItemType.SEED || item.getItem().getType2() == L2Item.TYPE2_MONEY)
  649. +            {
  650. +                if (_list.size() < MAX_SORT_LIST_ITEMS)
  651. +                    _list.add(new L2WarehouseItem(item));
  652. +                else
  653. +                    continue;
  654. +            }
  655. +        }
  656. +        return _list;
  657. +    }
  658. +
  659. +    /**
  660. +     * This method is used to limit the given Warehouse List to:
  661. +     * <li>Everything which is no Weapon/Armor, Material, Recipe, Spellbook, Scroll or Shot</li>
  662. +     * <li>Money</li>
  663. +     * @param _items complete Warehouse List
  664. +     * @return limited Item List
  665. +     */
  666. +    private List<L2WarehouseItem> createOtherList(L2ItemInstance[] _items)
  667. +    {
  668. +        List<L2WarehouseItem> _list = new FastList<L2WarehouseItem>();
  669. +        for (L2ItemInstance item : _items)
  670. +        {
  671. +            if( item.isEtcItem() &&
  672. +                ( item.getEtcItem().getItemType() != L2EtcItemType.MATERIAL &&
  673. +                  item.getEtcItem().getItemType() != L2EtcItemType.RECEIPE &&
  674. +                  item.getEtcItem().getItemType() != L2EtcItemType.SPELLBOOK &&
  675. +                  item.getEtcItem().getItemType() != L2EtcItemType.SCROLL &&
  676. +                  item.getEtcItem().getItemType() != L2EtcItemType.SHOT
  677. +                ) || item.getItem().getType2() == L2Item.TYPE2_MONEY )
  678. +            {
  679. +                if (_list.size() < MAX_SORT_LIST_ITEMS)
  680. +                    _list.add(new L2WarehouseItem(item));
  681. +                else
  682. +                    continue;
  683. +            }
  684. +        }
  685. +        return _list;
  686. +    }
  687. +
  688. +    /**
  689. +     * This method is used to limit the given Warehouse List to:
  690. +     * <li>no limit</li>
  691. +     * This may sound strange but we return the given Array as a List<L2WarehouseItem>
  692. +     * @param _items complete Warehouse List
  693. +     * @return limited Item List
  694. +     */
  695. +    private List<L2WarehouseItem> createAllList(L2ItemInstance[] _items)
  696. +    {
  697. +        List<L2WarehouseItem> _list = new FastList<L2WarehouseItem>();
  698. +        for (L2ItemInstance item : _items)
  699. +        {
  700. +            if (_list.size() < MAX_SORT_LIST_ITEMS)
  701. +                _list.add(new L2WarehouseItem(item));
  702. +            else
  703. +                continue;
  704. +        }
  705. +        return _list;
  706. +    }
  707. +
  708. +   @Override
  709. +   protected final void writeImpl()
  710. +   {
  711. +       writeC(0x42);
  712. +       /* 0x01-Private Warehouse  
  713. +       * 0x02-Clan Warehouse  
  714. +       * 0x03-Castle Warehouse  
  715. +       * 0x04-Warehouse */  
  716. +       writeH(_whType);
  717. +       writeD(_playerAdena);
  718. +       writeH(_objects.size());
  719. +
  720. +       for (L2WarehouseItem item : _objects)
  721. +       {
  722. +           writeH(item.getItem().getType1()); // item type1 //unconfirmed, works
  723. +           writeD(0x00);
  724. +           //writeD(item.getObjectId());
  725. +           writeD(item.getItemId()); //unconfirmed, works
  726. +           writeD(item.getCount()); //unconfirmed, works
  727. +           writeH(item.getItem().getType2());  // item type2 //unconfirmed, works
  728. +           writeH(0x00);   // ?
  729. +           //writeH(item.getCustomType1());  // ?
  730. +           writeD(item.getItem().getBodyPart());   // ?
  731. +           writeH(item.getEnchantLevel()); // enchant level -confirmed
  732. +           writeH(0x00);   // ?
  733. +           writeH(0x00);   // ?
  734. +           //writeH(item.getCustomType2());  // ?
  735. +           //writeH(ENDmarker);  // ?
  736. +           writeD(item.getObjectId()); // item id - confimed      
  737. +           if (item.isAugmented())
  738. +           {
  739. +               writeD(0x0000FFFF&item.getAugmentationId());
  740. +               writeD(item.getAugmentationId()>>16);
  741. +           }
  742. +           else writeQ(0x00);
  743. +           //writeD(item.getMana());
  744. +
  745. +       }
  746. +   }
  747. +
  748. +   /* (non-Javadoc)
  749. +    * @see net.sf.l2j.gameserver.serverpackets.ServerBasePacket#getType()
  750. +    */
  751. +   @Override
  752. +   public String getType()
  753. +   {
  754. +       return _S__54_SORTEDWAREHOUSEWITHDRAWALLIST;
  755. +   }
  756. +}
  757. Index: /l2j-private/l2j-private/java/com/l2jarchid/gameserver/model/L2ItemInstance.java
  758. ===================================================================
  759. --- /l2j-private/l2j-private/java/com/l2jarchid/gameserver/model/L2ItemInstance.java    (revision 258)
  760. +++ /l2j-private/l2j-private/java/com/l2jarchid/gameserver/model/L2ItemInstance.java    (revision 310)
  761. @@ -410,4 +410,13 @@
  762.    
  763.     /**
  764. +    * Returns true if item is an EtcItem
  765. +    * @return boolean
  766. +    */
  767. +   public boolean isEtcItem()
  768. +   {
  769. +       return (_item instanceof L2EtcItem);
  770. +   }
  771. +  
  772. +   /**
  773.      * Returns true if item is a Weapon/Shield
  774.      *
  775. @@ -427,4 +436,17 @@
  776.     {
  777.         return (_item instanceof L2Armor);
  778. +   }
  779. +  
  780. +   /**
  781. +    * Returns the characteristics of the L2EtcItem
  782. +    * @return L2EtcItem
  783. +    */
  784. +   public L2EtcItem getEtcItem()
  785. +   {
  786. +       if (_item instanceof L2EtcItem)
  787. +       {
  788. +           return (L2EtcItem) _item;
  789. +       }
  790. +       return null;
  791.     }
  792.  
  793. Index: /l2j-private/l2j-private/java/com/l2jarchid/gameserver/model/actor/instance/L2CastleWarehouseInstance.java
  794. ===================================================================
  795. --- /l2j-private/l2j-private/java/com/l2jarchid/gameserver/model/actor/instance/L2CastleWarehouseInstance.java  (revision 200)
  796. +++ /l2j-private/l2j-private/java/com/l2jarchid/gameserver/model/actor/instance/L2CastleWarehouseInstance.java  (revision 310)
  797. @@ -1,11 +1,14 @@
  798.  package com.l2jarchid.gameserver.model.actor.instance;
  799.  
  800. +import com.l2jarchid.Config;
  801.  import com.l2jarchid.gameserver.model.L2Clan;
  802.  import com.l2jarchid.gameserver.network.SystemMessageId;
  803.  import com.l2jarchid.gameserver.network.serverpackets.ActionFailed;
  804.  import com.l2jarchid.gameserver.network.serverpackets.NpcHtmlMessage;
  805. +import com.l2jarchid.gameserver.network.serverpackets.SortedWareHouseWithdrawalList;
  806.  import com.l2jarchid.gameserver.network.serverpackets.SystemMessage;
  807.  import com.l2jarchid.gameserver.network.serverpackets.WareHouseDepositList;
  808.  import com.l2jarchid.gameserver.network.serverpackets.WareHouseWithdrawalList;
  809. +import com.l2jarchid.gameserver.network.serverpackets.SortedWareHouseWithdrawalList.WarehouseListType;
  810.  import com.l2jarchid.gameserver.templates.L2NpcTemplate;
  811.  
  812. @@ -38,5 +41,8 @@
  813.          }
  814.  
  815. -        player.sendPacket(new WareHouseWithdrawalList(player, WareHouseWithdrawalList.PRIVATE));
  816. +        if (Config.L2F_ENABLE_WAREHOUSESORTING)
  817. +               player.sendPacket(new SortedWareHouseWithdrawalList(player, WareHouseWithdrawalList.PRIVATE,WarehouseListType.ALL,SortedWareHouseWithdrawalList.A2Z));
  818. +        else      
  819. +               player.sendPacket(new WareHouseWithdrawalList(player, WareHouseWithdrawalList.PRIVATE));
  820.      }
  821.  
  822. @@ -84,5 +90,8 @@
  823.              } else {
  824.                  player.setActiveWarehouse(player.getClan().getWarehouse());
  825. -                player.sendPacket(new WareHouseWithdrawalList(player, WareHouseWithdrawalList.CLAN));
  826. +                if (Config.L2F_ENABLE_WAREHOUSESORTING)
  827. +                   player.sendPacket(new SortedWareHouseWithdrawalList(player, WareHouseWithdrawalList.CLAN,WarehouseListType.ALL,SortedWareHouseWithdrawalList.A2Z));
  828. +                else
  829. +                   player.sendPacket(new WareHouseWithdrawalList(player, WareHouseWithdrawalList.CLAN));
  830.              }
  831.          }
  832. Index: /l2j-private/l2j-private/java/com/l2jarchid/gameserver/model/actor/instance/L2WarehouseInstance.java
  833. ===================================================================
  834. --- /l2j-private/l2j-private/java/com/l2jarchid/gameserver/model/actor/instance/L2WarehouseInstance.java    (revision 200)
  835. +++ /l2j-private/l2j-private/java/com/l2jarchid/gameserver/model/actor/instance/L2WarehouseInstance.java    (revision 310)
  836. @@ -27,7 +27,9 @@
  837.  import com.l2jarchid.gameserver.network.serverpackets.ActionFailed;
  838.  import com.l2jarchid.gameserver.network.serverpackets.PackageToList;
  839. +import com.l2jarchid.gameserver.network.serverpackets.SortedWareHouseWithdrawalList;
  840.  import com.l2jarchid.gameserver.network.serverpackets.SystemMessage;
  841.  import com.l2jarchid.gameserver.network.serverpackets.WareHouseDepositList;
  842.  import com.l2jarchid.gameserver.network.serverpackets.WareHouseWithdrawalList;
  843. +import com.l2jarchid.gameserver.network.serverpackets.SortedWareHouseWithdrawalList.WarehouseListType;
  844.  import com.l2jarchid.gameserver.templates.L2NpcTemplate;
  845.  
  846. @@ -77,4 +79,7 @@
  847.  
  848.          if (Config.DEBUG) _log.fine("Showing stored items");
  849. +        if (Config.L2F_ENABLE_WAREHOUSESORTING)
  850. +          player.sendPacket(new SortedWareHouseWithdrawalList(player, WareHouseWithdrawalList.PRIVATE,WarehouseListType.ALL,SortedWareHouseWithdrawalList.A2Z));
  851. +        else
  852.          player.sendPacket(new WareHouseWithdrawalList(player, WareHouseWithdrawalList.PRIVATE));
  853.      }
  854. @@ -125,4 +130,7 @@
  855.                 player.setActiveWarehouse(player.getClan().getWarehouse());
  856.                  if (Config.DEBUG) _log.fine("Showing items to deposit - clan");
  857. +                if (Config.L2F_ENABLE_WAREHOUSESORTING)
  858. +                  player.sendPacket(new SortedWareHouseWithdrawalList(player, WareHouseWithdrawalList.CLAN,WarehouseListType.ALL,SortedWareHouseWithdrawalList.A2Z));
  859. +                else
  860.                  player.sendPacket(new WareHouseWithdrawalList(player, WareHouseWithdrawalList.CLAN));
  861.              }
  862. @@ -149,4 +157,7 @@
  863.                 }
  864.                 player.setActiveWarehouse(freight);
  865. +                if (Config.L2F_ENABLE_WAREHOUSESORTING)
  866. +                  player.sendPacket(new SortedWareHouseWithdrawalList(player, WareHouseWithdrawalList.FREIGHT,WarehouseListType.ALL,SortedWareHouseWithdrawalList.A2Z));
  867. +                else
  868.                 player.sendPacket(new WareHouseWithdrawalList(player, WareHouseWithdrawalList.FREIGHT));
  869.             }
  870. Index: /l2j-private/l2j-private/java/com/l2jarchid/gameserver/templates/L2WarehouseItem.java
  871. ===================================================================
  872. --- /l2j-private/l2j-private/java/com/l2jarchid/gameserver/templates/L2WarehouseItem.java   (revision 310)
  873. +++ /l2j-private/l2j-private/java/com/l2jarchid/gameserver/templates/L2WarehouseItem.java   (revision 310)
  874. @@ -0,0 +1,243 @@
  875. +/*
  876. + * This program is free software; you can redistribute it and/or modify
  877. + * it under the terms of the GNU General Public License as published by
  878. + * the Free Software Foundation; either version 2, or (at your option)
  879. + * any later version.
  880. + *
  881. + * This program is distributed in the hope that it will be useful,
  882. + * but WITHOUT ANY WARRANTY; without even the implied warranty of
  883. + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  884. + * GNU General Public License for more details.
  885. + *
  886. + * You should have received a copy of the GNU General Public License
  887. + * along with this program; if not, write to the Free Software
  888. + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  889. + * 02111-1307, USA.
  890. + *
  891. + * http://www.gnu.org/copyleft/gpl.html
  892. + */
  893. +package com.l2jarchid.gameserver.templates;
  894. +
  895. +import com.l2jarchid.gameserver.model.L2ItemInstance;
  896. +
  897. +/**
  898. + * This class contains L2ItemInstance<BR>
  899. + * Use to sort L2ItemInstance of :
  900. + * <LI>L2Armor</LI>
  901. + * <LI>L2EtcItem</LI>
  902. + * <LI>L2Weapon</LI>
  903. + * @version $Revision: 1.7.2.2.2.5 $ $Date: 2005/04/06 18:25:18 $
  904. + */
  905. +public class L2WarehouseItem
  906. +{
  907. +    private L2Item _item;
  908. +    private int _object;
  909. +    private int _count;
  910. +    private int _owner;
  911. +    private int _enchant;
  912. +    private int _grade;
  913. +    private boolean _isAugmented;
  914. +    private int _augmentationId;
  915. +    private int _customType1;
  916. +    private int _customType2;
  917. +    private int _mana;
  918. +
  919. +
  920. +    public L2WarehouseItem(L2ItemInstance item)
  921. +    {
  922. +        _item = item.getItem();
  923. +        _object = item.getObjectId();
  924. +        _count = item.getCount();
  925. +        _owner = item.getOwnerId();
  926. +        _enchant = item.getEnchantLevel();
  927. +        _customType1 = item.getCustomType1();
  928. +        _customType2 = item.getCustomType2();
  929. +        _grade = item.getItem().getItemGrade();
  930. +        if (item.isAugmented())
  931. +        {
  932. +            _isAugmented = true;
  933. +            _augmentationId = item.getAugmentation().getAugmentationId();
  934. +        }
  935. +        else
  936. +            _isAugmented = false;
  937. +        _mana = item.getMana();
  938. +    }
  939. +
  940. +    /**
  941. +    * Returns the item.
  942. +    * @return L2Item
  943. +    */
  944. +   public L2Item getItem()
  945. +   {
  946. +       return _item;
  947. +   }
  948. +
  949. +   /**
  950. +    * Returns the unique objectId
  951. +    * @return int
  952. +    */
  953. +   public final int getObjectId()
  954. +   {
  955. +       return _object;
  956. +   }
  957. +
  958. +    /**
  959. +     * Returns the owner
  960. +     * @return int
  961. +     */
  962. +    public final int getOwnerId()
  963. +    {
  964. +        return _owner;
  965. +    }
  966. +
  967. +    /**
  968. +     * Returns the count
  969. +     * @return int
  970. +     */
  971. +    public final int getCount()
  972. +    {
  973. +        return _count;
  974. +    }
  975. +
  976. +    /**
  977. +     * Returns the first type
  978. +     * @return int
  979. +     */
  980. +    public final int getType1()
  981. +    {
  982. +        return _item.getType1();
  983. +    }
  984. +
  985. +    /**
  986. +     * Returns the second type
  987. +     * @return int
  988. +     */
  989. +    public final int getType2()
  990. +    {
  991. +        return _item.getType2();
  992. +    }
  993. +
  994. +    /**
  995. +     * Returns the second type
  996. +     * @return int
  997. +     */
  998. +    @SuppressWarnings("unchecked")
  999. +    public final Enum getItemType()
  1000. +    {
  1001. +        return _item.getItemType();
  1002. +    }
  1003. +
  1004. +    /**
  1005. +     * Returns the ItemId
  1006. +     * @return int
  1007. +     */
  1008. +    public final int getItemId()
  1009. +    {
  1010. +        return _item.getItemId();
  1011. +    }
  1012. +
  1013. +    /**
  1014. +     * Returns the part of body used with this item
  1015. +     * @return int
  1016. +     */
  1017. +    public final int getBodyPart()
  1018. +    {
  1019. +        return _item.getBodyPart();
  1020. +    }
  1021. +
  1022. +    /**
  1023. +     * Returns the enchant level
  1024. +     * @return int
  1025. +     */
  1026. +    public final int getEnchantLevel()
  1027. +    {
  1028. +        return _enchant;
  1029. +    }
  1030. +
  1031. +    /**
  1032. +     * Returns the item grade
  1033. +     * @return int
  1034. +     */
  1035. +    public final int getItemGrade()
  1036. +    {
  1037. +        return _grade;
  1038. +    }
  1039. +
  1040. +    /**
  1041. +     * Returns true if it is a weapon
  1042. +     * @return boolean
  1043. +     */
  1044. +    public final boolean isWeapon()
  1045. +    {
  1046. +        return (_item instanceof L2Weapon);
  1047. +    }
  1048. +
  1049. +    /**
  1050. +     * Returns true if it is an armor
  1051. +     * @return boolean
  1052. +     */
  1053. +    public final boolean isArmor()
  1054. +    {
  1055. +        return (_item instanceof L2Armor);
  1056. +    }
  1057. +
  1058. +    /**
  1059. +     * Returns true if it is an EtcItem
  1060. +     * @return boolean
  1061. +     */
  1062. +    public final boolean isEtcItem()
  1063. +    {
  1064. +        return (_item instanceof L2EtcItem);
  1065. +    }
  1066. +
  1067. +    /**
  1068. +     * Returns the name of the item
  1069. +     * @return String
  1070. +     */
  1071. +    public String getItemName()
  1072. +    {
  1073. +        return _item.getName();
  1074. +    }
  1075. +
  1076. +    public boolean isAugmented()
  1077. +    {
  1078. +        return _isAugmented;
  1079. +    }
  1080. +
  1081. +    public int getAugmentationId()
  1082. +    {
  1083. +        return _augmentationId;
  1084. +    }
  1085. +
  1086. +    /**
  1087. +     * Returns the name of the item
  1088. +     * @return String
  1089. +     * @deprecated beware to use getItemName() instead because getName() is final in L2Object and could not be overridden! Allover L2Object.getName() may return null!
  1090. +     */
  1091. +    public String getName()
  1092. +    {
  1093. +        return _item.getName();
  1094. +    }
  1095. +
  1096. +    public final int getCustomType1()
  1097. +    {
  1098. +        return _customType1;
  1099. +    }
  1100. +    public final int getCustomType2()
  1101. +    {
  1102. +        return _customType2;
  1103. +    }
  1104. +    public final int getMana()
  1105. +    {
  1106. +        return _mana;
  1107. +    }
  1108. +
  1109. +    /**
  1110. +     * Returns the name of the item
  1111. +     * @return String
  1112. +     */
  1113. +   public String toString()
  1114. +   {
  1115. +       return _item.toString();
  1116. +   }
  1117. +}
  1118. Index: /l2j-private/l2j-private/config/l2jarchid-customs.properties
  1119. ===================================================================
  1120. --- /l2j-private/l2j-private/config/l2jarchid-customs.properties    (revision 301)
  1121. +++ /l2j-private/l2j-private/config/l2jarchid-customs.properties    (revision 310)
  1122. @@ -441,2 +441,9 @@
  1123.  # ---------------------------------------------------------------------------
  1124.  SaveBuffsAfterDeath = false
  1125. +
  1126. +# ---------------------------------------------------------------------------
  1127. +# Warehouse Sorting
  1128. +# Shows Withdraw Window sorted by A to Z
  1129. +# ---------------------------------------------------------------------------
  1130. +EnableWarehouseSorting = False
  1131. +
  1132.  
  1133.  
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
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!