Update chunk ticket API

generator/src/main/java/org/spongepowered/vanilla/generator/world/WorldRegistries.java

@@ -53,6 +53,13 @@ public static List<Generator> worldRegistries(final Context context) {
                 "getSerializedName",
                 "sponge"
             ),
+            new RegistryEntriesGenerator<>(
+                "world.server",
+                "TicketTypes",
+                "TICKET_TYPE",
+                context.relativeClass("world.server", "TicketType"),
+                Registries.TICKET_TYPE
+            ),
             new RegistryEntriesGenerator<>(
                 "effect.particle",
                 "ParticleTypes",

src/main/java/org/spongepowered/common/bridge/world/DistanceManagerBridge.java

@@ -25,26 +25,28 @@
 package org.spongepowered.common.bridge.world;
 
 import org.spongepowered.api.util.Ticks;
-import org.spongepowered.api.world.server.ServerWorld;
 import org.spongepowered.api.world.server.Ticket;
 import org.spongepowered.api.world.server.TicketType;
 import org.spongepowered.math.vector.Vector3i;
 
 import java.util.Collection;
-import java.util.Optional;
 
 public interface DistanceManagerBridge {
 
-    boolean bridge$checkTicketValid(Ticket<?> ticket);
+    boolean bridge$checkTicketValid(Ticket ticket);
 
-    Ticks bridge$timeLeft(Ticket<?> ticket);
+    Ticks bridge$timeLeft(Ticket ticket);
 
-    <S, T> Optional<Ticket<T>> bridge$registerTicket(ServerWorld world, TicketType<T> ticketType, Vector3i pos, T value, int distanceLimit);
+    Ticket bridge$registerTicket(TicketType ticketType, Vector3i pos, int radius);
 
-    boolean bridge$renewTicket(Ticket<?> ticket);
+    boolean bridge$renewTicket(Ticket ticket);
 
-    boolean bridge$releaseTicket(Ticket<?> ticket);
+    boolean bridge$releaseTicket(Ticket ticket);
 
-    <T> Collection<Ticket<T>> bridge$tickets(TicketType<T> ticketType);
+    Collection<Ticket> bridge$tickets(Vector3i pos);
+
+    Collection<Ticket> bridge$tickets(org.spongepowered.api.world.server.TicketType type);
+
+    Collection<Ticket> bridge$tickets();
 
 }

src/main/java/org/spongepowered/common/bridge/world/server/TicketBridge.java

@@ -32,7 +32,7 @@ public interface TicketBridge {
 
     void bridge$setChunkPosition(long chunkPos);
 
-    <T> org.spongepowered.api.world.server.Ticket<T> bridge$retrieveAppropriateTicket();
+    Ticket bridge$retrieveAppropriateTicket();
 
     void bridge$setParentTicket(Ticket parentTicket);
 

src/main/java/org/spongepowered/common/util/Constants.java

@@ -467,12 +467,9 @@ public static final class Chunk {
 
     public static final class ChunkTicket {
 
-        public static final int MAX_FULL_CHUNK_TICKET_LEVEL = ChunkLevel.byStatus(FullChunkStatus.ENTITY_TICKING);
+        public static final int FULL_CHUNK_MAX_TICKET_LEVEL = ChunkLevel.byStatus(FullChunkStatus.FULL);
 
-        // Highest ticket level that will cause loading a full chunk, plus one.
-        public static final int MAX_FULL_CHUNK_DISTANCE = ChunkTicket.MAX_FULL_CHUNK_TICKET_LEVEL + 1;
-
-        public static final int INFINITE_TIMEOUT = 0;
+        public static final long INFINITE_TIMEOUT = 0;
     }
 
     public static final class Networking {

src/main/java/org/spongepowered/common/world/server/SpongeTicketTypeBuilder.java

@@ -25,43 +25,64 @@
 package org.spongepowered.common.world.server;
 
 import org.checkerframework.checker.nullness.qual.MonotonicNonNull;
-import org.checkerframework.checker.nullness.qual.Nullable;
 import org.spongepowered.api.util.Ticks;
 import org.spongepowered.api.world.server.TicketType;
 import org.spongepowered.common.util.Constants;
 
-import java.util.Comparator;
 import java.util.Objects;
 
-@SuppressWarnings("unchecked")
-public final class SpongeTicketTypeBuilder<T> implements TicketType.Builder<T> {
+public final class SpongeTicketTypeBuilder implements TicketType.Builder {
 
-    private @MonotonicNonNull String name;
-    private @Nullable Comparator<T> comparator;
     private @MonotonicNonNull Ticks lifetime;
+    private int flags;
 
     @Override
-    public TicketType.Builder<T> reset() {
-        this.name = null;
-        this.comparator = null;
+    public TicketType.Builder reset() {
         this.lifetime = null;
+        this.flags = 0;
+        return this;
+    }
+
+    private void setFlag(int flag, boolean value) {
+        if (value) {
+            this.flags |= flag;
+        } else {
+            this.flags &= ~flag;
+        }
+    }
+
+    @Override
+    public TicketType.Builder persists(boolean persists) {
+        this.setFlag(net.minecraft.server.level.TicketType.FLAG_PERSIST, persists);
+        return this;
+    }
+
+    @Override
+    public TicketType.Builder loadsChunks(boolean loadsChunks) {
+        this.setFlag(net.minecraft.server.level.TicketType.FLAG_LOADING, loadsChunks);
+        return this;
+    }
+
+    @Override
+    public TicketType.Builder simulatesChunks(boolean simulatesChunks) {
+        this.setFlag(net.minecraft.server.level.TicketType.FLAG_SIMULATION, simulatesChunks);
         return this;
     }
 
     @Override
-    public TicketType.Builder<T> name(final String name) {
-        this.name = Objects.requireNonNull(name, "Name cannot null");
+    public TicketType.Builder keepsWorldActive(boolean keepsWorldActive) {
+        this.setFlag(net.minecraft.server.level.TicketType.FLAG_KEEP_DIMENSION_ACTIVE, keepsWorldActive);
         return this;
     }
 
     @Override
-    public TicketType.Builder<T> comparator(final @Nullable Comparator<T> comparator) {
-        this.comparator = comparator;
+    public TicketType.Builder canExpireIfUnloaded(boolean canExpireIfUnloaded) {
+        this.setFlag(net.minecraft.server.level.TicketType.FLAG_CAN_EXPIRE_IF_UNLOADED, canExpireIfUnloaded);
         return this;
     }
 
     @Override
-    public TicketType.Builder<T> lifetime(final Ticks lifetime) {
+    public TicketType.Builder lifetime(final Ticks lifetime) {
         Objects.requireNonNull(lifetime, "Lifetime cannot be null");
         if (!lifetime.isInfinite() && lifetime.ticks() <= 0) {
             throw new IllegalArgumentException("The lifetime is required to be a positive integer");
@@ -71,16 +92,9 @@ public TicketType.Builder<T> lifetime(final Ticks lifetime) {
     }
 
     @Override
-    public TicketType<T> build() {
-        Objects.requireNonNull(this.name, "Name cannot null");
+    public TicketType build() {
         Objects.requireNonNull(this.lifetime, "Lifetime cannot be null");
-        if (this.comparator == null) {
-            this.comparator = (v1, v2) -> 0;
-        }
-        final var flag = net.minecraft.server.level.TicketType.FLAG_LOADING
-            | net.minecraft.server.level.TicketType.FLAG_SIMULATION
-            | net.minecraft.server.level.TicketType.FLAG_KEEP_DIMENSION_ACTIVE;
         final var timeout = this.lifetime.isInfinite() ? Constants.ChunkTicket.INFINITE_TIMEOUT : this.lifetime.ticks();
-        return (TicketType<T>) (Object) new net.minecraft.server.level.TicketType(timeout,flag);
+        return (TicketType) (Object) new net.minecraft.server.level.TicketType(timeout, this.flags);
     }
 }

src/mixins/java/org/spongepowered/common/mixin/api/minecraft/server/level/ChunkMapMixin_API.java

@@ -39,7 +39,7 @@
 import org.spongepowered.math.vector.Vector3i;
 
 import java.util.Collection;
-import java.util.Optional;
+import java.util.Objects;
 import java.util.concurrent.CompletableFuture;
 
 @Mixin(ChunkMap.class)
@@ -55,43 +55,56 @@ public abstract class ChunkMapMixin_API implements org.spongepowered.api.world.s
     }
 
     @Override
-    public boolean valid(final @NonNull Ticket<?> ticket) {
+    public boolean valid(final @NonNull Ticket ticket) {
+        Objects.requireNonNull(ticket, "ticket");
         return ((ChunkMapBridge) this).bridge$distanceManager().bridge$checkTicketValid(ticket);
     }
 
     @Override
-    public @NonNull Ticks timeLeft(final @NonNull Ticket<?> ticket) {
+    public @NonNull Ticks timeLeft(final @NonNull Ticket ticket) {
+        Objects.requireNonNull(ticket, "ticket");
         return ((ChunkMapBridge) this).bridge$distanceManager().bridge$timeLeft(ticket);
     }
 
     @Override
-    public <T> @NonNull Optional<Ticket<T>> requestTicket(final @NonNull TicketType<T> type, final @NonNull Vector3i chunkPosition,
-            final @NonNull T value, final int radius) {
-        if (!((Object) type instanceof net.minecraft.server.level.TicketType)) {
-            throw new IllegalArgumentException("TicketType must be a Minecraft TicketType");
+    public @NonNull Ticket requestTicket(final @NonNull TicketType type, final @NonNull Vector3i chunkPosition, final int radius) {
+        Objects.requireNonNull(type, "type");
+        Objects.requireNonNull(chunkPosition, "chunkPosition");
+        if (radius < 0) {
+            throw new IllegalArgumentException("The radius must be not be negative.");
         }
-        if (radius < 1) {
-            throw new IllegalArgumentException("The radius must be positive.");
-        }
-        return ((ChunkMapBridge) this).bridge$distanceManager()
-                .bridge$registerTicket(this.world(), type, chunkPosition, value, radius);
+        return ((ChunkMapBridge) this).bridge$distanceManager().bridge$registerTicket(type, chunkPosition, radius);
     }
 
     @Override
-    public boolean renewTicket(final @NonNull Ticket<?> ticket) {
+    public boolean renewTicket(final @NonNull Ticket ticket) {
+        Objects.requireNonNull(ticket, "ticket");
         return ((ChunkMapBridge) this).bridge$distanceManager().bridge$renewTicket(ticket);
     }
 
     @Override
-    public boolean releaseTicket(final @NonNull Ticket<?> ticket) {
+    public boolean releaseTicket(final @NonNull Ticket ticket) {
+        Objects.requireNonNull(ticket, "ticket");
         return ((ChunkMapBridge) this).bridge$distanceManager().bridge$releaseTicket(ticket);
     }
 
     @Override
-    public <T> @NonNull Collection<Ticket<T>> findTickets(final @NonNull TicketType<T> type) {
+    public @NonNull Collection<Ticket> findTickets(final @NonNull Vector3i chunkOrigin) {
+        Objects.requireNonNull(chunkOrigin, "chunkOrigin");
+        return ((ChunkMapBridge) this).bridge$distanceManager().bridge$tickets(chunkOrigin);
+    }
+
+    @Override
+    public @NonNull Collection<Ticket> findTickets(final @NonNull TicketType type) {
+        Objects.requireNonNull(type, "type");
         return ((ChunkMapBridge) this).bridge$distanceManager().bridge$tickets(type);
     }
 
+    @Override
+    public @NonNull Collection<Ticket> findTickets() {
+        return ((ChunkMapBridge) this).bridge$distanceManager().bridge$tickets();
+    }
+
     @Override
     public @NonNull CompletableFuture<Boolean> regenerateChunk(final int cx, final int cy, final int cz, final @NonNull ChunkRegenerateFlag flag) {
         final CompletableFuture<Boolean> cf = new CompletableFuture<>();

src/mixins/java/org/spongepowered/common/mixin/api/minecraft/server/level/TicketMixin_API.java

@@ -25,8 +25,36 @@
 package org.spongepowered.common.mixin.api.minecraft.server.level;
 
 import net.minecraft.server.level.Ticket;
+import net.minecraft.world.level.ChunkPos;
+import org.spongepowered.api.world.server.TicketType;
+import org.spongepowered.asm.mixin.Final;
 import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.common.bridge.world.server.TicketBridge;
+import org.spongepowered.common.util.Constants;
+import org.spongepowered.common.util.VecHelper;
+import org.spongepowered.math.vector.Vector3i;
 
 @Mixin(Ticket.class)
-public abstract class TicketMixin_API<T> implements org.spongepowered.api.world.server.Ticket<T> {
+public abstract class TicketMixin_API implements org.spongepowered.api.world.server.Ticket {
+
+    // @formatter:off
+    @Shadow @Final private net.minecraft.server.level.TicketType type;
+    @Shadow @Final private int ticketLevel;
+    // @formatter:on
+
+    @Override
+    public TicketType type() {
+        return (TicketType) (Object) this.type;
+    }
+
+    @Override
+    public Vector3i chunkOrigin() {
+        return VecHelper.toVector3i(new ChunkPos(((TicketBridge) this).bridge$chunkPosition()));
+    }
+
+    @Override
+    public int radius() {
+        return Math.max(0, Constants.ChunkTicket.FULL_CHUNK_MAX_TICKET_LEVEL - this.ticketLevel);
+    }
 }

src/mixins/java/org/spongepowered/common/mixin/api/minecraft/server/level/TicketTypeMixin_API.java

@@ -24,33 +24,50 @@
  */
 package org.spongepowered.common.mixin.api.minecraft.server.level;
 
+import net.minecraft.server.level.TicketType;
 import org.checkerframework.checker.nullness.qual.NonNull;
 import org.spongepowered.api.util.Ticks;
-import org.spongepowered.api.world.server.TicketType;
 import org.spongepowered.asm.mixin.Final;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Shadow;
 import org.spongepowered.common.util.Constants;
 
-@Mixin(net.minecraft.server.level.TicketType.class)
-public abstract class TicketTypeMixin_API<T> implements TicketType<T> {
+@Mixin(TicketType.class)
+public abstract class TicketTypeMixin_API implements org.spongepowered.api.world.server.TicketType {
 
     // @formatter:off
     @Shadow @Final private long timeout;
-
+    @Shadow @Final private int flags;
     // @formatter:on
 
     @Override
-    public String name() {
-        // TODO - change this out
-        return "";
+    public boolean persists() {
+        return (this.flags & TicketType.FLAG_PERSIST) != 0;
+    }
+
+    @Override
+    public boolean loadsChunks() {
+        return (this.flags & TicketType.FLAG_LOADING) != 0;
+    }
+
+    @Override
+    public boolean simulatesChunks() {
+        return (this.flags & TicketType.FLAG_SIMULATION) != 0;
+    }
+
+    @Override
+    public boolean keepsWorldActive() {
+        return (this.flags & TicketType.FLAG_KEEP_DIMENSION_ACTIVE) != 0;
+    }
+
+    @Override
+    public boolean canExpireIfUnloaded() {
+        return (this.flags & TicketType.FLAG_CAN_EXPIRE_IF_UNLOADED) != 0;
     }
 
     @Override
     @NonNull
     public Ticks lifetime() {
-        return this.timeout == Constants.ChunkTicket.INFINITE_TIMEOUT
-                ? Ticks.infinite()
-                : Ticks.of(this.timeout);
+        return this.timeout == Constants.ChunkTicket.INFINITE_TIMEOUT ? Ticks.infinite() : Ticks.of(this.timeout);
     }
 }