1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
|
package org.bukkit.craftbukkit.inventory;
import java.util.Collection;
import org.apache.commons.lang.Validate;
import org.bukkit.Color;
import org.bukkit.Material;
import org.bukkit.configuration.serialization.ConfigurationSerialization;
import org.bukkit.inventory.ItemFactory;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.meta.ItemMeta;
import com.google.common.collect.ImmutableSet;
public final class CraftItemFactory implements ItemFactory {
static final Color DEFAULT_LEATHER_COLOR = Color.fromRGB(0xA06540);
static final Collection<String> KNOWN_NBT_ATTRIBUTE_NAMES;
private static final CraftItemFactory instance;
static {
instance = new CraftItemFactory();
ConfigurationSerialization.registerClass(CraftMetaItem.SerializableMeta.class);
KNOWN_NBT_ATTRIBUTE_NAMES = ImmutableSet.<String>builder()
.add("generic.attackDamage")
.add("generic.followRange")
.add("generic.knockbackResistance")
.add("generic.maxHealth")
.add("generic.movementSpeed")
.add("horse.jumpStrength")
.add("zombie.spawnReinforcements")
.build();
}
private CraftItemFactory() {
}
public boolean isApplicable(ItemMeta meta, ItemStack itemstack) {
if (itemstack == null) {
return false;
}
return isApplicable(meta, itemstack.getType());
}
public boolean isApplicable(ItemMeta meta, Material type) {
if (type == null || meta == null) {
return false;
}
if (!(meta instanceof CraftMetaItem)) {
throw new IllegalArgumentException("Meta of " + meta.getClass().toString() + " not created by " + CraftItemFactory.class.getName());
}
return ((CraftMetaItem) meta).applicableTo(type);
}
public ItemMeta getItemMeta(Material material) {
Validate.notNull(material, "Material cannot be null");
return getItemMeta(material, null);
}
private ItemMeta getItemMeta(Material material, CraftMetaItem meta) {
switch (material) {
case AIR:
return null;
case WRITTEN_BOOK:
case BOOK_AND_QUILL:
return meta instanceof CraftMetaBook ? meta : new CraftMetaBook(meta);
case SKULL_ITEM:
return meta instanceof CraftMetaSkull ? meta : new CraftMetaSkull(meta);
case LEATHER_HELMET:
case LEATHER_CHESTPLATE:
case LEATHER_LEGGINGS:
case LEATHER_BOOTS:
return meta instanceof CraftMetaLeatherArmor ? meta : new CraftMetaLeatherArmor(meta);
case POTION:
return meta instanceof CraftMetaPotion ? meta : new CraftMetaPotion(meta);
case MAP:
return meta instanceof CraftMetaMap ? meta : new CraftMetaMap(meta);
case FIREWORK:
return meta instanceof CraftMetaFirework ? meta : new CraftMetaFirework(meta);
case FIREWORK_CHARGE:
return meta instanceof CraftMetaCharge ? meta : new CraftMetaCharge(meta);
case ENCHANTED_BOOK:
return meta instanceof CraftMetaEnchantedBook ? meta : new CraftMetaEnchantedBook(meta);
default:
return new CraftMetaItem(meta);
}
}
public boolean equals(ItemMeta meta1, ItemMeta meta2) {
if (meta1 == meta2) {
return true;
}
if (meta1 != null && !(meta1 instanceof CraftMetaItem)) {
throw new IllegalArgumentException("First meta of " + meta1.getClass().getName() + " does not belong to " + CraftItemFactory.class.getName());
}
if (meta2 != null && !(meta2 instanceof CraftMetaItem)) {
throw new IllegalArgumentException("Second meta " + meta2.getClass().getName() + " does not belong to " + CraftItemFactory.class.getName());
}
if (meta1 == null) {
return ((CraftMetaItem) meta2).isEmpty();
}
if (meta2 == null) {
return ((CraftMetaItem) meta1).isEmpty();
}
return equals((CraftMetaItem) meta1, (CraftMetaItem) meta2);
}
boolean equals(CraftMetaItem meta1, CraftMetaItem meta2) {
/*
* This couldn't be done inside of the objects themselves, else force recursion.
* This is a fairly clean way of implementing it, by dividing the methods into purposes and letting each method perform its own function.
*
* The common and uncommon were split, as both could have variables not applicable to the other, like a skull and book.
* Each object needs its chance to say "hey wait a minute, we're not equal," but without the redundancy of using the 1.equals(2) && 2.equals(1) checking the 'commons' twice.
*
* Doing it this way fills all conditions of the .equals() method.
*/
return meta1.equalsCommon(meta2) && meta1.notUncommon(meta2) && meta2.notUncommon(meta1);
}
public static CraftItemFactory instance() {
return instance;
}
public ItemMeta asMetaFor(ItemMeta meta, ItemStack stack) {
Validate.notNull(stack, "Stack cannot be null");
return asMetaFor(meta, stack.getType());
}
public ItemMeta asMetaFor(ItemMeta meta, Material material) {
Validate.notNull(material, "Material cannot be null");
if (!(meta instanceof CraftMetaItem)) {
throw new IllegalArgumentException("Meta of " + (meta != null ? meta.getClass().toString() : "null") + " not created by " + CraftItemFactory.class.getName());
}
return getItemMeta(material, (CraftMetaItem) meta);
}
public Color getDefaultLeatherColor() {
return DEFAULT_LEATHER_COLOR;
}
}
|
