SteamWar/Paper-Old
Archiviert
13
0
Fork 0
Code Issues Pull-Requests Projekte Releases Wiki Aktivität
Dieses Repository wurde am 2024-12-25 archiviert. Du kannst Dateien ansehen und es klonen, aber nicht pushen oder Issues/Pull-Requests öffnen.
e51401e764
Paper-Old/patches/api/0258-Add-StructuresLocateEvent.patch
Nassim Jahnke 385f313a8b
Updated Upstream (Bukkit/CraftBukkit/Spigot) (#8092) 
Upstream has released updates that appear to apply and compile correctly.
This update has not been tested by PaperMC and as with ANY update, please do your own testing

Bukkit Changes:
d41796de SPIGOT-7071: Add Player#stopSound(SoundCategory category)
61dae5b2 SPIGOT-7011, SPIGOT-7065: Overhaul of structures

CraftBukkit Changes:
991aeda12 SPIGOT-1729, SPIGOT-7090: Keep precision in teleportation between worlds
5c9a5f628 SPIGOT-7071: Add Player#stopSound(SoundCategory category)
68f888ded SPIGOT-7011, SPIGOT-7065: Overhaul of structures
0231a3746 Remove outdated build delay.

Spigot Changes:
475f6008 Rebuild patches
8ce1761f Rebuild patches
2022-07-04 16:38:06 +02:00

463 Zeilen
17 KiB
Diff
Originalformat Blame Verlauf

From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
From: dfsek <dfsek@protonmail.com>
Date: Tue, 15 Sep 2020 21:59:16 -0700
Subject: [PATCH] Add StructuresLocateEvent
Co-authored-by: Jake Potrebic <jake.m.potrebic@gmail.com>
diff --git a/src/main/java/io/papermc/paper/event/world/StructureLocateEvent.java b/src/main/java/io/papermc/paper/event/world/StructureLocateEvent.java
new file mode 100644
index 0000000000000000000000000000000000000000..0c83a02059d65672ff191c42932d850950e9ea00
--- /dev/null
+++ b/src/main/java/io/papermc/paper/event/world/StructureLocateEvent.java
@@ -0,0 +1,157 @@
+package io.papermc.paper.event.world;
+
+import org.bukkit.Location;
+import org.bukkit.StructureType;
+import org.bukkit.World;
+import org.bukkit.event.Cancellable;
+import org.bukkit.event.HandlerList;
+import org.bukkit.event.world.WorldEvent;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Called <b>before</b> a structure/feature is located.
+ * This happens when:
+ * <ul>
+ * <li>The /locate command is used.<br></li>
+ * <li>An Eye of Ender is used.</li>
+ * <li>An Explorer/Treasure Map is activated.</li>
+ * <li>{@link World#locateNearestStructure(Location, StructureType, int, boolean)} is invoked.</li>
+ * </ul>
+ * @deprecated no longer used, see {@link StructuresLocateEvent}
+ */
+@Deprecated(forRemoval = true)
+public class StructureLocateEvent extends WorldEvent implements Cancellable {
+ private static final HandlerList handlers = new HandlerList();
+ private final Location origin;
+ private Location result = null;
+ private StructureType type;
+ private int radius;
+ private boolean findUnexplored;
+ private boolean cancelled = false;
+
+ public StructureLocateEvent(@NotNull World world, @NotNull Location origin, @NotNull StructureType structureType, int radius, boolean findUnexplored) {
+ super(world);
+ this.origin = origin;
+ this.type = structureType;
+ this.radius = radius;
+ this.findUnexplored = findUnexplored;
+ }
+
+ @NotNull
+ public static HandlerList getHandlerList() {
+ return handlers;
+ }
+
+ @NotNull
+ @Override
+ public HandlerList getHandlers() {
+ return handlers;
+ }
+
+ /**
+ * Gets the location set as the structure location, if it was defined.
+ * <p>
+ * Returns {@code null} if it has not been set by {@link StructureLocateEvent#setResult(Location)}.
+ * Since this event fires <i>before</i> the search is done, the actual location is unknown at this point.
+ *
+ * @return The result location, if it has been set. null if it has not.
+ * @see World#locateNearestStructure(Location, StructureType, int, boolean)
+ */
+ @Nullable
+ public Location getResult() {
+ return result;
+ }
+
+ /**
+ * Sets the result {@link Location}. This causes the search to be skipped, and the location passed here to be used as the result.
+ *
+ * @param result the {@link Location} of the structure.
+ */
+ public void setResult(@Nullable Location result) {
+ this.result = result;
+ }
+
+ /**
+ * Gets the {@link StructureType} that is to be located.
+ *
+ * @return the structure type.
+ */
+ @NotNull
+ public StructureType getType() {
+ return type;
+ }
+
+ /**
+ * Sets the {@link StructureType} that is to be located.
+ *
+ * @param type the structure type.
+ */
+ public void setType(@NotNull StructureType type) {
+ this.type = type;
+ }
+
+ /**
+ * Gets the {@link Location} from which the search is to be conducted.
+ *
+ * @return {@link Location} where search begins
+ */
+ @NotNull
+ public Location getOrigin() {
+ return origin;
+ }
+
+ /**
+ * Gets the search radius in which to attempt locating the structure.
+ * <p>
+ * This radius may not always be obeyed during the structure search!
+ *
+ * @return the search radius.
+ */
+ public int getRadius() {
+ return radius;
+ }
+
+ /**
+ * Sets the search radius in which to attempt locating the structure.
+ * <p>
+ * This radius may not always be obeyed during the structure search!
+ *
+ * @param radius the search radius.
+ */
+ public void setRadius(int radius) {
+ this.radius = radius;
+ }
+
+ /**
+ * Gets whether to search exclusively for unexplored structures.
+ * <p>
+ * As with the search radius, this value is not always obeyed.
+ *
+ * @return Whether to search for only unexplored structures.
+ */
+ public boolean shouldFindUnexplored() {
+ return findUnexplored;
+ }
+
+ /**
+ * Sets whether to search exclusively for unexplored structures.
+ * <p>
+ * As with the search radius, this value is not always obeyed.
+ *
+ * @param findUnexplored Whether to search for only unexplored structures.
+ */
+ public void setFindUnexplored(boolean findUnexplored) {
+ this.findUnexplored = findUnexplored;
+ }
+
+ @Override
+ public boolean isCancelled() {
+ return cancelled;
+ }
+
+ @Override
+ public void setCancelled(boolean cancel) {
+ this.cancelled = cancel;
+ }
+}
diff --git a/src/main/java/io/papermc/paper/event/world/StructuresLocateEvent.java b/src/main/java/io/papermc/paper/event/world/StructuresLocateEvent.java
new file mode 100644
index 0000000000000000000000000000000000000000..566f9df8f615142e14330965f3491f4e83846783
--- /dev/null
+++ b/src/main/java/io/papermc/paper/event/world/StructuresLocateEvent.java
@@ -0,0 +1,164 @@
+package io.papermc.paper.event.world;
+
+import io.papermc.paper.world.structure.ConfiguredStructure;
+import org.bukkit.Location;
+import org.bukkit.World;
+import org.bukkit.event.Cancellable;
+import org.bukkit.event.HandlerList;
+import org.bukkit.event.world.WorldEvent;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Called <b>before</b> a set of configured structures is located.
+ * This happens when:
+ * <ul>
+ * <li>The /locate command is used.<br></li>
+ * <li>An Eye of Ender is used.</li>
+ * <li>An Explorer/Treasure Map is activated.</li>
+ * <li>A dolphin swims to a treasure location.</li>
+ * <li>A trade is done with a villager for a map.</li>
+ * <li>{@link World#locateNearestStructure(Location, org.bukkit.StructureType, int, boolean)} is invoked.</li>
+ * </ul>
+ */
+public class StructuresLocateEvent extends WorldEvent implements Cancellable {
+
+ private static final HandlerList HANDLER_LIST = new HandlerList();
+
+ private final Location origin;
+ private Result result;
+ private List<ConfiguredStructure> configuredStructures;
+ private int radius;
+ private boolean findUnexplored;
+ private boolean cancelled;
+
+ public StructuresLocateEvent(@NotNull World world, @NotNull Location origin, @NotNull List<ConfiguredStructure> configuredStructures, int radius, boolean findUnexplored) {
+ super(world);
+ this.origin = origin;
+ this.configuredStructures = configuredStructures;
+ this.radius = radius;
+ this.findUnexplored = findUnexplored;
+ }
+
+ /**
+ * Gets the {@link Location} from which the search is to be conducted.
+ *
+ * @return {@link Location} where search begins
+ */
+ public @NotNull Location getOrigin() {
+ return this.origin;
+ }
+
+ /**
+ * Gets the {@link Location} and {@link ConfiguredStructure} set as the result, if it was defined.
+ * <p>
+ * Returns {@code null} if it has not been set by {@link StructuresLocateEvent#setResult(Result)}.
+ * Since this event fires <i>before</i> the search is done, the actual result is unknown at this point.
+ *
+ * @return The result location and structure, if it has been set. null if it has not.
+ * @see World#locateNearestStructure(Location, org.bukkit.StructureType, int, boolean)
+ */
+ public @Nullable Result getResult() {
+ return this.result;
+ }
+
+ /**
+ * Sets the result {@link Location} and {@link ConfiguredStructure}. This causes the search to be
+ * skipped, and the result object passed here to be used as the result.
+ *
+ * @param result the {@link Location} and {@link ConfiguredStructure} of the search.
+ */
+ public void setResult(@Nullable Result result) {
+ this.result = result;
+ }
+
+ /**
+ * Gets a mutable list of ConfiguredStructures that are valid targets for the search.
+ *
+ * @return a mutable list of ConfiguredStructures
+ */
+ public @NotNull List<ConfiguredStructure> getConfiguredStructures() {
+ return this.configuredStructures;
+ }
+
+ /**
+ * Sets the list of ConfiguredStructures that are valid targets for the search.
+ *
+ * @param configuredStructures a list of ConfiguredStructure targets
+ */
+ public void setConfiguredStructures(@NotNull List<ConfiguredStructure> configuredStructures) {
+ this.configuredStructures = new ArrayList<>(configuredStructures);
+ }
+
+ /**
+ * Gets the search radius in which to attempt locating the structure.
+ * <p>
+ * This radius may not always be obeyed during the structure search!
+ *
+ * @return the search radius.
+ */
+ public int getRadius() {
+ return this.radius;
+ }
+
+ /**
+ * Sets the search radius in which to attempt locating the structure.
+ * <p>
+ * This radius may not always be obeyed during the structure search!
+ *
+ * @param radius the search radius.
+ */
+ public void setRadius(int radius) {
+ this.radius = radius;
+ }
+
+ /**
+ * Gets whether to search exclusively for unexplored structures.
+ * <p>
+ * As with the search radius, this value is not always obeyed.
+ *
+ * @return Whether to search for only unexplored structures.
+ */
+ public boolean shouldFindUnexplored() {
+ return this.findUnexplored;
+ }
+
+ /**
+ * Sets whether to search exclusively for unexplored structures.
+ * <p>
+ * As with the search radius, this value is not always obeyed.
+ *
+ * @param findUnexplored Whether to search for only unexplored structures.
+ */
+ public void setFindUnexplored(boolean findUnexplored) {
+ this.findUnexplored = findUnexplored;
+ }
+
+ @Override
+ public boolean isCancelled() {
+ return this.cancelled;
+ }
+
+ @Override
+ public void setCancelled(boolean cancel) {
+ this.cancelled = cancel;
+ }
+
+ @Override
+ public @NotNull HandlerList getHandlers() {
+ return HANDLER_LIST;
+ }
+
+ public static @NotNull HandlerList getHandlerList() {
+ return HANDLER_LIST;
+ }
+
+ /**
+ * Result for {@link StructuresLocateEvent}.
+ */
+ public record Result(@NotNull Location position, @NotNull ConfiguredStructure configuredStructure) {
+ }
+}
diff --git a/src/main/java/io/papermc/paper/world/structure/ConfiguredStructure.java b/src/main/java/io/papermc/paper/world/structure/ConfiguredStructure.java
new file mode 100644
index 0000000000000000000000000000000000000000..5a43e40b7311ed2acb51f6ba8b12d1f34569ff2e
--- /dev/null
+++ b/src/main/java/io/papermc/paper/world/structure/ConfiguredStructure.java
@@ -0,0 +1,98 @@
+package io.papermc.paper.world.structure;
+
+import io.papermc.paper.registry.Reference;
+import org.bukkit.Keyed;
+import org.bukkit.NamespacedKey;
+import org.bukkit.Registry;
+import org.bukkit.StructureType;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Objects;
+
+/**
+ * Represents a configured structure each with a
+ * {@link StructureType}. Multiple ConfiguredStructures can have
+ * the same {@link StructureType}.
+ */
+public final class ConfiguredStructure implements Keyed {
+
+ public static final Reference<ConfiguredStructure> PILLAGER_OUTPOST = create("pillager_outpost");
+ public static final Reference<ConfiguredStructure> MINESHAFT = create("mineshaft");
+ public static final Reference<ConfiguredStructure> MINESHAFT_MESA = create("mineshaft_mesa");
+ public static final Reference<ConfiguredStructure> WOODLAND_MANSION = create("mansion");
+ public static final Reference<ConfiguredStructure> JUNGLE_TEMPLE = create("jungle_pyramid");
+ public static final Reference<ConfiguredStructure> DESERT_PYRAMID = create("desert_pyramid");
+ public static final Reference<ConfiguredStructure> IGLOO = create("igloo");
+ public static final Reference<ConfiguredStructure> SHIPWRECK = create("shipwreck");
+ public static final Reference<ConfiguredStructure> SHIPWRECK_BEACHED = create("shipwreck_beached");
+ public static final Reference<ConfiguredStructure> SWAMP_HUT = create("swamp_hut");
+ public static final Reference<ConfiguredStructure> STRONGHOLD = create("stronghold");
+ public static final Reference<ConfiguredStructure> OCEAN_MONUMENT = create("monument");
+ public static final Reference<ConfiguredStructure> OCEAN_RUIN_COLD = create("ocean_ruin_cold");
+ public static final Reference<ConfiguredStructure> OCEAN_RUIN_WARM = create("ocean_ruin_warm");
+ public static final Reference<ConfiguredStructure> FORTRESS = create("fortress");
+ public static final Reference<ConfiguredStructure> NETHER_FOSSIL = create("nether_fossil");
+ public static final Reference<ConfiguredStructure> END_CITY = create("end_city");
+ public static final Reference<ConfiguredStructure> BURIED_TREASURE = create("buried_treasure");
+ public static final Reference<ConfiguredStructure> BASTION_REMNANT = create("bastion_remnant");
+ public static final Reference<ConfiguredStructure> VILLAGE_PLAINS = create("village_plains");
+ public static final Reference<ConfiguredStructure> VILLAGE_DESERT = create("village_desert");
+ public static final Reference<ConfiguredStructure> VILLAGE_SAVANNA = create("village_savanna");
+ public static final Reference<ConfiguredStructure> VILLAGE_SNOWY = create("village_snowy");
+ public static final Reference<ConfiguredStructure> VILLAGE_TAIGA = create("village_taiga");
+ public static final Reference<ConfiguredStructure> RUINED_PORTAL_STANDARD = create("ruined_portal");
+ public static final Reference<ConfiguredStructure> RUINED_PORTAL_DESERT = create("ruined_portal_desert");
+ public static final Reference<ConfiguredStructure> RUINED_PORTAL_JUNGLE = create("ruined_portal_jungle");
+ public static final Reference<ConfiguredStructure> RUINED_PORTAL_SWAMP = create("ruined_portal_swamp");
+ public static final Reference<ConfiguredStructure> RUINED_PORTAL_MOUNTAIN = create("ruined_portal_mountain");
+ public static final Reference<ConfiguredStructure> RUINED_PORTAL_OCEAN = create("ruined_portal_ocean");
+ public static final Reference<ConfiguredStructure> RUINED_PORTAL_NETHER = create("ruined_portal_nether");
+ // public static final Reference<ConfiguredStructure> ANCIENT_CITY = create("ancient_city"); // TODO remove when upstream adds "jigsaw" StructureType
+
+ private final NamespacedKey key;
+ private final StructureType structureType;
+
+ ConfiguredStructure(@NotNull NamespacedKey key, @NotNull StructureType structureType) {
+ this.key = key;
+ this.structureType = structureType;
+ }
+
+ @Override
+ public @NotNull NamespacedKey getKey() {
+ return this.key;
+ }
+
+ /**
+ * Gets the structure type for this configure structure.
+ *
+ * @return the structure type
+ */
+ public @NotNull StructureType getStructureType() {
+ return this.structureType;
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) return true;
+ if (o == null || getClass() != o.getClass()) return false;
+ ConfiguredStructure structure = (ConfiguredStructure) o;
+ return this.key.equals(structure.key) && this.structureType.equals(structure.structureType);
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(this.key, this.structureType);
+ }
+
+ @Override
+ public String toString() {
+ return "ConfiguredStructure{" +
+ "key=" + this.key +
+ ", structureType=" + this.structureType +
+ '}';
+ }
+
+ private static @NotNull Reference<ConfiguredStructure> create(@NotNull String name) {
+ return Reference.create(Registry.CONFIGURED_STRUCTURE, NamespacedKey.minecraft(name));
+ }
+}
diff --git a/src/main/java/org/bukkit/Registry.java b/src/main/java/org/bukkit/Registry.java
index a77320257b691c3a380f7c59c350382c0c0fe863..ec59aa76488a1500ab3df46c98ba7b1d4179df4e 100644
--- a/src/main/java/org/bukkit/Registry.java
+++ b/src/main/java/org/bukkit/Registry.java
@@ -210,6 +210,13 @@ public interface Registry<T extends Keyed> extends Iterable<T> {
return GameEvent.getByKey(key);
}
};
+ // Paper start
+ /**
+ * Configured structures.
+ * @see io.papermc.paper.world.structure.ConfiguredStructure
+ */
+ Registry<io.papermc.paper.world.structure.ConfiguredStructure> CONFIGURED_STRUCTURE = Bukkit.getRegistry(io.papermc.paper.world.structure.ConfiguredStructure.class);
+ // Paper end
/**
* Get the object by its key.
In neuem Issue referenzieren Git Blame ansehen Permalink kopieren