Upstream/Minestom
1
0
Fork 0
mirror of https://github.com/Minestom/Minestom.git synced 2024-09-27 14:13:24 +02:00
Code Issues Projects Releases Wiki Activity

Cleanup

Browse Source
This commit is contained in:
Felix Cravic 2020-08-03 10:35:46 +02:00
parent f925e31b29
commit c74ce2752c
15 changed files with 126 additions and 59 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
src/main/java/net/minestom/server/UpdateManager.java
View File

@ -9,7 +9,7 @@ import net.minestom.server.instance.Instance;
import net.minestom.server.instance.InstanceManager;
import net.minestom.server.network.ConnectionManager;
import net.minestom.server.network.packet.server.play.KeepAlivePacket;
import net.minestom.server.thread.PerInstanceThreadProvider;
import net.minestom.server.thread.SingleThreadProvider;
import net.minestom.server.thread.ThreadProvider;
import net.minestom.server.utils.thread.MinestomThread;
import net.minestom.server.utils.validate.Check;
@ -27,7 +27,8 @@ public final class UpdateManager {
private ThreadProvider threadProvider;
{
threadProvider = new PerInstanceThreadProvider();
threadProvider = new SingleThreadProvider();
//threadProvider = new PerInstanceThreadProvider();
//threadProvider = new PerGroupChunkProvider();
}

15
src/main/java/net/minestom/server/benchmark/BenchmarkManager.java
View File

@ -1,5 +1,7 @@
package net.minestom.server.benchmark;
import it.unimi.dsi.fastutil.longs.Long2LongMap;
import it.unimi.dsi.fastutil.longs.Long2LongOpenHashMap;
import net.minestom.server.MinecraftServer;
import net.minestom.server.utils.time.UpdateOption;
import net.minestom.server.utils.validate.Check;
@ -7,7 +9,10 @@ import net.minestom.server.utils.validate.Check;
import java.lang.management.ManagementFactory;
import java.lang.management.ThreadInfo;
import java.lang.management.ThreadMXBean;
import java.util.*;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import static net.minestom.server.MinecraftServer.*;
@ -28,10 +33,10 @@ public class BenchmarkManager {
threads.add(THREAD_NAME_TICK);
}
private Map<Long, Long> lastCpuTimeMap = new HashMap<>();
private Map<Long, Long> lastUserTimeMap = new HashMap<>();
private Map<Long, Long> lastWaitedMap = new HashMap<>();
private Map<Long, Long> lastBlockedMap = new HashMap<>();
private final Long2LongMap lastCpuTimeMap = new Long2LongOpenHashMap();
private final Long2LongMap lastUserTimeMap = new Long2LongOpenHashMap();
private final Long2LongMap lastWaitedMap = new Long2LongOpenHashMap();
private final Long2LongMap lastBlockedMap = new Long2LongOpenHashMap();
private Map<String, ThreadResult> resultMap = new ConcurrentHashMap<>();

6
src/main/java/net/minestom/server/chat/ChatColor.java
View File

@ -41,9 +41,9 @@ public class ChatColor {
public static final ChatColor YELLOW = fromRGB(255, 255, 85, 14, "yellow");
public static final ChatColor WHITE = fromRGB(255, 255, 255, 15, "white");
private static Int2ObjectMap<ChatColor> idColorMap = new Int2ObjectOpenHashMap<>();
private static Map<String, ChatColor> colorCode = new HashMap<>();
private static Char2ObjectMap<ChatColor> legacyColorCodesMap = new Char2ObjectOpenHashMap<>();
private static final Int2ObjectMap<ChatColor> idColorMap = new Int2ObjectOpenHashMap<>();
private static final Map<String, ChatColor> colorCode = new HashMap<>();
private static final Char2ObjectMap<ChatColor> legacyColorCodesMap = new Char2ObjectOpenHashMap<>();
static {

14
src/main/java/net/minestom/server/command/CommandManager.java
View File

@ -1,5 +1,7 @@
package net.minestom.server.command;
import it.unimi.dsi.fastutil.ints.IntArrayList;
import it.unimi.dsi.fastutil.ints.IntList;
import net.minestom.server.command.builder.Command;
import net.minestom.server.command.builder.CommandDispatcher;
import net.minestom.server.command.builder.CommandSyntax;
@ -174,7 +176,7 @@ public class CommandManager {
List<DeclareCommandsPacket.Node> nodes = new ArrayList<>();
// Contains the children of the main node (all commands name)
ArrayList<Integer> rootChildren = new ArrayList<>();
IntList rootChildren = new IntArrayList();
for (Command command : dispatcher.getCommands()) {
// Check if player should see this command
@ -187,8 +189,8 @@ public class CommandManager {
}
// The main root of this command
ArrayList<Integer> cmdChildren = new ArrayList<>();
Collection<CommandSyntax> syntaxes = command.getSyntaxes();
IntList cmdChildren = new IntArrayList();
final Collection<CommandSyntax> syntaxes = command.getSyntaxes();
List<String> names = new ArrayList<>();
names.add(command.getName());
@ -249,7 +251,7 @@ public class CommandManager {
* @param syntaxes the syntaxes of the command
* @param rootChildren the children of the main node (all commands name)
*/
private void createCommand(List<DeclareCommandsPacket.Node> nodes, ArrayList<Integer> cmdChildren, String name, Collection<CommandSyntax> syntaxes, ArrayList<Integer> rootChildren) {
private void createCommand(List<DeclareCommandsPacket.Node> nodes, IntList cmdChildren, String name, Collection<CommandSyntax> syntaxes, IntList rootChildren) {
DeclareCommandsPacket.Node literalNode = createMainNode(name, syntaxes.isEmpty());
@ -261,7 +263,7 @@ public class CommandManager {
List<DeclareCommandsPacket.Node> lastNodes = null;
// Represent the children of the last node
ArrayList<Integer> argChildren = null;
IntList argChildren = null;
final Argument[] arguments = syntax.getArguments();
for (int i = 0; i < arguments.length; i++) {
@ -300,7 +302,7 @@ public class CommandManager {
argumentNodes.forEach(node -> node.children = children);
} else {
// Create children list which will be filled during next iteration
argChildren = new ArrayList<>();
argChildren = new IntArrayList();
lastNodes = argumentNodes;
}
}

5
src/main/java/net/minestom/server/command/builder/CommandDispatcher.java
View File

@ -89,11 +89,14 @@ public class CommandDispatcher {
boolean useRemaining = false;
for (int argCount = 0; argCount < syntax.getArguments().length; argCount++) {
Argument argument = syntax.getArguments()[argCount];
final Argument argument = syntax.getArguments()[argCount];
useRemaining = argument.useRemaining();
// the correction result of the argument
int correctionResult = Argument.SUCCESS;
// true if the arg is valid, false otherwise
boolean correct = false;
// the raw string representing the correct argument syntax
String argValue = "";
if (useRemaining) {

4
src/main/java/net/minestom/server/instance/Instance.java
View File

@ -1,6 +1,8 @@
package net.minestom.server.instance;
import io.netty.buffer.ByteBuf;
import it.unimi.dsi.fastutil.longs.Long2ObjectMap;
import it.unimi.dsi.fastutil.longs.Long2ObjectOpenHashMap;
import net.minestom.server.MinecraftServer;
import net.minestom.server.data.Data;
import net.minestom.server.data.DataContainer;
@ -68,7 +70,7 @@ public abstract class Instance implements BlockModifier, EventHandler, DataConta
protected Set<ObjectEntity> objectEntities = new CopyOnWriteArraySet<>();
protected Set<ExperienceOrb> experienceOrbs = new CopyOnWriteArraySet<>();
// Entities per chunk
protected Map<Long, Set<Entity>> chunkEntities = new ConcurrentHashMap<>();
protected Long2ObjectMap<Set<Entity>> chunkEntities = new Long2ObjectOpenHashMap<>();
protected UUID uniqueId;
protected List<Consumer<Instance>> nextTick = Collections.synchronizedList(new ArrayList<>());

4
src/main/java/net/minestom/server/instance/InstanceContainer.java
View File

@ -397,7 +397,7 @@ public class InstanceContainer extends Instance {
e.printStackTrace();
}
} else {
Iterator<Chunk> chunks = getChunks().iterator();
final Iterator<Chunk> chunks = getChunks().iterator();
while (chunks.hasNext()) {
final Chunk chunk = chunks.next();
final boolean isLast = !chunks.hasNext();
@ -453,7 +453,7 @@ public class InstanceContainer extends Instance {
}
public void sendChunkUpdate(Chunk chunk) {
Set<Player> chunkViewers = chunk.getViewers();
final Set<Player> chunkViewers = chunk.getViewers();
if (!chunkViewers.isEmpty()) {
sendChunkUpdate(chunkViewers, chunk);
}

15
src/main/java/net/minestom/server/inventory/click/InventoryClickLoopHandler.java
View File

@ -1,22 +1,23 @@
package net.minestom.server.inventory.click;
import it.unimi.dsi.fastutil.ints.Int2IntFunction;
import it.unimi.dsi.fastutil.ints.Int2ObjectFunction;
import net.minestom.server.item.ItemStack;
import java.util.function.BiConsumer;
import java.util.function.Function;
public class InventoryClickLoopHandler {
private int start;
private int end;
private int step;
private Function<Integer, Integer> indexModifier;
private Function<Integer, ItemStack> itemGetter;
private Int2IntFunction indexModifier;
private Int2ObjectFunction<ItemStack> itemGetter;
private BiConsumer<Integer, ItemStack> itemSetter;
public InventoryClickLoopHandler(int start, int end, int step,
Function<Integer, Integer> indexModifier,
Function<Integer, ItemStack> itemGetter,
Int2IntFunction indexModifier,
Int2ObjectFunction<ItemStack> itemGetter,
BiConsumer<Integer, ItemStack> itemSetter) {
this.start = start;
this.end = end;
@ -38,11 +39,11 @@ public class InventoryClickLoopHandler {
return step;
}
public Function<Integer, Integer> getIndexModifier() {
public Int2IntFunction getIndexModifier() {
return indexModifier;
}
public Function<Integer, ItemStack> getItemGetter() {
public Int2ObjectFunction<ItemStack> getItemGetter() {
return itemGetter;
}

34
src/main/java/net/minestom/server/inventory/click/InventoryClickProcessor.java
View File

@ -1,5 +1,9 @@
package net.minestom.server.inventory.click;
import it.unimi.dsi.fastutil.ints.Int2IntFunction;
import it.unimi.dsi.fastutil.ints.Int2ObjectFunction;
import it.unimi.dsi.fastutil.ints.IntOpenHashSet;
import it.unimi.dsi.fastutil.ints.IntSet;
import net.minestom.server.entity.Player;
import net.minestom.server.event.inventory.InventoryClickEvent;
import net.minestom.server.event.inventory.InventoryPreClickEvent;
@ -10,15 +14,17 @@ import net.minestom.server.item.ItemStack;
import net.minestom.server.item.StackingRule;
import net.minestom.server.utils.inventory.PlayerInventoryUtils;
import java.util.*;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.function.BiConsumer;
import java.util.function.Function;
public class InventoryClickProcessor {
// Dragging maps
private Map<Player, Set<Integer>> leftDraggingMap = new HashMap<>();
private Map<Player, Set<Integer>> rightDraggingMap = new HashMap<>();
private Map<Player, IntSet> leftDraggingMap = new HashMap<>();
private Map<Player, IntSet> rightDraggingMap = new HashMap<>();
public InventoryClickResult leftClick(Inventory inventory, Player player, int slot, ItemStack clicked, ItemStack cursor) {
final InventoryClickResult clickResult = startCondition(inventory, player, slot, ClickType.LEFT_CLICK, clicked, cursor);
@ -182,9 +188,9 @@ public class InventoryClickProcessor {
ItemStack resultClicked = clicked.clone();
for (InventoryClickLoopHandler loopHandler : loopHandlers) {
Function<Integer, Integer> indexModifier = loopHandler.getIndexModifier();
Function<Integer, ItemStack> itemGetter = loopHandler.getItemGetter();
BiConsumer<Integer, ItemStack> itemSetter = loopHandler.getItemSetter();
final Int2IntFunction indexModifier = loopHandler.getIndexModifier();
final Int2ObjectFunction<ItemStack> itemGetter = loopHandler.getItemGetter();
final BiConsumer<Integer, ItemStack> itemSetter = loopHandler.getItemSetter();
for (int i = loopHandler.getStart(); i < loopHandler.getEnd(); i += loopHandler.getStep()) {
final int index = indexModifier.apply(i);
@ -248,7 +254,7 @@ public class InventoryClickProcessor {
public InventoryClickResult dragging(Inventory inventory, Player player,
int slot, int button,
ItemStack clicked, ItemStack cursor,
Function<Integer, ItemStack> itemGetter,
Int2ObjectFunction<ItemStack> itemGetter,
BiConsumer<Integer, ItemStack> itemSetter) {
InventoryClickResult clickResult = new InventoryClickResult(clicked, cursor);
@ -258,15 +264,15 @@ public class InventoryClickProcessor {
// Start or end left/right drag
if (button == 0) {
// Start left
this.leftDraggingMap.put(player, new HashSet<>());
this.leftDraggingMap.put(player, new IntOpenHashSet());
} else if (button == 4) {
// Start right
this.rightDraggingMap.put(player, new HashSet<>());
this.rightDraggingMap.put(player, new IntOpenHashSet());
} else if (button == 2) {
// End left
if (!leftDraggingMap.containsKey(player))
return null;
Set<Integer> slots = leftDraggingMap.get(player);
final Set<Integer> slots = leftDraggingMap.get(player);
final int slotCount = slots.size();
final int cursorAmount = stackingRule.getAmount(cursor);
if (slotCount > cursorAmount)
@ -310,7 +316,7 @@ public class InventoryClickProcessor {
// End right
if (!rightDraggingMap.containsKey(player))
return null;
Set<Integer> slots = rightDraggingMap.get(player);
final Set<Integer> slots = rightDraggingMap.get(player);
final int size = slots.size();
int cursorAmount = stackingRule.getAmount(cursor);
if (size > cursorAmount)
@ -381,8 +387,8 @@ public class InventoryClickProcessor {
return null;
for (InventoryClickLoopHandler loopHandler : loopHandlers) {
final Function<Integer, Integer> indexModifier = loopHandler.getIndexModifier();
final Function<Integer, ItemStack> itemGetter = loopHandler.getItemGetter();
final Int2IntFunction indexModifier = loopHandler.getIndexModifier();
final Int2ObjectFunction<ItemStack> itemGetter = loopHandler.getItemGetter();
final BiConsumer<Integer, ItemStack> itemSetter = loopHandler.getItemSetter();
for (int i = loopHandler.getStart(); i < loopHandler.getEnd(); i += loopHandler.getStep()) {

2
src/main/java/net/minestom/server/item/StackingRule.java
View File

@ -7,7 +7,7 @@ package net.minestom.server.item;
*/
public abstract class StackingRule {
private int maxSize;
private final int maxSize;
public StackingRule(int maxSize) {
this.maxSize = maxSize;

10
src/main/java/net/minestom/server/scoreboard/Sidebar.java
View File

@ -1,5 +1,6 @@
package net.minestom.server.scoreboard;
import it.unimi.dsi.fastutil.ints.IntLinkedOpenHashSet;
import net.minestom.server.Viewable;
import net.minestom.server.chat.ChatParser;
import net.minestom.server.chat.ColoredText;
@ -12,7 +13,6 @@ import net.minestom.server.network.player.PlayerConnection;
import net.minestom.server.utils.validate.Check;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Set;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.CopyOnWriteArraySet;
@ -32,7 +32,7 @@ public class Sidebar implements Viewable {
private Set<Player> viewers = new CopyOnWriteArraySet<>();
private ConcurrentLinkedQueue<ScoreboardLine> lines = new ConcurrentLinkedQueue<>();
private LinkedList<Integer> availableColors = new LinkedList<>();
private IntLinkedOpenHashSet availableColors = new IntLinkedOpenHashSet();
private String objectiveName;
@ -202,9 +202,9 @@ public class Sidebar implements Viewable {
return line;
}
private void retrieveName(LinkedList<Integer> colors) {
private void retrieveName(IntLinkedOpenHashSet colors) {
synchronized (colors) {
this.colorName = colors.pollFirst();
this.colorName = colors.removeFirstInt();
}
}
@ -214,7 +214,7 @@ public class Sidebar implements Viewable {
this.sidebarTeam = new SidebarTeam(teamName, content, ColoredText.of(""), entityName);
}
private void returnName(LinkedList<Integer> colors) {
private void returnName(IntLinkedOpenHashSet colors) {
synchronized (colors) {
colors.add(colorName);
}

4
src/main/java/net/minestom/server/stat/PlayerStatistic.java
View File

@ -2,8 +2,8 @@ package net.minestom.server.stat;
public class PlayerStatistic {
private StatisticCategory category;
private int statisticId;
private final StatisticCategory category;
private final int statisticId;
public PlayerStatistic(StatisticCategory category, int statisticId) {
this.category = category;

41
src/main/java/net/minestom/server/thread/SingleThreadProvider.java Normal file
View File

@ -0,0 +1,41 @@
package net.minestom.server.thread;
import net.minestom.server.instance.Chunk;
import net.minestom.server.instance.Instance;
import java.util.HashSet;
import java.util.Set;
public class SingleThreadProvider extends ThreadProvider {
private Set<Instance> instances = new HashSet<>();
private long time;
@Override
public void start() {
this.instances.clear();
this.time = System.currentTimeMillis();
}
@Override
public void linkThread(Instance instance, Chunk chunk) {
if (instances.add(instance)) {
updateInstance(instance, time);
}
updateChunk(instance, chunk, time);
updateEntities(instance, chunk, time);
}
@Override
public void end() {
}
@Override
public void update() {
}
}

5
src/main/java/net/minestom/server/utils/ArrayUtils.java
View File

@ -1,6 +1,7 @@
package net.minestom.server.utils;
import java.util.ArrayList;
import it.unimi.dsi.fastutil.ints.IntList;
import java.util.function.Supplier;
public class ArrayUtils {
@ -54,7 +55,7 @@ public class ArrayUtils {
return result;
}
public static int[] toArray(ArrayList<Integer> list) {
public static int[] toArray(IntList list) {
int[] array = new int[list.size()];
for (int i = 0; i < array.length; i++) {
array[i] = list.get(i);

21
src/main/java/net/minestom/server/utils/WeightedRandom.java
View File

@ -1,5 +1,8 @@
package net.minestom.server.utils;
import it.unimi.dsi.fastutil.doubles.DoubleArrayList;
import it.unimi.dsi.fastutil.doubles.DoubleList;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
@ -7,21 +10,22 @@ import java.util.Random;
/**
* Produces a random element from a given set, with weights applied
*
* @param <E>
*/
public class WeightedRandom<E extends WeightedRandomItem> {
private final List<E> entries;
private final List<Double> weightSums;
private final DoubleList weightSums;
private final double totalWeight;
public WeightedRandom(Collection<E> items) {
if(items.isEmpty())
if (items.isEmpty())
throw new IllegalArgumentException("items must not be empty");
this.entries = new ArrayList<>(items);
this.weightSums = new ArrayList<>(items.size());
this.weightSums = new DoubleArrayList(items.size());
double sum = 0.0;
for(E item : items) {
for (E item : items) {
sum += item.getWeight();
weightSums.add(sum);
}
@ -30,17 +34,18 @@ public class WeightedRandom<E extends WeightedRandomItem> {
/**
* Gets a random element from this set
*
* @param rng Random Number Generator to generate random numbers with
* @return
*/
public E get(Random rng) {
double p = rng.nextDouble()*totalWeight;
final double p = rng.nextDouble() * totalWeight;
for (int i = 0; i < entries.size(); i++) {
double weightSum = weightSums.get(i);
if(weightSum >= p) {
final double weightSum = weightSums.get(i);
if (weightSum >= p) {
return entries.get(i);
}
}
return entries.get(entries.size()-1);
return entries.get(entries.size() - 1);
}
}