Compare commits

..

9 Commits

18 changed files with 374 additions and 120 deletions

View File

@ -134,7 +134,7 @@ public class BlockEventListener117 implements Listener {
public void onBlockFertilize(BlockFertilizeEvent event) {
Block block = event.getBlock();
List<org.bukkit.block.BlockState> blocks = event.getBlocks();
Location location = BukkitUtil.adapt(block.getLocation());
Location location = BukkitUtil.adapt(blocks.get(0).getLocation());
PlotArea area = location.getPlotArea();
if (area == null) {

View File

@ -44,7 +44,6 @@ import java.util.List;
import java.util.Queue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.Consumer;
@ -227,22 +226,16 @@ public final class BukkitChunkCoordinator extends ChunkCoordinator {
loadingChunks.incrementAndGet();
PaperLib
.getChunkAtAsync(this.bukkitWorld, chunk.getX(), chunk.getZ(), shouldGen, true)
.orTimeout(10L, TimeUnit.SECONDS)
.completeOnTimeout(null, 10L, TimeUnit.SECONDS)
.whenComplete((chunkObject, throwable) -> {
loadingChunks.decrementAndGet();
if (throwable != null) {
if (throwable instanceof TimeoutException) {
LOGGER.warn("Timed out awaiting chunk load {}", chunk);
this.requestedChunks.offer(chunk);
} else {
LOGGER.error("Failed to load chunk {}", chunk, throwable);
// We want one less because this couldn't be processed
this.expectedSize.decrementAndGet();
}
LOGGER.error("Failed to load chunk {}", chunk, throwable);
// We want one less because this couldn't be processed
this.expectedSize.decrementAndGet();
} else if (chunkObject == null) {
if (shouldGen) {
LOGGER.error("Null chunk returned for chunk at {}", chunk);
}
LOGGER.warn("Timed out awaiting chunk load {}", chunk);
this.requestedChunks.offer(chunk);
} else if (PlotSquared.get().isMainThread(Thread.currentThread())) {
this.processChunk(chunkObject);
} else {

View File

@ -713,8 +713,6 @@ public class PlotSquared {
case CREATION_DATE_TIMESTAMP -> toReturn.addAll(sortPlotsByTimestamp(map.get(area)));
case DISTANCE_FROM_ORIGIN -> toReturn.addAll(sortPlotsByHash(map.get(area)));
case LAST_MODIFIED -> toReturn.addAll(sortPlotsByModified(map.get(area)));
default -> {
}
}
}
return toReturn;

View File

@ -67,13 +67,10 @@ public class Visit extends Command {
private void visit(
final @NonNull PlotPlayer<?> player, final @NonNull PlotQuery query, final PlotArea sortByArea,
final RunnableVal3<Command, Runnable, Runnable> confirm, final RunnableVal2<Command, CommandResult> whenDone, int page
final RunnableVal3<Command, Runnable, Runnable> confirm, final RunnableVal2<Command, CommandResult> whenDone,
int page, final boolean isQueryingBasePlot
) {
// We get the query once,
// then we get it another time further on
final List<Plot> unsorted = query.asList();
if (unsorted.size() > 1) {
if (!isQueryingBasePlot && query.hasMinimumMatches(2)) {
query.whereBasePlot();
}
@ -237,7 +234,8 @@ public class Visit extends Command {
finalSortByArea,
confirm,
whenDone,
finalPage1
finalPage1,
true
);
}
});
@ -261,12 +259,9 @@ public class Visit extends Command {
if (throwable instanceof TimeoutException) {
// The request timed out
player.sendMessage(TranslatableCaption.of("players.fetching_players_timeout"));
} else if (uuid != null && (Settings.Teleport.VISIT_MERGED_OWNERS
? !PlotQuery.newQuery().ownersInclude(uuid).anyMatch()
: !PlotQuery.newQuery().ownedBy(uuid).anyMatch())) {
// It was a valid UUID but the player has no plots
player.sendMessage(TranslatableCaption.of("errors.player_no_plots"));
} else if (uuid == null) {
return;
}
if (uuid == null){
// player not found, so we assume it's an alias if no page was provided
if (finalPage == Integer.MIN_VALUE) {
this.visit(
@ -275,7 +270,8 @@ public class Visit extends Command {
player.getApplicablePlotArea(),
confirm,
whenDone,
1
1,
false
);
} else {
player.sendMessage(
@ -283,24 +279,23 @@ public class Visit extends Command {
TagResolver.resolver("value", Tag.inserting(Component.text(finalArgs[0])))
);
}
} else {
this.visit(
player,
Settings.Teleport.VISIT_MERGED_OWNERS
? PlotQuery.newQuery().ownersInclude(uuid).whereBasePlot()
: PlotQuery.newQuery().ownedBy(uuid).whereBasePlot(),
null,
confirm,
whenDone,
finalPage
);
return;
}
final PlotQuery query = Settings.Teleport.VISIT_MERGED_OWNERS
? PlotQuery.newQuery().ownersInclude(uuid)
: PlotQuery.newQuery().ownedBy(uuid);
if (!query.anyMatch()) {
// It was a valid UUID but the player has no plots
player.sendMessage(TranslatableCaption.of("errors.player_no_plots"));
return;
}
this.visit(player, query.whereBasePlot(), null, confirm, whenDone, finalPage, true);
});
} else {
// Try to parse a plot
final Plot plot = Plot.getPlotFromString(player, finalArgs[0], true);
if (plot != null) {
this.visit(player, PlotQuery.newQuery().withPlot(plot), null, confirm, whenDone, 1);
this.visit(player, PlotQuery.newQuery().withPlot(plot), null, confirm, whenDone, 1, false);
}
}
break;

View File

@ -0,0 +1,50 @@
/*
* PlotSquared, a land and world management plugin for Minecraft.
* Copyright (C) IntellectualSites <https://intellectualsites.com>
* Copyright (C) IntellectualSites team and contributors
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package com.plotsquared.core.util.comparator;
import com.plotsquared.core.plot.Plot;
import java.util.Comparator;
/**
* Sort plots by {@link Plot#temp} (being the auto increment id in database) in natural order for {@code temp > 0}.
* For {@code temp < 1} sort by {@link Plot#hashCode()}
*/
public class PlotByCreationDateComparator implements Comparator<Plot> {
public static final Comparator<Plot> INSTANCE = new PlotByCreationDateComparator();
private PlotByCreationDateComparator() {
}
@Override
@SuppressWarnings("deprecation") // Plot#temp
public int compare(final Plot first, final Plot second) {
if (first.temp > 0 && second.temp > 0) {
return Integer.compare(first.temp, second.temp);
}
// second is implicitly `< 1` (due to previous condition)
if (first.temp > 0) {
return 1;
}
// sort dangling plots (temp < 1) by their hashcode
return Integer.compare(first.hashCode(), second.hashCode());
}
}

View File

@ -0,0 +1,52 @@
/*
* PlotSquared, a land and world management plugin for Minecraft.
* Copyright (C) IntellectualSites <https://intellectualsites.com>
* Copyright (C) IntellectualSites team and contributors
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package com.plotsquared.core.util.comparator;
import com.plotsquared.core.plot.Plot;
import com.plotsquared.core.plot.flag.implementations.DoneFlag;
import com.plotsquared.core.util.MathMan;
import java.util.Comparator;
/**
* Sort plots by their {@link DoneFlag} in reverse numeric natural order. (more recent "finished plots" first)
* <br>
* Non-finished plots last, unsorted.
*/
public class PlotByDoneComparator implements Comparator<Plot> {
public static final PlotByDoneComparator INSTANCE = new PlotByDoneComparator();
private PlotByDoneComparator() {
}
@Override
public int compare(final Plot first, final Plot second) {
String firstDone = first.getFlag(DoneFlag.class);
String lastDone = second.getFlag(DoneFlag.class);
if (MathMan.isInteger(firstDone)) {
if (MathMan.isInteger(lastDone)) {
return Integer.parseInt(lastDone) - Integer.parseInt(firstDone);
}
return -1; // only "first" is finished, so sort "second" after "first"
}
return 0; // neither is finished
}
}

View File

@ -0,0 +1,61 @@
/*
* PlotSquared, a land and world management plugin for Minecraft.
* Copyright (C) IntellectualSites <https://intellectualsites.com>
* Copyright (C) IntellectualSites team and contributors
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package com.plotsquared.core.util.comparator;
import com.plotsquared.core.plot.Plot;
import com.plotsquared.core.plot.Rating;
import java.util.Comparator;
import java.util.Map;
import java.util.UUID;
public class PlotByRatingComparator implements Comparator<Plot> {
public static final PlotByRatingComparator INSTANCE = new PlotByRatingComparator();
PlotByRatingComparator() {
}
@Override
public int compare(final Plot p1, final Plot p2) {
double v1 = 0;
int p1s = p1.getSettings().getRatings().size();
int p2s = p2.getRatings().size();
if (!p1.getSettings().getRatings().isEmpty()) {
v1 = p1.getRatings().values().stream().mapToDouble(Rating::getAverageRating)
.map(av -> av * av).sum();
v1 /= p1s;
v1 += p1s;
}
double v2 = 0;
if (!p2.getSettings().getRatings().isEmpty()) {
for (Map.Entry<UUID, Rating> entry : p2.getRatings().entrySet()) {
double av = entry.getValue().getAverageRating();
v2 += av * av;
}
v2 /= p2s;
v2 += p2s;
}
if (v2 == v1 && v2 != 0) {
return p2s - p1s;
}
return (int) Math.signum(v2 - v1);
}
}

View File

@ -0,0 +1,49 @@
/*
* PlotSquared, a land and world management plugin for Minecraft.
* Copyright (C) IntellectualSites <https://intellectualsites.com>
* Copyright (C) IntellectualSites team and contributors
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
package com.plotsquared.core.util.comparator;
import com.plotsquared.core.plot.Plot;
import com.plotsquared.core.plot.PlotArea;
import javax.annotation.Nullable;
import java.util.Comparator;
public class PlotInPrioritizedAreaComparator implements Comparator<Plot> {
private final PlotArea priorityArea;
public PlotInPrioritizedAreaComparator(@Nullable final PlotArea area) {
this.priorityArea = area;
}
@Override
public int compare(final Plot first, final Plot second) {
if (this.priorityArea == null) {
return 0; // no defined priority? don't sort
}
if (this.priorityArea.equals(first.getArea())) {
return -1;
}
if (this.priorityArea.equals(second.getArea())) {
return 1;
}
return 0; // same area, don't sort
}
}

View File

@ -24,6 +24,7 @@ import com.plotsquared.core.plot.PlotArea;
import java.util.Collection;
import java.util.LinkedList;
import java.util.List;
import java.util.stream.Stream;
class AreaLimitedPlotProvider implements PlotProvider {
@ -42,4 +43,9 @@ class AreaLimitedPlotProvider implements PlotProvider {
return plots;
}
@Override
public Stream<Plot> streamPlots() {
return streamPlotsInPlotAreas(this.areas.toArray(PlotArea[]::new));
}
}

View File

@ -22,6 +22,7 @@ import com.plotsquared.core.PlotSquared;
import com.plotsquared.core.plot.Plot;
import java.util.Collection;
import java.util.stream.Stream;
class ExpiredPlotProvider implements PlotProvider {
@ -30,4 +31,9 @@ class ExpiredPlotProvider implements PlotProvider {
return PlotSquared.platform().expireManager().getPendingExpired();
}
@Override
public Stream<Plot> streamPlots() {
return getPlots().stream();
}
}

View File

@ -23,6 +23,7 @@ import org.checkerframework.checker.nullness.qual.NonNull;
import java.util.Collection;
import java.util.Collections;
import java.util.stream.Stream;
class FixedPlotProvider implements PlotProvider {
@ -37,4 +38,9 @@ class FixedPlotProvider implements PlotProvider {
return Collections.singleton(plot);
}
@Override
public Stream<Plot> streamPlots() {
return Stream.of(plot);
}
}

View File

@ -26,6 +26,7 @@ import org.checkerframework.checker.nullness.qual.NonNull;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.stream.Stream;
class GlobalPlotProvider implements PlotProvider {
@ -44,4 +45,9 @@ class GlobalPlotProvider implements PlotProvider {
return plots;
}
@Override
public Stream<Plot> streamPlots() {
return streamPlotsInPlotAreas(this.plotAreaManager.getAllPlotAreas());
}
}

View File

@ -22,6 +22,7 @@ import com.plotsquared.core.plot.Plot;
import java.util.Collection;
import java.util.Collections;
import java.util.stream.Stream;
class NullProvider implements PlotProvider {
@ -30,4 +31,9 @@ class NullProvider implements PlotProvider {
return Collections.emptyList();
}
@Override
public Stream<Plot> streamPlots() {
return Stream.empty();
}
}

View File

@ -23,17 +23,11 @@ import org.checkerframework.checker.nullness.qual.NonNull;
import java.util.UUID;
class OwnersIncludeFilter implements PlotFilter {
private final UUID owner;
OwnersIncludeFilter(final @NonNull UUID owner) {
this.owner = owner;
}
record OwnersIncludeFilter(UUID owner) implements PlotFilter {
@Override
public boolean accepts(final @NonNull Plot plot) {
return plot.isBasePlot() && plot.getOwners().size() > 0 && plot.getOwners().contains(owner);
return plot.isBasePlot() && plot.isOwner(owner);
}
}

View File

@ -19,12 +19,44 @@
package com.plotsquared.core.util.query;
import com.plotsquared.core.plot.Plot;
import com.plotsquared.core.plot.PlotArea;
import java.util.Collection;
import java.util.Iterator;
import java.util.Spliterator;
import java.util.Spliterators;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;
@FunctionalInterface
interface PlotProvider {
Collection<Plot> getPlots();
Stream<Plot> streamPlots();
default Stream<Plot> streamPlotsInPlotAreas(PlotArea[] areas) {
if (areas == null || areas.length == 0) {
return Stream.of();
}
return StreamSupport.stream(Spliterators.spliteratorUnknownSize(new Iterator<>() {
private int areaIndex = -1;
private Iterator<Plot> currentAreaPlots;
@Override
public boolean hasNext() {
if (currentAreaPlots == null || !currentAreaPlots.hasNext()) {
if (areaIndex >= areas.length - 1) {
return false;
}
currentAreaPlots = areas[++areaIndex].getPlots().iterator();
}
return true;
}
@Override
public Plot next() {
return currentAreaPlots.next();
}
}, Spliterator.IMMUTABLE), false);
}
}

View File

@ -23,10 +23,11 @@ import com.plotsquared.core.PlotSquared;
import com.plotsquared.core.player.PlotPlayer;
import com.plotsquared.core.plot.Plot;
import com.plotsquared.core.plot.PlotArea;
import com.plotsquared.core.plot.Rating;
import com.plotsquared.core.plot.flag.implementations.DoneFlag;
import com.plotsquared.core.plot.world.PlotAreaManager;
import com.plotsquared.core.util.MathMan;
import com.plotsquared.core.util.comparator.PlotByDoneComparator;
import com.plotsquared.core.util.comparator.PlotByRatingComparator;
import com.plotsquared.core.util.comparator.PlotByCreationDateComparator;
import com.plotsquared.core.util.comparator.PlotInPrioritizedAreaComparator;
import org.checkerframework.checker.nullness.qual.NonNull;
import java.util.ArrayList;
@ -37,7 +38,6 @@ import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import java.util.function.Predicate;
@ -229,6 +229,7 @@ public final class PlotQuery implements Iterable<Plot> {
public @NonNull PlotQuery hasOwner() {
return this.addFilter(new HasOwnerFilter());
}
/**
* Query for plots with a specific alias
*
@ -307,7 +308,15 @@ public final class PlotQuery implements Iterable<Plot> {
* @return Matching plots
*/
public @NonNull Stream<Plot> asStream() {
return this.asList().stream();
Stream<Plot> stream = this.plotProvider.streamPlots().filter(testPlotAgainstFilters());
if (this.sortingStrategy == SortingStrategy.NO_SORTING) {
return stream;
}
stream = stream.sorted(getConfiguredComparator());
if (this.priorityArea != null) {
stream = stream.sorted(new PlotInPrioritizedAreaComparator(this.priorityArea));
}
return stream;
}
/**
@ -334,49 +343,10 @@ public final class PlotQuery implements Iterable<Plot> {
}
if (this.sortingStrategy == SortingStrategy.NO_SORTING) {
return result;
} else if (this.sortingStrategy == SortingStrategy.SORT_BY_TEMP) {
return PlotSquared.get().sortPlotsByTemp(result);
} else if (this.sortingStrategy == SortingStrategy.SORT_BY_DONE) {
result.sort((a, b) -> {
String va = a.getFlag(DoneFlag.class);
String vb = b.getFlag(DoneFlag.class);
if (MathMan.isInteger(va)) {
if (MathMan.isInteger(vb)) {
return Integer.parseInt(vb) - Integer.parseInt(va);
}
return -1;
}
return 1;
});
} else if (this.sortingStrategy == SortingStrategy.SORT_BY_RATING) {
result.sort((p1, p2) -> {
double v1 = 0;
int p1s = p1.getSettings().getRatings().size();
int p2s = p2.getRatings().size();
if (!p1.getSettings().getRatings().isEmpty()) {
v1 = p1.getRatings().values().stream().mapToDouble(Rating::getAverageRating)
.map(av -> av * av).sum();
v1 /= p1s;
v1 += p1s;
}
double v2 = 0;
if (!p2.getSettings().getRatings().isEmpty()) {
for (Map.Entry<UUID, Rating> entry : p2.getRatings().entrySet()) {
double av = entry.getValue().getAverageRating();
v2 += av * av;
}
v2 /= p2s;
v2 += p2s;
}
if (v2 == v1 && v2 != 0) {
return p2s - p1s;
}
return (int) Math.signum(v2 - v1);
});
} else if (this.sortingStrategy == SortingStrategy.SORT_BY_CREATION) {
return PlotSquared.get().sortPlots(result, PlotSquared.SortType.CREATION_DATE, this.priorityArea);
} else if (this.sortingStrategy == SortingStrategy.COMPARATOR) {
result.sort(this.plotComparator);
}
result.sort(getConfiguredComparator());
if (this.priorityArea != null) {
result.sort(new PlotInPrioritizedAreaComparator(this.priorityArea));
}
return result;
}
@ -427,28 +397,22 @@ public final class PlotQuery implements Iterable<Plot> {
* @return {@code true} if any provided plot matches the filters.
*/
public boolean anyMatch() {
if (this.filters.isEmpty()) {
return !this.plotProvider.getPlots().isEmpty();
} else {
final Collection<Plot> plots = this.plotProvider.getPlots();
outer:
for (final Plot plot : plots) {
// a plot must pass all filters to match the criteria
for (final PlotFilter filter : this.filters) {
if (!filter.accepts(plot)) {
continue outer;
}
}
return true; // a plot passed all filters, so we have a match
}
return false;
}
return hasMinimumMatches(1);
}
@NonNull
private PlotQuery addFilter(final @NonNull PlotFilter filter) {
this.filters.add(filter);
return this;
/**
* Get whether this query matches at least {@code minimum} plots.
* <br />
* Should be prioritized over {@link #count()}, if possible.
* This method only queries as many plots and areas as required without applying sorting. (short-circuiting on the stream)
*
* @param minimum the minimum amount of matches plots expected (inclusive)
* @return {@code true} if this query's result contains at least {@code minimum} plots (after optional filters).
*
* @since TODO
*/
public boolean hasMinimumMatches(int minimum) {
return this.plotProvider.streamPlots().filter(testPlotAgainstFilters()).limit(minimum).count() == minimum;
}
@NonNull
@ -457,4 +421,34 @@ public final class PlotQuery implements Iterable<Plot> {
return this.asCollection().iterator();
}
@NonNull
private PlotQuery addFilter(final @NonNull PlotFilter filter) {
this.filters.add(filter);
return this;
}
private Comparator<Plot> getConfiguredComparator() {
return switch (sortingStrategy) {
case NO_SORTING -> (p1, p2) -> 0;
case SORT_BY_TEMP, SORT_BY_CREATION -> PlotByCreationDateComparator.INSTANCE;
case SORT_BY_DONE -> PlotByDoneComparator.INSTANCE;
case SORT_BY_RATING -> PlotByRatingComparator.INSTANCE;
case COMPARATOR -> plotComparator;
};
}
private Predicate<Plot> testPlotAgainstFilters() {
if (this.filters.isEmpty()) {
return plot -> true;
}
return plot -> {
for (final PlotFilter filter : filters) {
if (!filter.accepts(plot)) {
return false;
}
}
return true;
};
}
}

View File

@ -31,6 +31,7 @@ import java.util.List;
import java.util.UUID;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;
class SearchPlotProvider implements PlotProvider {
@ -115,4 +116,9 @@ class SearchPlotProvider implements PlotProvider {
return getPlotsBySearch(this.searchTerm);
}
@Override
public Stream<Plot> streamPlots() {
return getPlots().stream(); // TODO: look into potentially optimizations here?
}
}

View File

@ -22,7 +22,7 @@ plugins {
}
group = "com.intellectualsites.plotsquared"
version = "7.5.2-SNAPSHOT"
version = "7.5.1-SNAPSHOT"
if (!File("$rootDir/.git").exists()) {
logger.lifecycle("""