1. package net.kopara.core.utils;
2.  
3. import org.bukkit.configuration.serialization.ConfigurationSerialization;
4. import org.bukkit.inventory.meta.ItemMeta;
5. import java.util.HashMap;
6. import org.bukkit.Material;
7. import java.util.Map;
8. import java.io.InputStream;
9. import java.io.ObjectInputStream;
10. import java.io.ByteArrayInputStream;
11. import javax.xml.bind.DatatypeConverter;
12. import java.io.OutputStream;
13. import java.io.ObjectOutputStream;
14. import java.io.ByteArrayOutputStream;
15. import org.bukkit.inventory.ItemStack;
16.  
17. public class ItemSerializer
18. {
19.     public static String itemsToString(final ItemStack[] items) {
20.         try {
21.             final ByteArrayOutputStream bos = new ByteArrayOutputStream();
22.             final ObjectOutputStream oos = new ObjectOutputStream(bos);
23.             oos.writeObject(serializeItemStack(items));
24.             oos.flush();
25.             return DatatypeConverter.printBase64Binary(bos.toByteArray());
26.         }
27.         catch (Exception e) {
28.             Logger.exception(e);
29.             return "";
30.         }
31.     }
32.    
33.     public static ItemStack[] stringToItems(final String s) {
34.         try {
35.             final ByteArrayInputStream bis = new ByteArrayInputStream(DatatypeConverter.parseBase64Binary(s));
36.             final ObjectInputStream ois = new ObjectInputStream(bis);
37.             return deserializeItemStack((Map<String, Object>[])ois.readObject());
38.         }
39.         catch (Exception e) {
40.             Logger.exception(e);
41.             return new ItemStack[] { new ItemStack(Material.AIR) };
42.         }
43.     }
44.    
45.     private static Map<String, Object>[] serializeItemStack(final ItemStack[] items) {
46.         final Map[] result = new Map[items.length];
47.         for (int i = 0; i < items.length; ++i) {
48.             final ItemStack is = items[i];
49.             if (is == null) {
50.                 result[i] = new HashMap();
51.             }
52.             else {
53.                 result[i] = is.serialize();
54.                 if (is.hasItemMeta()) {
55.                     result[i].put("meta", is.getItemMeta().serialize());
56.                 }
57.             }
58.         }
59.         return (Map<String, Object>[])result;
60.     }
61.    
62.     private static ItemStack[] deserializeItemStack(final Map<String, Object>[] map) {
63.         final ItemStack[] items = new ItemStack[map.length];
64.         for (int i = 0; i < items.length; ++i) {
65.             final Map<String, Object> s = map[i];
66.             if (s.size() == 0) {
67.                 items[i] = null;
68.             }
69.             else {
70.                 try {
71.                     if (s.containsKey("meta")) {
72.                         final Map<String, Object> im = new HashMap<String, Object>(s.remove("meta"));   <--- Tu jest błąd
73.                         im.put("==", "ItemMeta");
74.                         final ItemStack is = ItemStack.deserialize((Map)s);
75.                         is.setItemMeta((ItemMeta)ConfigurationSerialization.deserializeObject((Map)im));
76.                         items[i] = is;
77.                     }
78.                     else {
79.                         items[i] = ItemStack.deserialize((Map)s);
80.                     }
81.                 }
82.                 catch (Exception e) {
83.                     Logger.exception(e);
84.                     items[i] = null;
85.                 }
86.             }
87.         }
88.         return items;
89.     }
90. }
91.