NEI Optimization (#519)

* NEI Optimization

* save setting after death

---------

Co-authored-by: slprime <[email protected]>
This commit is contained in:
slprimeandslprime authored and GitHub committed 2024-08-29 22:14:52 +02:00
1 parent 165afa2910
commit bd5e991a84
27 files changed
+516 -645

No files matched your search

@@ -1,227 +1,33 @@
package codechicken.nei;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Predicate;
import java.util.regex.Pattern;
import java.util.regex.PatternSyntaxException;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTBase.NBTPrimitive;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.util.StatCollector;
import net.minecraftforge.oredict.OreDictionary;
import org.apache.commons.io.IOUtils;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
import com.google.gson.JsonSyntaxException;
import codechicken.nei.ItemList.AllMultiItemFilter;
import codechicken.nei.ItemList.AnyMultiItemFilter;
import codechicken.nei.ItemList.EverythingItemFilter;
import codechicken.nei.ItemList.NegatedItemFilter;
import codechicken.nei.ItemList.NothingItemFilter;
import codechicken.nei.PresetsList.Preset;
import codechicken.nei.PresetsList.PresetMode;
import codechicken.nei.api.ItemFilter;
import cpw.mods.fml.common.registry.GameData;
import codechicken.nei.util.ItemStackFilterParser;
public class CollapsibleItems {
protected static interface ISearchParserProvider {
public ItemFilter getFilter(String searchText);
default Predicate<String> getMatcher(String searchText) {
if (searchText.length() >= 3 && searchText.startsWith("r/") && searchText.endsWith("/")) {
try {
Pattern pattern = Pattern.compile(
searchText.substring(2, searchText.length() - 1),
Pattern.MULTILINE | Pattern.CASE_INSENSITIVE | Pattern.UNICODE_CASE);
return value -> pattern.matcher(value).find();
} catch (PatternSyntaxException ignored) {}
} else if (!searchText.isEmpty()) {
return value -> value.toLowerCase().contains(searchText);
}
return null;
}
}
protected static class GroupTokenParser {
protected final HashMap<Character, ISearchParserProvider> searchProviders = new HashMap<>();
public void addProvider(char prefix, ISearchParserProvider provider) {
this.searchProviders.put(prefix, provider);
}
public ItemFilter getFilter(String filterText) {
final String[] parts = filterText.toLowerCase().trim().split("\\|");
final List<ItemFilter> searchTokens = Arrays.stream(parts).map(s -> parseSearchText(s))
.filter(s -> s != null && !s.filters.isEmpty()).collect(Collectors.toCollection(ArrayList::new));
if (searchTokens.isEmpty()) {
return new EverythingItemFilter();
} else if (searchTokens.size() == 1) {
return searchTokens.get(0);
} else {
return new AnyMultiItemFilter(searchTokens);
}
}
private AllMultiItemFilter parseSearchText(String filterText) {
if (filterText.isEmpty()) {
return null;
}
final String[] tokens = filterText.split("\\s+");
final AllMultiItemFilter searchTokens = new AllMultiItemFilter();
for (String token : tokens) {
token = token.trim();
boolean ignore = token.startsWith("!");
if (ignore) {
token = token.substring(1);
}
if (token.isEmpty()) {
continue;
}
ISearchParserProvider provider = this.searchProviders.get(token.charAt(0));
if (provider != null) {
token = token.substring(1);
} else {
provider = this.searchProviders.get('\0');
}
ItemFilter filter = parseToken(ignore ? "!" + token : token, provider);
if (filter != null) {
searchTokens.filters.add(filter);
}
}
return searchTokens;
}
private ItemFilter parseToken(String token, ISearchParserProvider provider) {
final String[] parts = token.split(",");
final AnyMultiItemFilter includeFilter = new AnyMultiItemFilter();
final AnyMultiItemFilter expludeFilter = new AnyMultiItemFilter();
final AllMultiItemFilter groupFilter = new AllMultiItemFilter();
for (String part : parts) {
boolean ignore = part.startsWith("!");
if (ignore) {
part = part.substring(1);
}
ItemFilter filter = provider.getFilter(part);
if (filter == null) {
continue;
}
if (ignore) {
expludeFilter.filters.add(filter);
} else {
includeFilter.filters.add(filter);
}
}
if (!includeFilter.filters.isEmpty()) {
groupFilter.filters.add(includeFilter);
}
if (!expludeFilter.filters.isEmpty()) {
groupFilter.filters.add(new NegatedItemFilter(expludeFilter));
}
return groupFilter.filters.isEmpty() ? null : groupFilter;
}
}
protected static class IdentifierFilter implements ISearchParserProvider {
@Override
public ItemFilter getFilter(String searchText) {
if (Pattern.matches("^\\d+(-\\d+)*$", searchText)) {
final Predicate<Integer> filter = generateDamageFilter(searchText);
return (stack) -> filter.test(stack.getItemDamage());
}
Predicate<String> matcher = getMatcher(searchText);
if (matcher != null) {
return stack -> matcher.test(getStringIdentifier(stack));
}
return null;
}
protected String getStringIdentifier(ItemStack stack) {
String name = GameData.getItemRegistry().getNameForObject(stack.getItem());
return name == null || name.isEmpty() ? "Unknown:Unknown" : name;
}
protected Predicate<Integer> generateDamageFilter(String searchText) {
String[] range = searchText.split("-");
if (range.length == 1) {
final int damage = Integer.parseInt(range[0]);
return (dmg) -> dmg == damage;
} else {
final int damageStart = Integer.parseInt(range[0]);
final int damageEnd = Integer.parseInt(range[1]);
return (dmg) -> dmg >= damageStart && dmg <= damageEnd;
}
}
}
protected static class OreDictionaryFilter implements ISearchParserProvider {
@Override
public ItemFilter getFilter(String searchText) {
Predicate<String> matcher = getMatcher(searchText);
if (matcher != null) {
return stack -> matches(stack, matcher);
}
return null;
}
protected boolean matches(ItemStack stack, Predicate<String> matcher) {
return IntStream.of(OreDictionary.getOreIDs(stack))
.anyMatch(id -> matcher.test(OreDictionary.getOreName(id)));
}
}
protected static class GroupItem {
public String guid;
@@ -232,8 +38,8 @@ public class CollapsibleItems {
public GroupItem() {}
public void setFilter(String filter) {
this.filter = CollapsibleItems.groupParser.getFilter(filter.trim());
this.guid = UUID.nameUUIDFromBytes(filter.getBytes()).toString();
this.filter = ItemStackFilterParser.parse(filter.trim());
this.guid = this.filter != null ? UUID.nameUUIDFromBytes(filter.getBytes()).toString() : "";
}
public void setFilter(ItemFilter filter, String guid) {
@@ -246,17 +52,40 @@ public class CollapsibleItems {
}
}
private static final String STATE_KEY = "collapsibleitems";
protected File statesFile;
protected static final GroupTokenParser groupParser = new GroupTokenParser();
protected final List<GroupItem> groups = new ArrayList<>();
protected final Map<ItemStack, Integer> cache = new ConcurrentHashMap<>();
static {
groupParser.addProvider('\0', new IdentifierFilter());
groupParser.addProvider('$', new OreDictionaryFilter());
public void load() {
try {
if (NEIClientConfig.world.nbt.hasKey(STATE_KEY)) {
NBTTagCompound states = NEIClientConfig.world.nbt.getCompoundTag(STATE_KEY);
@SuppressWarnings("unchecked")
final Map<String, NBTPrimitive> list = (Map<String, NBTPrimitive>) states.tagMap;
final Map<String, GroupItem> mapping = new HashMap<>();
for (GroupItem group : this.groups) {
mapping.put(group.guid, group);
}
for (Map.Entry<String, NBTPrimitive> nbtEntry : list.entrySet()) {
if (mapping.containsKey(nbtEntry.getKey())) {
mapping.get(nbtEntry.getKey()).expanded = nbtEntry.getValue().func_150290_f() == 1;
}
}
}
} catch (Exception e) {
NEIClientConfig.logger.error("Error loading collapsible items states", e);
}
reloadGroups();
}
public void reload() {
public void reloadGroups() {
this.groups.clear();
this.cache.clear();
@@ -271,49 +100,17 @@ public class CollapsibleItems {
}
if (NEIClientConfig.enableCollapsibleItems()) {
loadCollapsibleItems();
}
loadStates();
if (ItemList.loadFinished) {
LayoutManager.markItemsDirty();
ClientHandler.loadSettingsFile(
"collapsibleitems.cfg",
lines -> parseFile(lines.collect(Collectors.toCollection(ArrayList::new))));
}
}
protected void loadCollapsibleItems() {
File file = NEIClientConfig.collapsibleItemsFile;
if (!file.exists()) {
try (FileWriter writer = new FileWriter(file)) {
NEIClientConfig.logger.info("Creating default collapsible items list {}", file);
URL defaultCollapsibleItemsResource = ClientHandler.class
.getResource("/assets/nei/cfg/collapsibleitems.cfg");
if (defaultCollapsibleItemsResource != null) {
IOUtils.copy(defaultCollapsibleItemsResource.openStream(), writer);
}
} catch (IOException e) {
NEIClientConfig.logger.error("Failed to save default collapsible items list to file {}", file, e);
}
}
try (FileReader reader = new FileReader(file)) {
NEIClientConfig.logger.info("Loading collapsible items from file {}", file);
parseFile(IOUtils.readLines(reader));
} catch (IOException e) {
NEIClientConfig.logger.error("Failed to load collapsible items from file {}", file, e);
}
}
public void parseFile(List<String> itemStrings) {
private void parseFile(List<String> itemStrings) {
final JsonParser parser = new JsonParser();
GroupItem group = new GroupItem();
for (String itemStr : itemStrings) {
if (itemStr.startsWith("#") || itemStr.trim().isEmpty()) {
continue;
}
try {
if (itemStr.startsWith("; ")) {
@@ -324,10 +121,10 @@ public class CollapsibleItems {
}
if (settings.get("unlocalizedName") != null) {
String displayName = StatCollector
.translateToLocal(settings.get("unlocalizedName").getAsString());
String unlocalizedName = settings.get("unlocalizedName").getAsString();
String displayName = StatCollector.translateToLocal(unlocalizedName);
if (!displayName.equals(settings.get("unlocalizedName").getAsString())) {
if (!displayName.equals(unlocalizedName)) {
group.displayName = displayName;
}
}
@@ -430,7 +227,7 @@ public class CollapsibleItems {
public void toggleGroups(Boolean expanded) {
if (expanded == null) {
expanded = !this.groups.stream().filter(g -> g.expanded).findAny().isPresent();
expanded = this.groups.stream().noneMatch(g -> g.expanded);
}
for (GroupItem group : this.groups) {
@@ -440,33 +237,6 @@ public class CollapsibleItems {
saveStates();
}
private void loadStates() {
try {
if (NEIClientConfig.world.nbt.hasKey("collapsibleitems")) {
NBTTagCompound states = NEIClientConfig.world.nbt.getCompoundTag("collapsibleitems");
@SuppressWarnings("unchecked")
final Map<String, NBTPrimitive> list = (Map<String, NBTPrimitive>) states.tagMap;
final Map<String, GroupItem> mapping = new HashMap<>();
for (GroupItem group : this.groups) {
mapping.put(group.guid, group);
}
for (Map.Entry<String, NBTPrimitive> nbtEntry : list.entrySet()) {
if (mapping.containsKey(nbtEntry.getKey())) {
mapping.get(nbtEntry.getKey()).expanded = nbtEntry.getValue().func_150290_f() == 1;
}
}
}
} catch (Exception e) {
NEIClientConfig.logger.error("Error loading collapsible items states", e);
}
}
private void saveStates() {
NBTTagCompound list = new NBTTagCompound();
@@ -474,7 +244,7 @@ public class CollapsibleItems {
list.setBoolean(group.guid, group.expanded);
}
NEIClientConfig.world.nbt.setTag("collapsibleitems", list);
NEIClientConfig.world.nbt.setTag(STATE_KEY, list);
}
}