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
143
144
145
146
147
148
149
150
151
152
153
154
155
|
From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
From: Jake Potrebic <jake.m.potrebic@gmail.com>
Date: Wed, 12 Sep 2018 18:53:55 +0300
Subject: [PATCH] Add API for CanPlaceOn and CanDestroy NBT values
diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaItem.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaItem.java
index 042bfdd14c9ff4cc8ed3421f73565f0f03b11bcb..e0414b0a48a95f1f5e718070dd0e5f955052a898 100644
--- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaItem.java
+++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaItem.java
@@ -2183,4 +2183,117 @@ class CraftMetaItem implements ItemMeta, Damageable, Repairable, BlockDataMeta {
}
// Paper end
+ // Paper start - Add an API for can-place-on/can-break adventure mode predicates
+ @Override
+ public Set<Material> getCanDestroy() {
+ return !this.hasDestroyableKeys() ? Collections.emptySet() : convertToLegacyMaterial(this.canBreakPredicates);
+ }
+
+ @Override
+ public void setCanDestroy(final Set<Material> canDestroy) {
+ Preconditions.checkArgument(canDestroy != null, "Cannot replace with null set!");
+ this.canBreakPredicates = convertFromLegacyMaterial(canDestroy);
+ }
+
+ @Override
+ public Set<Material> getCanPlaceOn() {
+ return !this.hasPlaceableKeys() ? Collections.emptySet() : convertToLegacyMaterial(this.canPlaceOnPredicates);
+ }
+
+ @Override
+ public void setCanPlaceOn(final Set<Material> canPlaceOn) {
+ Preconditions.checkArgument(canPlaceOn != null, "Cannot replace with null set!");
+ this.canPlaceOnPredicates = convertFromLegacyMaterial(canPlaceOn);
+ }
+
+ private static List<net.minecraft.advancements.critereon.BlockPredicate> convertFromLegacyMaterial(final Collection<Material> materials) {
+ return materials.stream().map(m -> {
+ return net.minecraft.advancements.critereon.BlockPredicate.Builder.block().of(CraftBlockType.bukkitToMinecraft(m)).build();
+ }).toList();
+ }
+
+ private static Set<Material> convertToLegacyMaterial(final List<net.minecraft.advancements.critereon.BlockPredicate> predicates) {
+ return predicates.stream()
+ .flatMap(p -> p.blocks().map(net.minecraft.core.HolderSet::stream).orElse(java.util.stream.Stream.empty()))
+ .map(holder -> CraftBlockType.minecraftToBukkit(holder.value()))
+ .collect(java.util.stream.Collectors.toSet());
+ }
+
+ @Override
+ public Set<com.destroystokyo.paper.Namespaced> getDestroyableKeys() {
+ return !this.hasDestroyableKeys() ? Collections.emptySet() : convertToLegacyNamespaced(this.canBreakPredicates);
+ }
+
+ @Override
+ public void setDestroyableKeys(final Collection<com.destroystokyo.paper.Namespaced> canDestroy) {
+ Preconditions.checkArgument(canDestroy != null, "Cannot replace with null collection!");
+ Preconditions.checkArgument(ofAcceptableType(canDestroy), "Can only use NamespacedKey or NamespacedTag objects!");
+ this.canBreakPredicates = convertFromLegacyNamespaced(canDestroy);
+ }
+
+ @Override
+ public Set<com.destroystokyo.paper.Namespaced> getPlaceableKeys() {
+ return !this.hasPlaceableKeys() ? Collections.emptySet() : convertToLegacyNamespaced(this.canPlaceOnPredicates);
+ }
+
+ @Override
+ public void setPlaceableKeys(final Collection<com.destroystokyo.paper.Namespaced> canPlaceOn) {
+ Preconditions.checkArgument(canPlaceOn != null, "Cannot replace with null collection!");
+ Preconditions.checkArgument(ofAcceptableType(canPlaceOn), "Can only use NamespacedKey or NamespacedTag objects!");
+ this.canPlaceOnPredicates = convertFromLegacyNamespaced(canPlaceOn);
+ }
+
+ private static List<net.minecraft.advancements.critereon.BlockPredicate> convertFromLegacyNamespaced(final Collection<com.destroystokyo.paper.Namespaced> namespaceds) {
+ final List<net.minecraft.advancements.critereon.BlockPredicate> predicates = new ArrayList<>();
+ for (final com.destroystokyo.paper.Namespaced namespaced : namespaceds) {
+ if (namespaced instanceof final org.bukkit.NamespacedKey key) {
+ predicates.add(net.minecraft.advancements.critereon.BlockPredicate.Builder.block().of(CraftBlockType.bukkitToMinecraft(Objects.requireNonNull(org.bukkit.Registry.MATERIAL.get(key)))).build());
+ } else if (namespaced instanceof final com.destroystokyo.paper.NamespacedTag tag) {
+ predicates.add(net.minecraft.advancements.critereon.BlockPredicate.Builder.block().of(net.minecraft.tags.TagKey.create(Registries.BLOCK, ResourceLocation.fromNamespaceAndPath(tag.getNamespace(), tag.getKey()))).build());
+ }
+ }
+ return predicates;
+ }
+
+ private static Set<com.destroystokyo.paper.Namespaced> convertToLegacyNamespaced(final Collection<net.minecraft.advancements.critereon.BlockPredicate> predicates) {
+ final Set<com.destroystokyo.paper.Namespaced> namespaceds = Sets.newHashSet();
+ for (final net.minecraft.advancements.critereon.BlockPredicate predicate : predicates) {
+ if (predicate.blocks().isEmpty()) {
+ continue;
+ }
+ final net.minecraft.core.HolderSet<net.minecraft.world.level.block.Block> holders = predicate.blocks().get();
+ if (holders instanceof final net.minecraft.core.HolderSet.Named<net.minecraft.world.level.block.Block> named) {
+ namespaceds.add(new com.destroystokyo.paper.NamespacedTag(named.key().location().getNamespace(), named.key().location().getPath()));
+ } else {
+ holders.forEach(h -> {
+ h.unwrapKey().ifPresent(key -> {
+ namespaceds.add(new org.bukkit.NamespacedKey(key.location().getNamespace(), key.location().getPath()));
+ });
+ });
+ }
+ }
+ return namespaceds;
+ }
+
+ @Override
+ public boolean hasPlaceableKeys() {
+ return this.canPlaceOnPredicates != null;
+ }
+
+ @Override
+ public boolean hasDestroyableKeys() {
+ return this.canBreakPredicates != null;
+ }
+
+ // not a fan of this
+ private static boolean ofAcceptableType(final Collection<com.destroystokyo.paper.Namespaced> namespacedResources) {
+ for (com.destroystokyo.paper.Namespaced resource : namespacedResources) {
+ if (!(resource instanceof org.bukkit.NamespacedKey || resource instanceof com.destroystokyo.paper.NamespacedTag)) {
+ return false;
+ }
+ }
+
+ return true;
+ }
+ // Paper end - Add an API for can-place-on/can-break adventure mode predicates
}
diff --git a/src/main/java/org/bukkit/craftbukkit/legacy/MaterialRerouting.java b/src/main/java/org/bukkit/craftbukkit/legacy/MaterialRerouting.java
index 6930d0afb230a88aa813b02e4d55c95d3a049688..db8d8e2a07296d62c3097f02b03319e2e1ba9394 100644
--- a/src/main/java/org/bukkit/craftbukkit/legacy/MaterialRerouting.java
+++ b/src/main/java/org/bukkit/craftbukkit/legacy/MaterialRerouting.java
@@ -690,4 +690,22 @@ public class MaterialRerouting {
return ItemStack.of(material, amount);
}
// Paper end
+
+ // Paper start - methods added post 1.13, no-op (https://github.com/PaperMC/Paper/pull/1015)
+ public static Set<Material> getCanDestroy(final ItemMeta meta) {
+ return meta.getCanDestroy();
+ }
+
+ public static void setCanDestroy(final ItemMeta meta, final Set<Material> materials) {
+ meta.setCanDestroy(materials);
+ }
+
+ public static Set<Material> getCanPlaceOn(final ItemMeta meta) {
+ return meta.getCanPlaceOn();
+ }
+
+ public static void setCanPlaceOn(final ItemMeta meta, final Set<Material> materials) {
+ meta.setCanPlaceOn(materials);
+ }
+ // Paper end
}
|
