Upstream
/
Paper
mirror of https://github.com/PaperMC/Paper.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge ea1febddea into 8f7ac62905

This commit is contained in:
Tamion 2024-04-29 08:33:37 +02:00 committed by GitHub
parent 8f7ac62905 ea1febddea
commit ce15c13e89
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
2 changed files with 406 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

376
patches/api/0473-Add-RayTraceConfiguration.patch Normal file
View File

@ -0,0 +1,376 @@
From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
From: Tamion <70228790+notTamion@users.noreply.github.com>
Date: Sun, 11 Feb 2024 08:47:54 +0100
Subject: [PATCH] Add RayTraceConfiguration
diff --git a/src/main/java/io/papermc/paper/raytracing/RayTraceConfiguration.java b/src/main/java/io/papermc/paper/raytracing/RayTraceConfiguration.java
new file mode 100644
index 0000000000000000000000000000000000000000..293ad30b365320867beb1784ed07c47d63f29f56
--- /dev/null
+++ b/src/main/java/io/papermc/paper/raytracing/RayTraceConfiguration.java
@@ -0,0 +1,206 @@
+package io.papermc.paper.raytracing;
+
+import org.bukkit.FluidCollisionMode;
+import org.bukkit.block.Block;
+import org.bukkit.entity.Entity;
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import java.util.List;
+import java.util.function.Predicate;
+
+/**
+ * Holds information about how to cast a raytrace.
+ */
+public interface RayTraceConfiguration {
+
+ /**
+ * Creates a new builder.
+ *
+ * @return the new builder
+ */
+ @NotNull
+ static Builder builder() {
+ return new RayTraceConfigurationBuilderImpl();
+ }
+
+ /**
+ * Gets the maximum distance.
+ *
+ * @return the maximum distance
+ */
+ double maxDistance();
+
+ /**
+ * Gets the FluidCollisionMode when looking for block collisions.
+ *
+ * @return the FluidCollisionMode
+ */
+ @Nullable
+ FluidCollisionMode fluidCollisionMode();
+
+ /**
+ * Gets if the raytrace will ignore passable blocks when looking for block collisions.
+ *
+ * @return if the raytrace will ignore passable blocks
+ */
+ boolean ignorePassableBlocks();
+
+ /**
+ * Gets the size of the raytrace when looking for entity collisions.
+ *
+ * @return the raytrace size
+ */
+ double raySize();
+
+ /**
+ * Gets the current entity filter.
+ *
+ * @return predicate for entities the ray can potentially collide with, or null to consider all entities
+ */
+ @Nullable
+ Predicate<? super Entity> entityFilter();
+
+ /**
+ * Gets the current block filter.
+ *
+ * @return predicate for blocks the ray can potentially collide with, or null to consider all blocks
+ */
+ @Nullable
+ Predicate<? super Block> blockFilter();
+
+ /**
+ * Gets which RayTraceTargets this configuration was made for.
+ *
+ * @return the targets
+ */
+ @NotNull
+ List<Targets> targets();
+
+ /**
+ * Helps you create a RayTraceConfiguration.
+ */
+ interface Builder {
+
+ /**
+ * Gets the maximum distance.
+ *
+ * @return the maximum distance
+ */
+ double maxDistance();
+
+ /**
+ * Sets the maximum distance.
+ *
+ * @param maxDistance the new maxDistance
+ * @return a reference to this object
+ */
+ @NotNull
+ @Contract("_ -> this")
+ Builder maxDistance(double maxDistance);
+
+ /**
+ * Gets the FluidCollisionMode when looking for block collisions.
+ *
+ * @return the FluidCollisionMode
+ */
+ @Nullable
+ FluidCollisionMode fluidCollisionMode();
+
+ /**
+ * Sets the FluidCollisionMode when looking for block collisions.
+ *
+ * @param fluidCollisionMode the new FluidCollisionMode
+ * @return a reference to this object
+ */
+ @NotNull
+ @Contract("_ -> this")
+ Builder fluidCollisionMode(@Nullable FluidCollisionMode fluidCollisionMode);
+
+ /**
+ * Gets if the raytrace will ignore passable blocks when looking for block collisions.
+ *
+ * @return if the raytrace will ignore passable blocks
+ */
+ boolean ignorePassableBlocks();
+
+ /**
+ * Gets if the raytrace will ignore passable blocks when looking for block collisions.
+ *
+ * @param ignorePassableBlocks if the raytrace should ignore passable blocks
+ * @return a reference to this object
+ */
+ @NotNull
+ @Contract("_ -> this")
+ Builder ignorePassableBlocks(boolean ignorePassableBlocks);
+
+ /**
+ * Gets the size of the raytrace when looking for entity collisions.
+ *
+ * @return the raytrace size
+ */
+ double raySize();
+
+ /**
+ * Sets the size of the raytrace when looking for entity collisions.
+ *
+ * @param raySize the new raytrace size
+ * @return a reference to this object
+ */
+ @NotNull
+ @Contract("_ -> this")
+ Builder raySize(double raySize);
+
+ /**
+ * Gets the current entity filter when looking for entity collisions.
+ *
+ * @return predicate for entities the ray can potentially collide with, or null to consider all entities
+ */
+ @Nullable
+ Predicate<? super Entity> entityFilter();
+
+ /**
+ * Sets the current entity filter when looking for entity collisions.
+ *
+ * @param entityFilter predicate for entities the ray can potentially collide with, or null to consider all entities
+ * @return a reference to this object
+ */
+ @NotNull
+ @Contract("_ -> this")
+ Builder entityFilter(@Nullable Predicate<? super Entity> entityFilter);
+
+ /**
+ * Gets the current block filter when looking for block collisions.
+ *
+ * @return predicate for blocks the ray can potentially collide with, or null to consider all blocks
+ */
+ @Nullable
+ Predicate<? super Block> blockFilter();
+
+ /**
+ * Sets the current block filter when looking for block collisions.
+ *
+ * @param blockFilter predicate for blocks the ray can potentially collide with, or null to consider all blocks
+ * @return a reference to this object
+ */
+ @NotNull
+ @Contract("_ -> this")
+ Builder blockFilter(@Nullable Predicate<? super Block> blockFilter);
+
+ /**
+ * Builds a configuration based on the provided targets.
+ *
+ * @return the configuration
+ */
+ @NotNull
+ RayTraceConfiguration target(@NotNull Targets first, @NotNull Targets... others);
+ }
+
+ /**
+ * List of Targets the builder can target.
+ */
+ enum Targets {
+ ENTITIES,
+ BLOCKS
+ }
+}
diff --git a/src/main/java/io/papermc/paper/raytracing/RayTraceConfigurationBuilderImpl.java b/src/main/java/io/papermc/paper/raytracing/RayTraceConfigurationBuilderImpl.java
new file mode 100644
index 0000000000000000000000000000000000000000..b6a9e03023ced3d88dc39a59a314d1fdc1d827ce
--- /dev/null
+++ b/src/main/java/io/papermc/paper/raytracing/RayTraceConfigurationBuilderImpl.java
@@ -0,0 +1,93 @@
+package io.papermc.paper.raytracing;
+import org.bukkit.FluidCollisionMode;
+import org.bukkit.block.Block;
+import org.bukkit.entity.Entity;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.Predicate;
+
+public class RayTraceConfigurationBuilderImpl implements RayTraceConfiguration.Builder {
+
+ private double maxDistance;
+ private FluidCollisionMode fluidCollisionMode = FluidCollisionMode.NEVER;
+ private boolean ignorePassableBlocks;
+ private double raySize = 0.0D;
+ private Predicate<? super Entity> entityFilter;
+ private Predicate<? super Block> blockFilter;
+
+
+ @Override
+ public double maxDistance() {
+ return maxDistance;
+ }
+
+ @Override
+ public @NotNull RayTraceConfiguration.Builder maxDistance(double maxDistance) {
+ this.maxDistance = maxDistance;
+ return this;
+ }
+
+ @Override
+ public @Nullable FluidCollisionMode fluidCollisionMode() {
+ return fluidCollisionMode;
+ }
+
+ @Override
+ public @NotNull RayTraceConfiguration.Builder fluidCollisionMode(@Nullable FluidCollisionMode fluidCollisionMode) {
+ this.fluidCollisionMode = fluidCollisionMode;
+ return this;
+ }
+
+ @Override
+ public boolean ignorePassableBlocks() {
+ return ignorePassableBlocks;
+ }
+
+ @Override
+ public @NotNull RayTraceConfiguration.Builder ignorePassableBlocks(boolean ignorePassableBlocks) {
+ this.ignorePassableBlocks = ignorePassableBlocks;
+ return this;
+ }
+
+ @Override
+ public double raySize() {
+ return raySize;
+ }
+
+ @Override
+ public @NotNull RayTraceConfiguration.Builder raySize(double raySize) {
+ this.raySize = raySize;
+ return this;
+ }
+
+ @Override
+ public @Nullable Predicate<? super Entity> entityFilter() {
+ return entityFilter;
+ }
+
+ @Override
+ public @NotNull RayTraceConfiguration.Builder entityFilter(@Nullable Predicate<? super Entity> entityFilter) {
+ this.entityFilter = entityFilter;
+ return this;
+ }
+
+ @Override
+ public @Nullable Predicate<? super Block> blockFilter() {
+ return blockFilter;
+ }
+
+ @Override
+ public @NotNull RayTraceConfiguration.Builder blockFilter(@Nullable Predicate<? super Block> blockFilter) {
+ this.blockFilter = blockFilter;
+ return this;
+ }
+
+ @Override
+ public @NotNull RayTraceConfiguration target(@NotNull RayTraceConfiguration.Targets first, @NotNull RayTraceConfiguration.Targets... others) {
+ List<RayTraceConfiguration.Targets> targets = new ArrayList<>(List.of(others)); // Need to make this immutable later
+ targets.add(first);
+ return new RayTraceConfigurationImpl(maxDistance, fluidCollisionMode, ignorePassableBlocks, raySize, entityFilter, blockFilter, targets);
+ }
+}
diff --git a/src/main/java/io/papermc/paper/raytracing/RayTraceConfigurationImpl.java b/src/main/java/io/papermc/paper/raytracing/RayTraceConfigurationImpl.java
new file mode 100644
index 0000000000000000000000000000000000000000..ffe49cd1ecc9075315c9695dd1aa4a3f94caefcc
--- /dev/null
+++ b/src/main/java/io/papermc/paper/raytracing/RayTraceConfigurationImpl.java
@@ -0,0 +1,15 @@
+package io.papermc.paper.raytracing;
+
+import org.bukkit.FluidCollisionMode;
+import org.bukkit.block.Block;
+import org.bukkit.entity.Entity;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import java.util.List;
+import java.util.function.Predicate;
+
+public record RayTraceConfigurationImpl(double maxDistance, @Nullable FluidCollisionMode fluidCollisionMode,
+ boolean ignorePassableBlocks, double raySize,
+ @Nullable Predicate<? super Entity> entityFilter, @Nullable Predicate<? super Block> blockFilter,
+ @NotNull List<Targets> targets) implements RayTraceConfiguration {
+}
diff --git a/src/main/java/org/bukkit/World.java b/src/main/java/org/bukkit/World.java
index 97f97ea5c6aa513c439f86a9c82821e0f7d9cd1e..972bee9c2fc9a79c7ab2922b88d567fd03ff831a 100644
--- a/src/main/java/org/bukkit/World.java
+++ b/src/main/java/org/bukkit/World.java
@@ -1908,6 +1908,33 @@ public interface World extends RegionAccessor, WorldInfo, PluginMessageRecipient
@Nullable RayTraceResult rayTrace(io.papermc.paper.math.@NotNull Position start, @NotNull Vector direction, double maxDistance, @NotNull FluidCollisionMode fluidCollisionMode, boolean ignorePassableBlocks, double raySize, @Nullable Predicate<? super Entity> filter, @Nullable Predicate<? super Block> canCollide);
// Paper end
+ // Paper start - Add RayTraceConfiguration
+ /**
+ * Performs a ray trace that checks for both block and entity collisions.
+ * <p>
+ * Block collisions use the blocks' precise collision shapes. The
+ * <code>raySize</code> parameter is only taken into account for entity
+ * collision checks.
+ * <p>
+ * If collisions with passable blocks are ignored, fluid collisions are
+ * ignored as well regardless of the fluid collision mode.
+ * <p>
+ * Portal blocks are only considered passable if the ray starts within them.
+ * Apart from that collisions with portal blocks will be considered even if
+ * collisions with passable blocks are otherwise ignored.
+ * <p>
+ * This may cause loading of chunks! Some implementations may impose
+ * artificial restrictions on the maximum distance.
+ *
+ * @param start the start position
+ * @param direction the ray direction
+ * @param config the configuration
+ * @return the closest ray trace hit result with either a block or an
+ * entity, or <code>null</code> if there is no hit
+ */
+ @Nullable RayTraceResult rayTrace(@NotNull Location start, @NotNull Vector direction, @NotNull io.papermc.paper.raytracing.RayTraceConfiguration config);
+ // Paper end - Add RayTraceConfiguration
+
/**
* Gets the default spawn {@link Location} of this world
*

30
patches/server/1046-Add-RayTraceConfiguration.patch Normal file
View File

@ -0,0 +1,30 @@
From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
From: Tamion <70228790+notTamion@users.noreply.github.com>
Date: Sun, 11 Feb 2024 08:49:30 +0100
Subject: [PATCH] Add RayTraceConfiguration
diff --git a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
index f2b20ed5063a293f0b464548f590d652170cd1d8..b1290a02d06927209c3a25a10be7a34e944eac86 100644
--- a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
+++ b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
@@ -1306,6 +1306,19 @@ public class CraftWorld extends CraftRegionAccessor implements World {
return blockHit;
}
+ // Paper start - Add RayTraceConfiguration
+ @Override
+ public @org.jetbrains.annotations.Nullable RayTraceResult rayTrace(Location start, Vector direction, io.papermc.paper.raytracing.RayTraceConfiguration config) {
+ List<io.papermc.paper.raytracing.RayTraceConfiguration.Targets> targets = config.targets();
+ if (targets.contains(io.papermc.paper.raytracing.RayTraceConfiguration.Targets.ENTITIES)) {
+ if(targets.contains(io.papermc.paper.raytracing.RayTraceConfiguration.Targets.BLOCKS))
+ return this.rayTrace(start, direction, config.maxDistance(), config.fluidCollisionMode(), config.ignorePassableBlocks(), config.raySize(), config.entityFilter(), config.blockFilter());
+ return this.rayTraceEntities(start, direction, config.maxDistance(), config.raySize(), config.entityFilter());
+ }
+ return this.rayTraceBlocks(start, direction, config.maxDistance(), config.fluidCollisionMode(), config.ignorePassableBlocks(), config.blockFilter());
+ }
+ // Paper end - Add RayTraceConfiguration
+
@Override
public List<Player> getPlayers() {
List<Player> list = new ArrayList<Player>(this.world.players().size());