427 lines
18 KiB
Java
427 lines
18 KiB
Java
package carpet.helpers;
|
|
|
|
import carpet.CarpetServer;
|
|
import carpet.fakes.IngredientInterface;
|
|
import carpet.fakes.RecipeManagerInterface;
|
|
import carpet.utils.Messenger;
|
|
import it.unimi.dsi.fastutil.objects.Object2LongLinkedOpenHashMap;
|
|
import it.unimi.dsi.fastutil.objects.Object2LongMap;
|
|
import net.minecraft.ChatFormatting;
|
|
import net.minecraft.core.Registry;
|
|
import net.minecraft.core.RegistryAccess;
|
|
import net.minecraft.core.registries.Registries;
|
|
import net.minecraft.network.chat.Component;
|
|
import net.minecraft.network.chat.MutableComponent;
|
|
import net.minecraft.network.chat.Style;
|
|
import net.minecraft.network.chat.TextColor;
|
|
import net.minecraft.resources.ResourceLocation;
|
|
import net.minecraft.server.MinecraftServer;
|
|
import net.minecraft.world.item.BlockItem;
|
|
import net.minecraft.world.item.DyeColor;
|
|
import net.minecraft.world.item.DyeItem;
|
|
import net.minecraft.world.item.Item;
|
|
import net.minecraft.world.item.ItemStack;
|
|
import net.minecraft.world.item.Items;
|
|
import net.minecraft.world.item.crafting.Ingredient;
|
|
import net.minecraft.world.item.crafting.Recipe;
|
|
import net.minecraft.world.item.crafting.RecipeType;
|
|
import net.minecraft.world.level.block.AbstractBannerBlock;
|
|
import net.minecraft.world.level.block.BeaconBeamBlock;
|
|
import net.minecraft.world.level.block.Block;
|
|
import net.minecraft.world.level.block.Blocks;
|
|
import net.minecraft.world.level.material.MapColor;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.Collection;
|
|
import java.util.Collections;
|
|
import java.util.EnumMap;
|
|
import java.util.List;
|
|
import java.util.Locale;
|
|
import java.util.Map;
|
|
import java.util.stream.Collectors;
|
|
|
|
import static java.util.Map.entry;
|
|
|
|
/**
|
|
* The actual object residing in each hopper counter which makes them count the items and saves them. There is one for each
|
|
* colour in MC.
|
|
*/
|
|
|
|
public class HopperCounter
|
|
{
|
|
/**
|
|
* A map of all the {@link HopperCounter} counters.
|
|
*/
|
|
private static final Map<DyeColor, HopperCounter> COUNTERS;
|
|
|
|
/**
|
|
* The default display colour of each item, which makes them look nicer when printing the counter contents to the chat
|
|
*/
|
|
|
|
public static final TextColor WHITE = TextColor.fromLegacyFormat(ChatFormatting.WHITE);
|
|
|
|
static
|
|
{
|
|
EnumMap<DyeColor, HopperCounter> counterMap = new EnumMap<>(DyeColor.class);
|
|
for (DyeColor color : DyeColor.values())
|
|
{
|
|
counterMap.put(color, new HopperCounter(color));
|
|
}
|
|
COUNTERS = Collections.unmodifiableMap(counterMap);
|
|
}
|
|
|
|
/**
|
|
* The counter's colour, determined by the colour of wool it's pointing into
|
|
*/
|
|
public final DyeColor color;
|
|
/**
|
|
* The string which is passed into {@link Messenger#m} which makes each counter name be displayed in the colour of
|
|
* that counter.
|
|
*/
|
|
private final String coloredName;
|
|
/**
|
|
* All the items stored within the counter, as a map of {@link Item} mapped to a {@code long} of the amount of items
|
|
* stored thus far of that item type.
|
|
*/
|
|
private final Object2LongMap<Item> counter = new Object2LongLinkedOpenHashMap<>();
|
|
/**
|
|
* The starting tick of the counter, used to calculate in-game time. Only initialised when the first item enters the
|
|
* counter
|
|
*/
|
|
private long startTick;
|
|
/**
|
|
* The starting millisecond of the counter, used to calculate IRl time. Only initialised when the first item enters
|
|
* the counter
|
|
*/
|
|
private long startMillis;
|
|
// private PubSubInfoProvider<Long> pubSubProvider;
|
|
|
|
private HopperCounter(DyeColor color)
|
|
{
|
|
startTick = -1;
|
|
this.color = color;
|
|
String hexColor = Integer.toHexString(color.getTextColor());
|
|
if (hexColor.length() < 6)
|
|
hexColor = "0".repeat(6 - hexColor.length()) + hexColor;
|
|
this.coloredName = '#' + hexColor + ' ' + color.getName();
|
|
}
|
|
|
|
/**
|
|
* Method used to add items to the counter. Note that this is when the {@link HopperCounter#startTick} and
|
|
* {@link HopperCounter#startMillis} variables are initialised, so you can place the counters and then start the farm
|
|
* after all the collection is sorted out.
|
|
*/
|
|
public void add(MinecraftServer server, ItemStack stack)
|
|
{
|
|
if (startTick < 0)
|
|
{
|
|
startTick = server.overworld().getGameTime();
|
|
startMillis = System.currentTimeMillis();
|
|
}
|
|
Item item = stack.getItem();
|
|
counter.put(item, counter.getLong(item) + stack.getCount());
|
|
// pubSubProvider.publish();
|
|
}
|
|
|
|
/**
|
|
* Resets the counter, clearing its items but keeping the clock running.
|
|
*/
|
|
public void reset(MinecraftServer server)
|
|
{
|
|
counter.clear();
|
|
startTick = server.overworld().getGameTime();
|
|
startMillis = System.currentTimeMillis();
|
|
// pubSubProvider.publish();
|
|
}
|
|
|
|
/**
|
|
* Resets all counters, clearing their items.
|
|
* @param fresh Whether or not to start the clocks going immediately or later.
|
|
*/
|
|
public static void resetAll(MinecraftServer server, boolean fresh)
|
|
{
|
|
for (HopperCounter counter : COUNTERS.values())
|
|
{
|
|
counter.reset(server);
|
|
if (fresh) counter.startTick = -1;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Prints all the counters to chat, nicely formatted, and you can choose whether to diplay in in game time or IRL time
|
|
*/
|
|
public static List<Component> formatAll(MinecraftServer server, boolean realtime)
|
|
{
|
|
List<Component> text = new ArrayList<>();
|
|
|
|
for (HopperCounter counter : COUNTERS.values())
|
|
{
|
|
List<Component> temp = counter.format(server, realtime, false);
|
|
if (temp.size() > 1)
|
|
{
|
|
if (!text.isEmpty()) text.add(Messenger.s(""));
|
|
text.addAll(temp);
|
|
}
|
|
}
|
|
if (text.isEmpty())
|
|
{
|
|
text.add(Messenger.s("No items have been counted yet."));
|
|
}
|
|
return text;
|
|
}
|
|
|
|
/**
|
|
* Prints a single counter's contents and timings to chat, with the option to keep it short (so no item breakdown,
|
|
* only rates). Again, realtime displays IRL time as opposed to in game time.
|
|
*/
|
|
public List<Component> format(MinecraftServer server, boolean realTime, boolean brief)
|
|
{
|
|
long ticks = Math.max(realTime ? (System.currentTimeMillis() - startMillis) / 50 : server.overworld().getGameTime() - startTick, 1);
|
|
if (startTick < 0 || ticks == 0)
|
|
{
|
|
if (brief)
|
|
{
|
|
return Collections.singletonList(Messenger.c("b"+coloredName,"w : ","gi -, -/h, - min "));
|
|
}
|
|
return Collections.singletonList(Messenger.c(coloredName, "w hasn't started counting yet"));
|
|
}
|
|
long total = getTotalItems();
|
|
if (total == 0)
|
|
{
|
|
if (brief)
|
|
{
|
|
return Collections.singletonList(Messenger.c("b"+coloredName,"w : ","wb 0","w , ","wb 0","w /h, ", String.format("wb %.1f ", ticks / (20.0 * 60.0)), "w min"));
|
|
}
|
|
return Collections.singletonList(Messenger.c("w No items for ", coloredName, String.format("w yet (%.2f min.%s)",
|
|
ticks / (20.0 * 60.0), (realTime ? " - real time" : "")),
|
|
"nb [X]", "^g reset", "!/counter " + color.getName() +" reset"));
|
|
}
|
|
if (brief)
|
|
{
|
|
return Collections.singletonList(Messenger.c("b"+coloredName,"w : ",
|
|
"wb "+total,"w , ",
|
|
"wb "+(total * (20 * 60 * 60) / ticks),"w /h, ",
|
|
String.format("wb %.1f ", ticks / (20.0 * 60.0)), "w min"
|
|
));
|
|
}
|
|
List<Component> items = new ArrayList<>();
|
|
items.add(Messenger.c("w Items for ", coloredName,
|
|
"w (",String.format("wb %.2f", ticks*1.0/(20*60)), "w min"+(realTime?" - real time":"")+"), ",
|
|
"w total: ", "wb "+total, "w , (",String.format("wb %.1f",total*1.0*(20*60*60)/ticks),"w /h):",
|
|
"nb [X]", "^g reset", "!/counter "+color+" reset"
|
|
));
|
|
items.addAll(counter.object2LongEntrySet().stream().sorted((e, f) -> Long.compare(f.getLongValue(), e.getLongValue())).map(e ->
|
|
{
|
|
Item item = e.getKey();
|
|
MutableComponent itemName = Component.translatable(item.getDescriptionId());
|
|
Style itemStyle = itemName.getStyle();
|
|
TextColor color = guessColor(item, server.registryAccess());
|
|
itemName.setStyle((color != null) ? itemStyle.withColor(color) : itemStyle.withItalic(true));
|
|
long count = e.getLongValue();
|
|
return Messenger.c("g - ", itemName,
|
|
"g : ","wb "+count,"g , ",
|
|
String.format("wb %.1f", count * (20.0 * 60.0 * 60.0) / ticks), "w /h"
|
|
);
|
|
}).collect(Collectors.toList()));
|
|
return items;
|
|
}
|
|
|
|
/**
|
|
* Converts a colour to have a low brightness and uniform colour, so when it prints the items in different colours
|
|
* it's not too flashy and bright, but enough that it's not dull to look at.
|
|
*/
|
|
public static int appropriateColor(int color)
|
|
{
|
|
if (color == 0) return MapColor.SNOW.col;
|
|
int r = (color >> 16 & 255);
|
|
int g = (color >> 8 & 255);
|
|
int b = (color & 255);
|
|
if (r < 70) r = 70;
|
|
if (g < 70) g = 70;
|
|
if (b < 70) b = 70;
|
|
return (r << 16) + (g << 8) + b;
|
|
}
|
|
|
|
/**
|
|
* Maps items that don't get a good block to reference for colour, or those that colour is wrong to a number of blocks, so we can get their colours easily with the
|
|
* {@link Block#defaultMapColor()} method as these items have those same colours.
|
|
*/
|
|
private static final Map<Item, Block> DEFAULTS = Map.ofEntries(
|
|
entry(Items.DANDELION, Blocks.YELLOW_WOOL),
|
|
entry(Items.POPPY, Blocks.RED_WOOL),
|
|
entry(Items.BLUE_ORCHID, Blocks.LIGHT_BLUE_WOOL),
|
|
entry(Items.ALLIUM, Blocks.MAGENTA_WOOL),
|
|
entry(Items.AZURE_BLUET, Blocks.SNOW_BLOCK),
|
|
entry(Items.RED_TULIP, Blocks.RED_WOOL),
|
|
entry(Items.ORANGE_TULIP, Blocks.ORANGE_WOOL),
|
|
entry(Items.WHITE_TULIP, Blocks.SNOW_BLOCK),
|
|
entry(Items.PINK_TULIP, Blocks.PINK_WOOL),
|
|
entry(Items.OXEYE_DAISY, Blocks.SNOW_BLOCK),
|
|
entry(Items.CORNFLOWER, Blocks.BLUE_WOOL),
|
|
entry(Items.WITHER_ROSE, Blocks.BLACK_WOOL),
|
|
entry(Items.LILY_OF_THE_VALLEY, Blocks.WHITE_WOOL),
|
|
entry(Items.BROWN_MUSHROOM, Blocks.BROWN_MUSHROOM_BLOCK),
|
|
entry(Items.RED_MUSHROOM, Blocks.RED_MUSHROOM_BLOCK),
|
|
entry(Items.STICK, Blocks.OAK_PLANKS),
|
|
entry(Items.GOLD_INGOT, Blocks.GOLD_BLOCK),
|
|
entry(Items.IRON_INGOT, Blocks.IRON_BLOCK),
|
|
entry(Items.DIAMOND, Blocks.DIAMOND_BLOCK),
|
|
entry(Items.NETHERITE_INGOT, Blocks.NETHERITE_BLOCK),
|
|
entry(Items.SUNFLOWER, Blocks.YELLOW_WOOL),
|
|
entry(Items.LILAC, Blocks.MAGENTA_WOOL),
|
|
entry(Items.ROSE_BUSH, Blocks.RED_WOOL),
|
|
entry(Items.PEONY, Blocks.PINK_WOOL),
|
|
entry(Items.CARROT, Blocks.ORANGE_WOOL),
|
|
entry(Items.APPLE,Blocks.RED_WOOL),
|
|
entry(Items.WHEAT,Blocks.HAY_BLOCK),
|
|
entry(Items.PORKCHOP, Blocks.PINK_WOOL),
|
|
entry(Items.RABBIT,Blocks.PINK_WOOL),
|
|
entry(Items.CHICKEN,Blocks.WHITE_TERRACOTTA),
|
|
entry(Items.BEEF,Blocks.NETHERRACK),
|
|
entry(Items.ENCHANTED_GOLDEN_APPLE,Blocks.GOLD_BLOCK),
|
|
entry(Items.COD,Blocks.WHITE_TERRACOTTA),
|
|
entry(Items.SALMON,Blocks.ACACIA_PLANKS),
|
|
entry(Items.ROTTEN_FLESH,Blocks.BROWN_WOOL),
|
|
entry(Items.PUFFERFISH,Blocks.YELLOW_TERRACOTTA),
|
|
entry(Items.TROPICAL_FISH,Blocks.ORANGE_WOOL),
|
|
entry(Items.POTATO,Blocks.WHITE_TERRACOTTA),
|
|
entry(Items.MUTTON, Blocks.RED_WOOL),
|
|
entry(Items.BEETROOT,Blocks.NETHERRACK),
|
|
entry(Items.MELON_SLICE,Blocks.MELON),
|
|
entry(Items.POISONOUS_POTATO,Blocks.SLIME_BLOCK),
|
|
entry(Items.SPIDER_EYE,Blocks.NETHERRACK),
|
|
entry(Items.GUNPOWDER,Blocks.GRAY_WOOL),
|
|
entry(Items.TURTLE_SCUTE,Blocks.LIME_WOOL),
|
|
entry(Items.ARMADILLO_SCUTE,Blocks.ANCIENT_DEBRIS),
|
|
entry(Items.FEATHER,Blocks.WHITE_WOOL),
|
|
entry(Items.FLINT,Blocks.BLACK_WOOL),
|
|
entry(Items.LEATHER,Blocks.SPRUCE_PLANKS),
|
|
entry(Items.GLOWSTONE_DUST,Blocks.GLOWSTONE),
|
|
entry(Items.PAPER,Blocks.WHITE_WOOL),
|
|
entry(Items.BRICK,Blocks.BRICKS),
|
|
entry(Items.INK_SAC,Blocks.BLACK_WOOL),
|
|
entry(Items.SNOWBALL,Blocks.SNOW_BLOCK),
|
|
entry(Items.WATER_BUCKET,Blocks.WATER),
|
|
entry(Items.LAVA_BUCKET,Blocks.LAVA),
|
|
entry(Items.MILK_BUCKET,Blocks.WHITE_WOOL),
|
|
entry(Items.CLAY_BALL, Blocks.CLAY),
|
|
entry(Items.COCOA_BEANS,Blocks.COCOA),
|
|
entry(Items.BONE,Blocks.BONE_BLOCK),
|
|
entry(Items.COD_BUCKET,Blocks.BROWN_TERRACOTTA),
|
|
entry(Items.PUFFERFISH_BUCKET,Blocks.YELLOW_TERRACOTTA),
|
|
entry(Items.SALMON_BUCKET,Blocks.PINK_TERRACOTTA),
|
|
entry(Items.TROPICAL_FISH_BUCKET,Blocks.ORANGE_TERRACOTTA),
|
|
entry(Items.SUGAR,Blocks.WHITE_WOOL),
|
|
entry(Items.BLAZE_POWDER,Blocks.GOLD_BLOCK),
|
|
entry(Items.ENDER_PEARL,Blocks.WARPED_PLANKS),
|
|
entry(Items.NETHER_STAR,Blocks.DIAMOND_BLOCK),
|
|
entry(Items.PRISMARINE_CRYSTALS,Blocks.SEA_LANTERN),
|
|
entry(Items.PRISMARINE_SHARD,Blocks.PRISMARINE),
|
|
entry(Items.RABBIT_HIDE,Blocks.OAK_PLANKS),
|
|
entry(Items.CHORUS_FRUIT,Blocks.PURPUR_BLOCK),
|
|
entry(Items.SHULKER_SHELL,Blocks.SHULKER_BOX),
|
|
entry(Items.NAUTILUS_SHELL,Blocks.BONE_BLOCK),
|
|
entry(Items.HEART_OF_THE_SEA,Blocks.CONDUIT),
|
|
entry(Items.HONEYCOMB,Blocks.HONEYCOMB_BLOCK),
|
|
entry(Items.NAME_TAG,Blocks.BONE_BLOCK),
|
|
entry(Items.TOTEM_OF_UNDYING,Blocks.YELLOW_TERRACOTTA),
|
|
entry(Items.TRIDENT,Blocks.PRISMARINE),
|
|
entry(Items.GHAST_TEAR,Blocks.WHITE_WOOL),
|
|
entry(Items.PHANTOM_MEMBRANE,Blocks.BONE_BLOCK),
|
|
entry(Items.EGG,Blocks.BONE_BLOCK),
|
|
//entry(Items.,Blocks.),
|
|
entry(Items.COPPER_INGOT,Blocks.COPPER_BLOCK),
|
|
entry(Items.AMETHYST_SHARD, Blocks.AMETHYST_BLOCK));
|
|
|
|
/**
|
|
* Gets the colour to print an item in when printing its count in a hopper counter.
|
|
*/
|
|
public static TextColor fromItem(Item item, RegistryAccess registryAccess)
|
|
{
|
|
if (DEFAULTS.containsKey(item)) return TextColor.fromRgb(appropriateColor(DEFAULTS.get(item).defaultMapColor().col));
|
|
if (item instanceof DyeItem dye) return TextColor.fromRgb(appropriateColor(dye.getDyeColor().getMapColor().col));
|
|
Block block = null;
|
|
final Registry<Item> itemRegistry = registryAccess.registryOrThrow(Registries.ITEM);
|
|
final Registry<Block> blockRegistry = registryAccess.registryOrThrow(Registries.BLOCK);
|
|
ResourceLocation id = itemRegistry.getKey(item);
|
|
if (item instanceof BlockItem blockItem)
|
|
{
|
|
block = blockItem.getBlock();
|
|
}
|
|
else if (blockRegistry.getOptional(id).isPresent())
|
|
{
|
|
block = blockRegistry.get(id);
|
|
}
|
|
if (block != null)
|
|
{
|
|
if (block instanceof AbstractBannerBlock) return TextColor.fromRgb(appropriateColor(((AbstractBannerBlock) block).getColor().getMapColor().col));
|
|
if (block instanceof BeaconBeamBlock) return TextColor.fromRgb(appropriateColor( ((BeaconBeamBlock) block).getColor().getMapColor().col));
|
|
return TextColor.fromRgb(appropriateColor( block.defaultMapColor().col));
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Guesses the item's colour from the item itself. It first calls {@link HopperCounter#fromItem} to see if it has a
|
|
* valid colour there, if not just makes a guess, and if that fails just returns null
|
|
*/
|
|
public static TextColor guessColor(Item item, RegistryAccess registryAccess)
|
|
{
|
|
TextColor direct = fromItem(item, registryAccess);
|
|
if (direct != null) return direct;
|
|
if (CarpetServer.minecraft_server == null) return WHITE;
|
|
|
|
ResourceLocation id = registryAccess.registryOrThrow(Registries.ITEM).getKey(item);
|
|
for (RecipeType<?> type: registryAccess.registryOrThrow(Registries.RECIPE_TYPE))
|
|
{
|
|
for (Recipe<?> r: ((RecipeManagerInterface) CarpetServer.minecraft_server.getRecipeManager()).getAllMatching(type, id, registryAccess))
|
|
{
|
|
for (Ingredient ingredient: r.getIngredients())
|
|
{
|
|
for (Collection<ItemStack> stacks : ((IngredientInterface) (Object) ingredient).getRecipeStacks())
|
|
{
|
|
for (ItemStack iStak : stacks)
|
|
{
|
|
TextColor cand = fromItem(iStak.getItem(), registryAccess);
|
|
if (cand != null)
|
|
return cand;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Returns the hopper counter for the given color
|
|
*/
|
|
public static HopperCounter getCounter(DyeColor color) {
|
|
return COUNTERS.get(color);
|
|
}
|
|
|
|
/**
|
|
* Returns the hopper counter from the colour name, if not null
|
|
*/
|
|
public static HopperCounter getCounter(String color)
|
|
{
|
|
try
|
|
{
|
|
DyeColor colorEnum = DyeColor.valueOf(color.toUpperCase(Locale.ROOT));
|
|
return COUNTERS.get(colorEnum);
|
|
}
|
|
catch (IllegalArgumentException e)
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* The total number of items in the counter
|
|
*/
|
|
public long getTotalItems()
|
|
{
|
|
return counter.isEmpty()?0:counter.values().longStream().sum();
|
|
}
|
|
}
|