mirror of
https://github.com/GTNewHorizons/NotEnoughItems.git
synced 2026-11-15 17:54:50 +00:00
317 lines
9.8 KiB
Java
317 lines
9.8 KiB
Java
package codechicken.nei;
|
|
|
|
import java.io.File;
|
|
import java.util.ArrayList;
|
|
import java.util.HashMap;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.UUID;
|
|
import java.util.concurrent.ConcurrentHashMap;
|
|
import java.util.concurrent.CopyOnWriteArrayList;
|
|
import java.util.function.Supplier;
|
|
import java.util.stream.Collectors;
|
|
|
|
import net.minecraft.item.Item;
|
|
import net.minecraft.item.ItemStack;
|
|
import net.minecraft.nbt.NBTBase;
|
|
import net.minecraft.nbt.NBTBase.NBTPrimitive;
|
|
import net.minecraft.nbt.NBTTagCompound;
|
|
import net.minecraft.util.StatCollector;
|
|
|
|
import com.google.gson.JsonObject;
|
|
import com.google.gson.JsonParser;
|
|
import com.google.gson.JsonSyntaxException;
|
|
|
|
import codechicken.nei.ItemList.AnyMultiItemFilter;
|
|
import codechicken.nei.ItemList.EverythingItemFilter;
|
|
import codechicken.nei.ItemList.NothingItemFilter;
|
|
import codechicken.nei.PresetsList.Preset;
|
|
import codechicken.nei.PresetsList.PresetMode;
|
|
import codechicken.nei.api.ItemFilter;
|
|
import codechicken.nei.util.ItemStackFilterParser;
|
|
|
|
public class CollapsibleItems {
|
|
|
|
protected static class GroupItem {
|
|
|
|
public String guid;
|
|
public ItemFilter filter;
|
|
public boolean expanded = false;
|
|
public String displayName = "";
|
|
public String unlocalizedName;
|
|
|
|
public void setFilter(String filter) {
|
|
this.filter = ItemStackFilterParser.parse(filter.trim());
|
|
this.guid = this.filter != null ? UUID.nameUUIDFromBytes(filter.getBytes()).toString() : "";
|
|
}
|
|
|
|
public void setFilter(ItemFilter filter, String guid) {
|
|
this.filter = filter;
|
|
this.guid = guid;
|
|
}
|
|
|
|
public String getDisplayName() {
|
|
if (this.unlocalizedName != null && !this.unlocalizedName.isEmpty()) {
|
|
final String translated = StatCollector.translateToLocal(this.unlocalizedName);
|
|
|
|
if (!translated.equals(this.unlocalizedName)) {
|
|
return translated;
|
|
}
|
|
}
|
|
|
|
return this.displayName;
|
|
}
|
|
|
|
public boolean matches(ItemStack stack) {
|
|
return this.filter.matches(stack);
|
|
}
|
|
}
|
|
|
|
public static class ApiGroup {
|
|
|
|
private String unlocalizedName;
|
|
|
|
public ApiGroup setName(String unlocalizedName) {
|
|
this.unlocalizedName = unlocalizedName;
|
|
return this;
|
|
}
|
|
}
|
|
|
|
private static final String STATE_KEY = "collapsibleitems";
|
|
|
|
protected static File statesFile;
|
|
protected static final List<GroupItem> groups = new ArrayList<>();
|
|
protected static final List<Supplier<GroupItem>> apiGroups = new CopyOnWriteArrayList<>();
|
|
protected static final Map<ItemStack, Integer> cache = new ConcurrentHashMap<>();
|
|
|
|
private CollapsibleItems() {}
|
|
|
|
public static void load() {
|
|
CollapsibleItems.groups.clear();
|
|
CollapsibleItems.cache.clear();
|
|
|
|
for (int i = PresetsList.presets.size() - 1; i >= 0; i--) {
|
|
Preset preset = PresetsList.presets.get(i);
|
|
if (preset.enabled && preset.mode == PresetMode.GROUP) {
|
|
GroupItem group = new GroupItem();
|
|
group.setFilter(preset, UUID.nameUUIDFromBytes(preset.items.toString().getBytes()).toString());
|
|
group.displayName = preset.name;
|
|
addGroup(group);
|
|
}
|
|
}
|
|
|
|
if (NEIClientConfig.enableCollapsibleItems()) {
|
|
ClientHandler.loadSettingsFile(
|
|
"collapsibleitems.cfg",
|
|
lines -> parseFile(lines.collect(Collectors.toCollection(ArrayList::new))));
|
|
|
|
for (Supplier<GroupItem> apiGroup : CollapsibleItems.apiGroups) {
|
|
try {
|
|
addGroup(apiGroup.get());
|
|
} catch (Exception e) {
|
|
NEIClientConfig.logger.error("Failed to add API group", e);
|
|
}
|
|
}
|
|
}
|
|
|
|
loadStates();
|
|
}
|
|
|
|
public static ApiGroup registerGroup(String filter) {
|
|
final ApiGroup apiGroup = new ApiGroup();
|
|
|
|
CollapsibleItems.apiGroups.add(() -> {
|
|
GroupItem group = new GroupItem();
|
|
group.setFilter(filter);
|
|
group.unlocalizedName = apiGroup.unlocalizedName;
|
|
return group;
|
|
});
|
|
|
|
return apiGroup;
|
|
}
|
|
|
|
public static ApiGroup registerGroup(Iterable<ItemStack> items) {
|
|
final ApiGroup apiGroup = new ApiGroup();
|
|
final ItemStackSet filter = new ItemStackSet();
|
|
|
|
for (ItemStack stack : items) {
|
|
if (stack != null) filter.add(stack.copy());
|
|
}
|
|
|
|
if (filter.isEmpty()) return apiGroup;
|
|
|
|
final String key = filter.keys().stream()
|
|
.map(stack -> Item.itemRegistry.getNameForObject(stack.getItem()) + ":" + stack.getItemDamage())
|
|
.sorted().collect(Collectors.joining(","));
|
|
final String guid = UUID.nameUUIDFromBytes(key.getBytes()).toString();
|
|
|
|
CollapsibleItems.apiGroups.add(() -> {
|
|
GroupItem group = new GroupItem();
|
|
group.setFilter(filter, guid);
|
|
group.unlocalizedName = apiGroup.unlocalizedName;
|
|
return group;
|
|
});
|
|
|
|
return apiGroup;
|
|
}
|
|
|
|
private static void parseFile(List<String> itemStrings) {
|
|
final JsonParser parser = new JsonParser();
|
|
GroupItem group = new GroupItem();
|
|
|
|
for (String itemStr : itemStrings) {
|
|
try {
|
|
|
|
if (itemStr.startsWith("; ")) {
|
|
JsonObject settings = parser.parse(itemStr.substring(2)).getAsJsonObject();
|
|
|
|
if (settings.get("unlocalizedName") != null) {
|
|
group.unlocalizedName = settings.get("unlocalizedName").getAsString();
|
|
}
|
|
|
|
if (settings.get("expanded") != null) {
|
|
group.expanded = settings.get("expanded").getAsBoolean();
|
|
}
|
|
|
|
} else {
|
|
group.setFilter(itemStr);
|
|
}
|
|
|
|
if (group.filter != null) {
|
|
addGroup(group);
|
|
group = new GroupItem();
|
|
}
|
|
|
|
} catch (IllegalArgumentException | JsonSyntaxException | IllegalStateException e) {
|
|
NEIClientConfig.logger.error("Failed to load collapsible items from json string:\n{}", itemStr);
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void addGroup(GroupItem group) {
|
|
if (group == null || group.filter == null
|
|
|| group.filter instanceof EverythingItemFilter
|
|
|| group.filter instanceof NothingItemFilter)
|
|
return;
|
|
CollapsibleItems.groups.add(group);
|
|
}
|
|
|
|
public static boolean isEmpty() {
|
|
return CollapsibleItems.groups.isEmpty();
|
|
}
|
|
|
|
public static ItemFilter getItemFilter() {
|
|
AnyMultiItemFilter filter = new AnyMultiItemFilter();
|
|
|
|
for (GroupItem group : CollapsibleItems.groups) {
|
|
filter.filters.add(group.filter);
|
|
}
|
|
|
|
return filter;
|
|
}
|
|
|
|
public static void clearCache() {
|
|
CollapsibleItems.cache.clear();
|
|
}
|
|
|
|
public static void putItem(ItemStack stack) {
|
|
int groupIndex = -1;
|
|
|
|
for (int i = 0; i < CollapsibleItems.groups.size() && groupIndex == -1; i++) {
|
|
if (CollapsibleItems.groups.get(i).matches(stack)) {
|
|
groupIndex = i;
|
|
}
|
|
}
|
|
|
|
if (groupIndex != -1) {
|
|
CollapsibleItems.cache.put(stack, groupIndex);
|
|
}
|
|
}
|
|
|
|
public static int getGroupIndex(ItemStack stack) {
|
|
|
|
if (stack == null) {
|
|
return -1;
|
|
}
|
|
|
|
return CollapsibleItems.cache.getOrDefault(stack, -1);
|
|
}
|
|
|
|
public static String getDisplayName(int groupIndex) {
|
|
|
|
if (groupIndex < CollapsibleItems.groups.size()) {
|
|
return CollapsibleItems.groups.get(groupIndex).getDisplayName();
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public static boolean isExpanded(int groupIndex) {
|
|
|
|
if (groupIndex < CollapsibleItems.groups.size()) {
|
|
return CollapsibleItems.groups.get(groupIndex).expanded;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public static void setExpanded(int groupIndex, boolean expanded) {
|
|
|
|
if (groupIndex < CollapsibleItems.groups.size()) {
|
|
CollapsibleItems.groups.get(groupIndex).expanded = expanded;
|
|
}
|
|
}
|
|
|
|
public static void toggleGroups(Boolean expanded) {
|
|
|
|
if (expanded == null) {
|
|
expanded = CollapsibleItems.groups.stream().noneMatch(g -> g.expanded);
|
|
}
|
|
|
|
for (GroupItem group : CollapsibleItems.groups) {
|
|
group.expanded = expanded;
|
|
}
|
|
|
|
}
|
|
|
|
public static void saveStates() {
|
|
NBTTagCompound list = new NBTTagCompound();
|
|
|
|
for (GroupItem group : CollapsibleItems.groups) {
|
|
list.setBoolean(group.guid, group.expanded);
|
|
}
|
|
|
|
if (NEIClientConfig.world != null) {
|
|
NEIClientConfig.world.nbt.setTag(STATE_KEY, list);
|
|
}
|
|
}
|
|
|
|
private static void loadStates() {
|
|
|
|
try {
|
|
|
|
if (NEIClientConfig.world.nbt.hasKey(STATE_KEY)) {
|
|
NBTTagCompound states = NEIClientConfig.world.nbt.getCompoundTag(STATE_KEY);
|
|
final Map<String, NBTBase> list = states.tagMap;
|
|
final Map<String, GroupItem> mapping = new HashMap<>();
|
|
|
|
for (GroupItem group : CollapsibleItems.groups) {
|
|
mapping.put(group.guid, group);
|
|
}
|
|
|
|
for (Map.Entry<String, NBTBase> nbtEntry : list.entrySet()) {
|
|
if (mapping.containsKey(nbtEntry.getKey())) {
|
|
mapping.get(nbtEntry.getKey()).expanded = ((NBTPrimitive) nbtEntry.getValue()).func_150290_f()
|
|
== 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
} catch (Exception e) {
|
|
NEIClientConfig.logger.error("Error loading collapsible items states", e);
|
|
}
|
|
|
|
}
|
|
|
|
}
|