Expose server build information (#10729)

* Expose server build information

* squash patches

* final tweaks

---------

Co-authored-by: Jake Potrebic <[email protected]>
Co-authored-by: masmc05 <[email protected]>

1 files changed, 116 insertions, 0 deletions

diff --git a/patches/api/0432-Add-predicate-for-blocks-when-raytracing.patch b/patches/api/0432-Add-predicate-for-blocks-when-raytracing.patch
new file mode 100644
index 0000000000..c212167a42
--- /dev/null
+++ b/patches/api/0432-Add-predicate-for-blocks-when-raytracing.patch
@@ -0,0 +1,116 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: TonytheMacaroni <[email protected]>
+Date: Wed, 6 Sep 2023 19:24:53 -0400
+Subject: [PATCH] Add predicate for blocks when raytracing
+
+
+diff --git a/src/main/java/org/bukkit/World.java b/src/main/java/org/bukkit/World.java
+index 00fbc02a1751902edda327236e51a6991f5366f8..3abd62dc08e1edaeec6773819c8726671221074a 100644
+--- a/src/main/java/org/bukkit/World.java
++++ b/src/main/java/org/bukkit/World.java
+@@ -1703,6 +1703,27 @@ public interface World extends RegionAccessor, WorldInfo, PluginMessageRecipient
+     @Nullable
+     public RayTraceResult rayTraceEntities(@NotNull Location start, @NotNull Vector direction, double maxDistance, double raySize, @Nullable Predicate<? super Entity> filter);
+ 
++    // Paper start
++    /**
++     * Performs a ray trace that checks for entity collisions.
++     * <p>
++     * This may not consider entities in currently unloaded chunks. Some
++     * implementations may impose artificial restrictions on the maximum
++     * distance.
++     *
++     * @param start the start position
++     * @param direction the ray direction
++     * @param maxDistance the maximum distance
++     * @param raySize entity bounding boxes will be uniformly expanded (or
++     *     shrinked) by this value before doing collision checks
++     * @param filter only entities that fulfill this predicate are considered,
++     *     or <code>null</code> to consider all entities
++     * @return the closest ray trace hit result, or <code>null</code> if there
++     *     is no hit
++     */
++    @Nullable RayTraceResult rayTraceEntities(io.papermc.paper.math.@NotNull Position start, @NotNull Vector direction, double maxDistance, double raySize, @Nullable Predicate<? super Entity> filter);
++    // Paper end
++
+     /**
+      * Performs a ray trace that checks for block collisions using the blocks'
+      * precise collision shapes.
+@@ -1766,6 +1787,34 @@ public interface World extends RegionAccessor, WorldInfo, PluginMessageRecipient
+     @Nullable
+     public RayTraceResult rayTraceBlocks(@NotNull Location start, @NotNull Vector direction, double maxDistance, @NotNull FluidCollisionMode fluidCollisionMode, boolean ignorePassableBlocks);
+ 
++    // Paper start
++    /**
++     * Performs a ray trace that checks for block collisions using the blocks'
++     * precise collision shapes.
++     * <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 maxDistance the maximum distance
++     * @param fluidCollisionMode the fluid collision mode
++     * @param ignorePassableBlocks whether to ignore passable but collidable
++     *     blocks (ex. tall grass, signs, fluids, ..)
++     * @param canCollide predicate for blocks the ray can potentially collide
++     *     with, or <code>null</code> to consider all blocks
++     * @return the ray trace hit result, or <code>null</code> if there is no hit
++     */
++    @Nullable RayTraceResult rayTraceBlocks(io.papermc.paper.math.@NotNull Position start, @NotNull Vector direction, double maxDistance, @NotNull FluidCollisionMode fluidCollisionMode, boolean ignorePassableBlocks, @Nullable Predicate<? super Block> canCollide);
++    // Paper end
++
+     /**
+      * Performs a ray trace that checks for both block and entity collisions.
+      * <p>
+@@ -1799,6 +1848,42 @@ public interface World extends RegionAccessor, WorldInfo, PluginMessageRecipient
+     @Nullable
+     public RayTraceResult rayTrace(@NotNull Location start, @NotNull Vector direction, double maxDistance, @NotNull FluidCollisionMode fluidCollisionMode, boolean ignorePassableBlocks, double raySize, @Nullable Predicate<? super Entity> filter);
+ 
++    // Paper start
++    /**
++     * 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 maxDistance the maximum distance
++     * @param fluidCollisionMode the fluid collision mode
++     * @param ignorePassableBlocks whether to ignore passable but collidable
++     *     blocks (ex. tall grass, signs, fluids, ..)
++     * @param raySize entity bounding boxes will be uniformly expanded (or
++     *     shrinked) by this value before doing collision checks
++     * @param filter only entities that fulfill this predicate are considered,
++     *     or <code>null</code> to consider all entities
++     * @param canCollide predicate for blocks the ray can potentially collide
++     *     with, or <code>null</code> to consider all blocks
++     * @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(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
++
+     /**
+      * Gets the default spawn {@link Location} of this world
+      *