604 lines
27 KiB
Java
604 lines
27 KiB
Java
package org.bukkit.craftbukkit.legacy;
|
|
|
|
import java.util.Collection;
|
|
import java.util.EnumMap;
|
|
import java.util.HashMap;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.Set;
|
|
import java.util.function.Consumer;
|
|
import java.util.stream.Collectors;
|
|
import org.bukkit.Bukkit;
|
|
import org.bukkit.ChunkSnapshot;
|
|
import org.bukkit.Keyed;
|
|
import org.bukkit.Location;
|
|
import org.bukkit.Material;
|
|
import org.bukkit.OfflinePlayer;
|
|
import org.bukkit.RegionAccessor;
|
|
import org.bukkit.Server;
|
|
import org.bukkit.Statistic;
|
|
import org.bukkit.Tag;
|
|
import org.bukkit.World;
|
|
import org.bukkit.block.Block;
|
|
import org.bukkit.block.BlockState;
|
|
import org.bukkit.block.DecoratedPot;
|
|
import org.bukkit.block.Jukebox;
|
|
import org.bukkit.block.data.BlockData;
|
|
import org.bukkit.craftbukkit.block.data.CraftBlockData;
|
|
import org.bukkit.craftbukkit.inventory.CraftItemType;
|
|
import org.bukkit.craftbukkit.legacy.reroute.InjectPluginVersion;
|
|
import org.bukkit.craftbukkit.legacy.reroute.RerouteStatic;
|
|
import org.bukkit.craftbukkit.tag.CraftBlockTag;
|
|
import org.bukkit.craftbukkit.tag.CraftItemTag;
|
|
import org.bukkit.craftbukkit.util.ApiVersion;
|
|
import org.bukkit.craftbukkit.util.CraftMagicNumbers;
|
|
import org.bukkit.enchantments.EnchantmentTarget;
|
|
import org.bukkit.entity.Animals;
|
|
import org.bukkit.entity.Boat;
|
|
import org.bukkit.entity.EntityType;
|
|
import org.bukkit.entity.FallingBlock;
|
|
import org.bukkit.entity.HumanEntity;
|
|
import org.bukkit.entity.LivingEntity;
|
|
import org.bukkit.entity.Piglin;
|
|
import org.bukkit.entity.Player;
|
|
import org.bukkit.entity.Steerable;
|
|
import org.bukkit.event.block.BlockCanBuildEvent;
|
|
import org.bukkit.event.block.BlockPhysicsEvent;
|
|
import org.bukkit.event.entity.EntityChangeBlockEvent;
|
|
import org.bukkit.event.inventory.FurnaceExtractEvent;
|
|
import org.bukkit.event.player.PlayerBucketEvent;
|
|
import org.bukkit.event.player.PlayerInteractEvent;
|
|
import org.bukkit.event.player.PlayerStatisticIncrementEvent;
|
|
import org.bukkit.generator.ChunkGenerator;
|
|
import org.bukkit.inventory.CookingRecipe;
|
|
import org.bukkit.inventory.FurnaceRecipe;
|
|
import org.bukkit.inventory.Inventory;
|
|
import org.bukkit.inventory.ItemFactory;
|
|
import org.bukkit.inventory.ItemStack;
|
|
import org.bukkit.inventory.RecipeChoice;
|
|
import org.bukkit.inventory.ShapedRecipe;
|
|
import org.bukkit.inventory.ShapelessRecipe;
|
|
import org.bukkit.inventory.StonecuttingRecipe;
|
|
import org.bukkit.inventory.meta.BlockDataMeta;
|
|
import org.bukkit.inventory.meta.ItemMeta;
|
|
import org.bukkit.inventory.meta.components.ToolComponent;
|
|
import org.bukkit.material.MaterialData;
|
|
import org.bukkit.packs.DataPackManager;
|
|
import org.bukkit.scoreboard.Criteria;
|
|
|
|
public class MaterialRerouting {
|
|
|
|
private static Material transformFromBlockType(Material blockType, ApiVersion version) {
|
|
if (blockType == null) {
|
|
return null;
|
|
}
|
|
|
|
if (version.isOlderThan(ApiVersion.FLATTENING)) {
|
|
return CraftLegacy.toLegacyData(blockType, false).getItemType();
|
|
}
|
|
|
|
return blockType;
|
|
}
|
|
|
|
private static Material transformFromItemType(Material itemType, ApiVersion version) {
|
|
if (itemType == null) {
|
|
return null;
|
|
}
|
|
|
|
if (version.isOlderThan(ApiVersion.FLATTENING)) {
|
|
return CraftLegacy.toLegacyData(itemType, true).getItemType();
|
|
}
|
|
|
|
return itemType;
|
|
}
|
|
|
|
private static Material transformToBlockType(Material material) {
|
|
if (material == null) {
|
|
return null;
|
|
}
|
|
|
|
if (material.isLegacy()) {
|
|
return CraftLegacy.fromLegacy(new MaterialData(material), false);
|
|
}
|
|
|
|
return material;
|
|
}
|
|
|
|
private static Material transformToItemType(Material material) {
|
|
if (material == null) {
|
|
return null;
|
|
}
|
|
|
|
if (material.isLegacy()) {
|
|
return CraftLegacy.fromLegacy(new MaterialData(material), true);
|
|
}
|
|
|
|
return material;
|
|
}
|
|
|
|
public static Material getMaterial(BlockData blockData, @InjectPluginVersion ApiVersion version) {
|
|
return transformFromBlockType(blockData.getMaterial(), version);
|
|
}
|
|
|
|
public static Material getPlacementMaterial(BlockData blockData, @InjectPluginVersion ApiVersion version) {
|
|
return transformFromItemType(blockData.getPlacementMaterial(), version);
|
|
}
|
|
|
|
public static Material getType(Block block, @InjectPluginVersion ApiVersion version) {
|
|
return transformFromBlockType(block.getType(), version);
|
|
}
|
|
|
|
public static void setType(Block block, Material type) {
|
|
block.setType(transformToBlockType(type));
|
|
}
|
|
|
|
public static void setType(Block block, Material type, boolean applyPhysics) {
|
|
block.setType(transformToBlockType(type), applyPhysics);
|
|
}
|
|
|
|
public static Material getType(BlockState blockState, @InjectPluginVersion ApiVersion version) {
|
|
return transformFromBlockType(blockState.getType(), version);
|
|
}
|
|
|
|
public static void setType(BlockState blockState, Material type) {
|
|
blockState.setType(transformToBlockType(type));
|
|
}
|
|
|
|
public static void setSherd(DecoratedPot decoratedPot, DecoratedPot.Side side, Material sherd) {
|
|
decoratedPot.setSherd(side, transformToItemType(sherd));
|
|
}
|
|
|
|
public static Material getSherd(DecoratedPot decoratedPot, DecoratedPot.Side side, @InjectPluginVersion ApiVersion version) {
|
|
return transformFromItemType(decoratedPot.getSherd(side), version);
|
|
}
|
|
|
|
public static Map<DecoratedPot.Side, Material> getSherds(DecoratedPot decoratedPot, @InjectPluginVersion ApiVersion version) {
|
|
Map<DecoratedPot.Side, Material> result = new EnumMap<>(DecoratedPot.Side.class);
|
|
for (Map.Entry<DecoratedPot.Side, Material> entry : decoratedPot.getSherds().entrySet()) {
|
|
result.put(entry.getKey(), transformFromItemType(entry.getValue(), version));
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
@Deprecated
|
|
public static List<Material> getShards(DecoratedPot decoratedPot, @InjectPluginVersion ApiVersion version) {
|
|
return decoratedPot.getSherds().values().stream().map(shard -> transformFromItemType(shard, version)).toList();
|
|
}
|
|
|
|
public static void setPlaying(Jukebox jukebox, Material record) {
|
|
jukebox.setPlaying(transformToItemType(record));
|
|
}
|
|
|
|
public static Material getPlaying(Jukebox jukebox, @InjectPluginVersion ApiVersion version) {
|
|
return transformFromItemType(jukebox.getPlaying(), version);
|
|
}
|
|
|
|
public static boolean includes(EnchantmentTarget enchantmentTarget, Material item) {
|
|
return enchantmentTarget.includes(transformToItemType(item));
|
|
}
|
|
|
|
public static boolean isBreedItem(Animals animals, Material material) {
|
|
return animals.isBreedItem(transformToItemType(material));
|
|
}
|
|
|
|
public static Material getMaterial(Boat.Type type, @InjectPluginVersion ApiVersion version) {
|
|
return transformFromItemType(type.getMaterial(), version);
|
|
}
|
|
|
|
@Deprecated
|
|
public static Material getMaterial(FallingBlock fallingBlock, @InjectPluginVersion ApiVersion version) {
|
|
return transformFromBlockType(fallingBlock.getBlockData().getMaterial(), version);
|
|
}
|
|
|
|
public static boolean hasCooldown(HumanEntity humanEntity, Material material) {
|
|
return humanEntity.hasCooldown(transformToItemType(material));
|
|
}
|
|
|
|
public static int getCooldown(HumanEntity humanEntity, Material material) {
|
|
return humanEntity.getCooldown(transformToItemType(material));
|
|
}
|
|
|
|
public static void setCooldown(HumanEntity humanEntity, Material material, int ticks) {
|
|
humanEntity.setCooldown(transformToItemType(material), ticks);
|
|
}
|
|
|
|
public static List<Block> getLineOfSight(LivingEntity livingEntity, Set<Material> transparent, int maxDistance) {
|
|
if (transparent == null) {
|
|
return livingEntity.getLineOfSight(null, maxDistance);
|
|
}
|
|
|
|
return livingEntity.getLineOfSight(transparent.stream().map(MaterialRerouting::transformToBlockType).collect(Collectors.toSet()), maxDistance);
|
|
}
|
|
|
|
public static Block getTargetBlock(LivingEntity livingEntity, Set<Material> transparent, int maxDistance) {
|
|
if (transparent == null) {
|
|
return livingEntity.getTargetBlock(null, maxDistance);
|
|
}
|
|
|
|
return livingEntity.getTargetBlock(transparent.stream().map(MaterialRerouting::transformToBlockType).collect(Collectors.toSet()), maxDistance);
|
|
}
|
|
|
|
public static List<Block> getLastTwoTargetBlocks(LivingEntity livingEntity, Set<Material> transparent, int maxDistance) {
|
|
if (transparent == null) {
|
|
return livingEntity.getLastTwoTargetBlocks(null, maxDistance);
|
|
}
|
|
|
|
return livingEntity.getLastTwoTargetBlocks(transparent.stream().map(MaterialRerouting::transformToBlockType).collect(Collectors.toSet()), maxDistance);
|
|
}
|
|
|
|
public static boolean addBarterMaterial(Piglin piglin, Material material) {
|
|
return piglin.addBarterMaterial(transformToItemType(material));
|
|
}
|
|
|
|
public static boolean removeBarterMaterial(Piglin piglin, Material material) {
|
|
return piglin.removeBarterMaterial(transformToItemType(material));
|
|
}
|
|
|
|
public static boolean addMaterialOfInterest(Piglin piglin, Material material) {
|
|
return piglin.addMaterialOfInterest(transformToItemType(material));
|
|
}
|
|
|
|
public static boolean removeMaterialOfInterest(Piglin piglin, Material material) {
|
|
return piglin.removeMaterialOfInterest(transformToItemType(material));
|
|
}
|
|
|
|
public static Set<Material> getInterestList(Piglin piglin, @InjectPluginVersion ApiVersion version) {
|
|
return piglin.getInterestList().stream().map(item -> transformFromItemType(item, version)).collect(Collectors.toSet());
|
|
}
|
|
|
|
public static Set<Material> getBarterList(Piglin piglin, @InjectPluginVersion ApiVersion version) {
|
|
return piglin.getBarterList().stream().map(item -> transformFromItemType(item, version)).collect(Collectors.toSet());
|
|
}
|
|
|
|
@Deprecated
|
|
public static void sendBlockChange(Player player, Location location, Material material, byte data) {
|
|
player.sendBlockChange(location, CraftBlockData.fromData(CraftMagicNumbers.getBlock(material, data)));
|
|
}
|
|
|
|
public static Material getSteerMaterial(Steerable steerable, @InjectPluginVersion ApiVersion version) {
|
|
return transformFromItemType(steerable.getSteerMaterial(), version);
|
|
}
|
|
|
|
public static Material getMaterial(BlockCanBuildEvent blockCanBuildEvent, @InjectPluginVersion ApiVersion version) {
|
|
return transformFromBlockType(blockCanBuildEvent.getMaterial(), version);
|
|
}
|
|
|
|
public static Material getChangedType(BlockPhysicsEvent blockPhysicsEvent, @InjectPluginVersion ApiVersion version) {
|
|
return transformFromBlockType(blockPhysicsEvent.getChangedType(), version);
|
|
}
|
|
|
|
public static Material getTo(EntityChangeBlockEvent entityChangeBlockEvent, @InjectPluginVersion ApiVersion version) {
|
|
return transformFromBlockType(entityChangeBlockEvent.getTo(), version);
|
|
}
|
|
|
|
public static Material getItemType(FurnaceExtractEvent furnaceExtractEvent, @InjectPluginVersion ApiVersion version) {
|
|
return transformFromItemType(furnaceExtractEvent.getItemType(), version);
|
|
}
|
|
|
|
public static Material getBucket(PlayerBucketEvent playerBucketEvent, @InjectPluginVersion ApiVersion version) {
|
|
return transformFromItemType(playerBucketEvent.getBucket(), version);
|
|
}
|
|
|
|
public static Material getMaterial(PlayerInteractEvent playerInteractEvent, @InjectPluginVersion ApiVersion version) {
|
|
return transformFromItemType(playerInteractEvent.getMaterial(), version);
|
|
}
|
|
|
|
public static Material getMaterial(PlayerStatisticIncrementEvent playerStatisticIncrementEvent, @InjectPluginVersion ApiVersion version) {
|
|
if (playerStatisticIncrementEvent.getStatistic().getType() == Statistic.Type.BLOCK) {
|
|
return transformFromBlockType(playerStatisticIncrementEvent.getMaterial(), version);
|
|
} else if (playerStatisticIncrementEvent.getStatistic().getType() == Statistic.Type.ITEM) {
|
|
return transformFromItemType(playerStatisticIncrementEvent.getMaterial(), version);
|
|
} else {
|
|
// Theoretically this should be null, but just in case convert from block type
|
|
// Can probably check if it is not null and print a warning, but for now it should be fine without the check.
|
|
return transformFromBlockType(playerStatisticIncrementEvent.getMaterial(), version);
|
|
}
|
|
}
|
|
|
|
public static void setBlock(ChunkGenerator.ChunkData chunkData, int x, int y, int z, Material material) {
|
|
chunkData.setBlock(x, y, z, transformToBlockType(material));
|
|
}
|
|
|
|
public static void setRegion(ChunkGenerator.ChunkData chunkData, int xMin, int yMin, int zMin, int xMax, int yMax, int zMax, Material material) {
|
|
chunkData.setRegion(xMin, yMin, zMin, xMax, yMax, zMax, transformToBlockType(material));
|
|
}
|
|
|
|
public static Material getType(ChunkGenerator.ChunkData chunkData, int x, int y, int z, @InjectPluginVersion ApiVersion version) {
|
|
return transformFromBlockType(chunkData.getType(x, y, z), version);
|
|
}
|
|
|
|
public static BlockData getBlockData(BlockDataMeta blockDataMeta, Material material) {
|
|
return blockDataMeta.getBlockData(transformToBlockType(material));
|
|
}
|
|
|
|
public static CookingRecipe<?> setInput(CookingRecipe<?> cookingRecipe, Material material) {
|
|
return cookingRecipe.setInput(transformToItemType(material));
|
|
}
|
|
|
|
public static FurnaceRecipe setInput(FurnaceRecipe furnaceRecipe, Material material) {
|
|
return furnaceRecipe.setInput(transformToItemType(material));
|
|
}
|
|
|
|
@Deprecated
|
|
public static FurnaceRecipe setInput(FurnaceRecipe furnaceRecipe, Material material, int data) {
|
|
return furnaceRecipe.setInput(CraftItemType.minecraftToBukkit(CraftMagicNumbers.getItem(material, (short) data)));
|
|
}
|
|
|
|
public static boolean contains(Inventory inventory, Material material) {
|
|
return inventory.contains(transformToItemType(material));
|
|
}
|
|
|
|
public static boolean contains(Inventory inventory, Material material, int amount) {
|
|
return inventory.contains(transformToItemType(material), amount);
|
|
}
|
|
|
|
public static HashMap<Integer, ? extends ItemStack> all(Inventory inventory, Material material) {
|
|
return inventory.all(transformToItemType(material));
|
|
}
|
|
|
|
public static int first(Inventory inventory, Material material) {
|
|
return inventory.first(transformToItemType(material));
|
|
}
|
|
|
|
public static void remove(Inventory inventory, Material material) {
|
|
inventory.remove(transformToItemType(material));
|
|
}
|
|
|
|
public static ItemMeta getItemMeta(ItemFactory itemFactory, Material material) {
|
|
return itemFactory.getItemMeta(transformToItemType(material));
|
|
}
|
|
|
|
public static boolean isApplicable(ItemFactory itemFactory, ItemMeta itemMeta, Material material) {
|
|
return itemFactory.isApplicable(itemMeta, transformToItemType(material));
|
|
}
|
|
|
|
public static ItemMeta asMetaFor(ItemFactory itemFactory, ItemMeta itemMeta, Material material) {
|
|
return itemFactory.asMetaFor(itemMeta, transformToItemType(material));
|
|
}
|
|
|
|
public static Material getSpawnEgg(ItemFactory itemFactory, EntityType entityType, @InjectPluginVersion ApiVersion version) {
|
|
return transformFromItemType(itemFactory.getSpawnEgg(entityType), version);
|
|
}
|
|
|
|
public static Material getType(ItemStack itemStack, @InjectPluginVersion ApiVersion version) {
|
|
return transformFromItemType(itemStack.getType(), version);
|
|
}
|
|
|
|
public static void setType(ItemStack itemStack, Material material) {
|
|
itemStack.setType(transformToItemType(material));
|
|
}
|
|
|
|
public static List<Material> getChoices(RecipeChoice.MaterialChoice materialChoice, @InjectPluginVersion ApiVersion version) {
|
|
return materialChoice.getChoices().stream().map(m -> transformFromItemType(m, version)).toList();
|
|
}
|
|
|
|
public static ShapedRecipe setIngredient(ShapedRecipe shapedRecipe, char key, Material material) {
|
|
return shapedRecipe.setIngredient(key, transformToItemType(material));
|
|
}
|
|
|
|
@Deprecated
|
|
public static ShapedRecipe setIngredient(ShapedRecipe shapedRecipe, char key, Material material, int raw) {
|
|
return shapedRecipe.setIngredient(key, CraftItemType.minecraftToBukkit(CraftMagicNumbers.getItem(material, (short) raw)));
|
|
}
|
|
|
|
public static ShapelessRecipe addIngredient(ShapelessRecipe shapelessRecipe, Material material) {
|
|
return shapelessRecipe.addIngredient(transformToItemType(material));
|
|
}
|
|
|
|
@Deprecated
|
|
public static ShapelessRecipe addIngredient(ShapelessRecipe shapelessRecipe, Material material, int raw) {
|
|
return shapelessRecipe.addIngredient(CraftItemType.minecraftToBukkit(CraftMagicNumbers.getItem(material, (short) raw)));
|
|
}
|
|
|
|
public static ShapelessRecipe addIngredient(ShapelessRecipe shapelessRecipe, int count, Material material) {
|
|
return shapelessRecipe.addIngredient(count, transformToItemType(material));
|
|
}
|
|
|
|
@Deprecated
|
|
public static ShapelessRecipe addIngredient(ShapelessRecipe shapelessRecipe, int count, Material material, int raw) {
|
|
return shapelessRecipe.addIngredient(count, CraftItemType.minecraftToBukkit(CraftMagicNumbers.getItem(material, (short) raw)));
|
|
}
|
|
|
|
public static ShapelessRecipe removeIngredient(ShapelessRecipe shapelessRecipe, Material material) {
|
|
return shapelessRecipe.removeIngredient(transformToItemType(material));
|
|
}
|
|
|
|
public static ShapelessRecipe removeIngredient(ShapelessRecipe shapelessRecipe, int count, Material material) {
|
|
return shapelessRecipe.removeIngredient(count, transformToItemType(material));
|
|
}
|
|
|
|
@Deprecated
|
|
public static ShapelessRecipe removeIngredient(ShapelessRecipe shapelessRecipe, Material material, int raw) {
|
|
return shapelessRecipe.removeIngredient(CraftItemType.minecraftToBukkit(CraftMagicNumbers.getItem(material, (short) raw)));
|
|
}
|
|
|
|
@Deprecated
|
|
public static ShapelessRecipe removeIngredient(ShapelessRecipe shapelessRecipe, int count, Material material, int raw) {
|
|
return shapelessRecipe.removeIngredient(count, CraftItemType.minecraftToBukkit(CraftMagicNumbers.getItem(material, (short) raw)));
|
|
}
|
|
|
|
public static StonecuttingRecipe setInput(StonecuttingRecipe stonecuttingRecipe, Material material) {
|
|
return stonecuttingRecipe.setInput(transformToItemType(material));
|
|
}
|
|
|
|
public static boolean isEnabledByFeature(DataPackManager dataPackManager, Material material, World world) {
|
|
return dataPackManager.isEnabledByFeature(transformToItemType(material), world);
|
|
}
|
|
|
|
@RerouteStatic("org/bukkit/scoreboard/Criteria")
|
|
public static Criteria statistic(Statistic statistic, Material material) {
|
|
if (statistic.getType() == Statistic.Type.BLOCK) {
|
|
return Criteria.statistic(statistic, transformToBlockType(material));
|
|
} else if (statistic.getType() == Statistic.Type.ITEM) {
|
|
return Criteria.statistic(statistic, transformToItemType(material));
|
|
} else {
|
|
// This is not allowed, the method will throw an error
|
|
return Criteria.statistic(statistic, transformToBlockType(material));
|
|
}
|
|
}
|
|
|
|
@RerouteStatic("org/bukkit/Bukkit")
|
|
public static BlockData createBlockData(Material material) {
|
|
return Bukkit.createBlockData(transformToBlockType(material));
|
|
}
|
|
|
|
@RerouteStatic("org/bukkit/Bukkit")
|
|
public static BlockData createBlockData(Material material, Consumer<? super BlockData> consumer) {
|
|
return Bukkit.createBlockData(transformToBlockType(material), consumer);
|
|
}
|
|
|
|
@RerouteStatic("org/bukkit/Bukkit")
|
|
public static BlockData createBlockData(Material material, String data) {
|
|
return Bukkit.createBlockData(transformToBlockType(material), data);
|
|
}
|
|
|
|
public static Material getBlockType(ChunkSnapshot chunkSnapshot, int x, int y, int z, @InjectPluginVersion ApiVersion version) {
|
|
return transformFromBlockType(chunkSnapshot.getBlockType(x, y, z), version);
|
|
}
|
|
|
|
public static void incrementStatistic(OfflinePlayer offlinePlayer, Statistic statistic, Material material) {
|
|
if (statistic.getType() == Statistic.Type.BLOCK) {
|
|
offlinePlayer.incrementStatistic(statistic, transformToBlockType(material));
|
|
} else if (statistic.getType() == Statistic.Type.ITEM) {
|
|
offlinePlayer.incrementStatistic(statistic, transformToItemType(material));
|
|
} else {
|
|
// This is not allowed, the method will throw an error
|
|
offlinePlayer.incrementStatistic(statistic, transformToBlockType(material));
|
|
}
|
|
}
|
|
|
|
public static void decrementStatistic(OfflinePlayer offlinePlayer, Statistic statistic, Material material) {
|
|
if (statistic.getType() == Statistic.Type.BLOCK) {
|
|
offlinePlayer.decrementStatistic(statistic, transformToBlockType(material));
|
|
} else if (statistic.getType() == Statistic.Type.ITEM) {
|
|
offlinePlayer.decrementStatistic(statistic, transformToItemType(material));
|
|
} else {
|
|
// This is not allowed, the method will throw an error
|
|
offlinePlayer.decrementStatistic(statistic, transformToBlockType(material));
|
|
}
|
|
}
|
|
|
|
public static int getStatistic(OfflinePlayer offlinePlayer, Statistic statistic, Material material) {
|
|
if (statistic.getType() == Statistic.Type.BLOCK) {
|
|
return offlinePlayer.getStatistic(statistic, transformToBlockType(material));
|
|
} else if (statistic.getType() == Statistic.Type.ITEM) {
|
|
return offlinePlayer.getStatistic(statistic, transformToItemType(material));
|
|
} else {
|
|
// This is not allowed, the method will throw an error
|
|
return offlinePlayer.getStatistic(statistic, transformToBlockType(material));
|
|
}
|
|
}
|
|
|
|
public static void incrementStatistic(OfflinePlayer offlinePlayer, Statistic statistic, Material material, int amount) {
|
|
if (statistic.getType() == Statistic.Type.BLOCK) {
|
|
offlinePlayer.incrementStatistic(statistic, transformToBlockType(material), amount);
|
|
} else if (statistic.getType() == Statistic.Type.ITEM) {
|
|
offlinePlayer.incrementStatistic(statistic, transformToItemType(material), amount);
|
|
} else {
|
|
// This is not allowed, the method will throw an error
|
|
offlinePlayer.incrementStatistic(statistic, transformToBlockType(material), amount);
|
|
}
|
|
}
|
|
|
|
public static void decrementStatistic(OfflinePlayer offlinePlayer, Statistic statistic, Material material, int amount) {
|
|
if (statistic.getType() == Statistic.Type.BLOCK) {
|
|
offlinePlayer.decrementStatistic(statistic, transformToBlockType(material), amount);
|
|
} else if (statistic.getType() == Statistic.Type.ITEM) {
|
|
offlinePlayer.decrementStatistic(statistic, transformToItemType(material), amount);
|
|
} else {
|
|
// This is not allowed, the method will throw an error
|
|
offlinePlayer.decrementStatistic(statistic, transformToBlockType(material), amount);
|
|
}
|
|
}
|
|
|
|
public static void setStatistic(OfflinePlayer offlinePlayer, Statistic statistic, Material material, int newValue) {
|
|
if (statistic.getType() == Statistic.Type.BLOCK) {
|
|
offlinePlayer.setStatistic(statistic, transformToBlockType(material), newValue);
|
|
} else if (statistic.getType() == Statistic.Type.ITEM) {
|
|
offlinePlayer.setStatistic(statistic, transformToItemType(material), newValue);
|
|
} else {
|
|
// This is not allowed, the method will throw an error
|
|
offlinePlayer.setStatistic(statistic, transformToBlockType(material), newValue);
|
|
}
|
|
}
|
|
|
|
public static Material getType(RegionAccessor regionAccessor, Location location, @InjectPluginVersion ApiVersion version) {
|
|
return transformFromBlockType(regionAccessor.getType(location), version);
|
|
}
|
|
|
|
public static Material getType(RegionAccessor regionAccessor, int x, int y, int z, @InjectPluginVersion ApiVersion version) {
|
|
return transformFromBlockType(regionAccessor.getType(x, y, z), version);
|
|
}
|
|
|
|
public static void setType(RegionAccessor regionAccessor, Location location, Material material) {
|
|
regionAccessor.setType(location, transformToBlockType(material));
|
|
}
|
|
|
|
public static void setType(RegionAccessor regionAccessor, int x, int y, int z, Material material) {
|
|
regionAccessor.setType(x, y, z, transformToBlockType(material));
|
|
}
|
|
|
|
public static BlockData createBlockData(Server server, Material material) {
|
|
return server.createBlockData(transformToBlockType(material));
|
|
}
|
|
|
|
public static BlockData createBlockData(Server server, Material material, Consumer<? super BlockData> consumer) {
|
|
return server.createBlockData(transformToBlockType(material), consumer);
|
|
}
|
|
|
|
public static BlockData createBlockData(Server server, Material material, String data) {
|
|
return server.createBlockData(transformToBlockType(material), data);
|
|
}
|
|
|
|
public static <T extends Keyed> boolean isTagged(Tag<T> tag, T item) {
|
|
if (tag instanceof CraftBlockTag) {
|
|
return tag.isTagged((T) transformToBlockType((Material) item));
|
|
} else if (tag instanceof CraftItemTag) {
|
|
return tag.isTagged((T) transformToItemType((Material) item));
|
|
}
|
|
|
|
return tag.isTagged(item);
|
|
}
|
|
|
|
public static <T extends Keyed> Set<T> getValues(Tag<T> tag, @InjectPluginVersion ApiVersion version) {
|
|
Set<T> values = tag.getValues();
|
|
if (values.isEmpty()) {
|
|
return values;
|
|
}
|
|
|
|
if (tag instanceof CraftBlockTag) {
|
|
return values.stream().map(val -> (Material) val).map(val -> transformFromBlockType(val, version)).map(val -> (T) val).collect(Collectors.toSet());
|
|
} else if (tag instanceof CraftItemTag) {
|
|
return values.stream().map(val -> (Material) val).map(val -> transformFromItemType(val, version)).map(val -> (T) val).collect(Collectors.toSet());
|
|
}
|
|
|
|
return values;
|
|
}
|
|
|
|
@Deprecated
|
|
public static FallingBlock spawnFallingBlock(World world, Location location, Material material, byte data) {
|
|
return world.spawnFallingBlock(location, CraftBlockData.fromData(CraftMagicNumbers.getBlock(material, data)));
|
|
}
|
|
|
|
public static ToolComponent.ToolRule addRule(ToolComponent toolComponent, Material block, Float speed, Boolean correctForDrops) {
|
|
return toolComponent.addRule(transformToBlockType(block), speed, correctForDrops);
|
|
}
|
|
|
|
public static ToolComponent.ToolRule addRule(ToolComponent toolComponent, Collection<Material> blocks, Float speed, Boolean correctForDrops) {
|
|
return toolComponent.addRule(blocks.stream().map(MaterialRerouting::transformToBlockType).collect(Collectors.toList()), speed, correctForDrops);
|
|
}
|
|
|
|
public static Collection<Material> getBlocks(ToolComponent.ToolRule toolRule, @InjectPluginVersion ApiVersion version) {
|
|
return toolRule.getBlocks().stream().map(val -> transformFromBlockType(val, version)).toList();
|
|
}
|
|
|
|
public static void setBlocks(ToolComponent.ToolRule toolRule, Material block) {
|
|
toolRule.setBlocks(transformToBlockType(block));
|
|
}
|
|
|
|
public static void setBlocks(ToolComponent.ToolRule toolRule, Collection<Material> blocks) {
|
|
toolRule.setBlocks(blocks.stream().map(MaterialRerouting::transformToBlockType).toList());
|
|
}
|
|
}
|