Cleaned and generalised item loading/searching

Reimplemented subsets
Added regex searching
Fixed format error on delete all
Fixed GuiButton handling clicks before NEI widgets could override
Re-Implemented banned blocks implementation
Added brewing recipes again
note test obf ASM beacons
Fixed some calls being intercepted by item panel when mouse was over a gui element
Fixed crash on closing potion window with escape
Disabled fast transfer, scrolling, and drag 'n' drop in creative
Added item panel sorting
Removed TMI uninstaller
Fixed /give command
Updated to 1.7.10
This commit is contained in:
Chicken-Bomes committed 2014-06-29 20:42:02 +10:00
1 parent 3c9ebc6961
commit 3c84527806
67 files changed
+3251 -2319

No files matched your search

+143 -289
View File
@@ -1,74 +1,48 @@
package codechicken.nei;
import codechicken.nei.ItemPanel.ItemPanelObject;
import codechicken.nei.ThreadOperationTimer.TimeoutException;
import codechicken.nei.api.ItemFilter;
import codechicken.nei.api.ItemFilter.ItemFilterProvider;
import codechicken.nei.api.ItemInfo;
import codechicken.nei.guihook.GuiContainerManager;
import com.google.common.collect.ArrayListMultimap;
import com.google.common.collect.ListMultimap;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.util.EnumChatFormatting;
import net.minecraft.util.IIcon;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.regex.Pattern;
import java.util.regex.PatternSyntaxException;
public class ItemList
{
/**
* Fields are replaced atomically and contents never modified.
*/
public static List<ItemStack> items = new ArrayList<ItemStack>();
/**
* Fields are replaced atomically and contents never modified.
*/
public static ListMultimap<Item, ItemStack> itemMap = ArrayListMultimap.create();
/**
* Updates to this should be synchronised on this
*/
public static final List<ItemFilterProvider> itemFilterers = new LinkedList<ItemFilterProvider>();
public static final List<ItemsLoadedCallback> loadCallbacks = new LinkedList<ItemsLoadedCallback>();
private static boolean matching = false;
private static boolean loading = false;
private static boolean research = false;
private static boolean reload = false;
private static boolean filtering = false;
private static boolean refilter = false;
private static HashSet<Item> erroredItems = new HashSet<Item>();
private static HashSet<String> stackTraces = new HashSet<String>();
private static interface ItemMatcher
{
public boolean matches(ItemStack item);
}
/*private static class SubsetItemMatcher implements ItemMatcher
{
final List<SubSetRangeTag> tags;
public SubsetItemMatcher(List<SubSetRangeTag> tags)
{
this.tags = tags;
}
@Override
public boolean matches(ItemStack item)
{
for(SubSetRangeTag tag : tags)
if(tag.isItemInRange(item.getItem(), item.getItemDamage()))
return true;
return false;
}
}*/
private static class PatternItemMatcher implements ItemMatcher
{
Pattern pattern;
public PatternItemMatcher(Pattern pattern) {
this.pattern = pattern;
}
@Override
public boolean matches(ItemStack item) {
return pattern.matcher(EnumChatFormatting.getTextWithoutFormattingCodes(GuiContainerManager.concatenatedDisplayName(item, true).toLowerCase())).find();
}
}
private static class EverythingItemMatcher implements ItemMatcher
public static class EverythingItemFilter implements ItemFilter
{
@Override
public boolean matches(ItemStack item) {
@@ -76,7 +50,7 @@ public class ItemList
}
}
private static class NothingItemMatcher implements ItemMatcher
public static class NothingItemFilter implements ItemFilter
{
@Override
public boolean matches(ItemStack item) {
@@ -84,287 +58,167 @@ public class ItemList
}
}
public static ItemMatcher getSearchMatcher() {
String matchstring = NEIClientConfig.getSearchExpression().toLowerCase();
/*if(matchstring.startsWith("@") && matchstring.length() > 1)
{
LinkedList<SubSetRangeTag> tags = new LinkedList<SubSetRangeTag>();
try
{
String pattern = matchstring.substring(1);
for(SubSetRangeTag tag : DropDownFile.dropDownInstance.allTags())
if(CommonUtils.filterText(tag.qualifiedname).toLowerCase().contains(pattern))
tags.add(tag);
if(tags.isEmpty())
return new NothingItemMatcher();
return new SubsetItemMatcher(tags);
}
catch(PatternSyntaxException e)
{
return new NothingItemMatcher();
}
}*/
{
matchstring = matchstring.replace(".", "");
matchstring = matchstring.replace("?", ".");
matchstring = matchstring.replace("*", ".+?");
Pattern pattern = null;
try {
pattern = Pattern.compile(matchstring);
} catch (PatternSyntaxException ignored) {}
if (pattern == null || pattern.toString().equals(""))
return new EverythingItemMatcher();
return new PatternItemMatcher(pattern);
}
}
public static boolean itemMatchesSearch(ItemStack item) {
return getSearchMatcher().matches(item);
}
public static interface IItemCounter
public static class PatternItemFilter implements ItemFilter
{
public Item getItem();
Pattern pattern;
public Thread getThread();
}
@SuppressWarnings("serial")
public static class TimeoutException extends RuntimeException
{
public final Item itemID;
public TimeoutException(String msg, Item lastItem) {
super(msg);
itemID = lastItem;
}
}
public static class ThreadLoadMonitor extends Thread
{
IItemCounter loadingThread;
public ThreadLoadMonitor(IItemCounter handle) {
super("NEI Load Monitor");
loadingThread = handle;
}
@SuppressWarnings("deprecation")
@Override
public void run() {
if(true) return;
Item lastItem = null;
long lastTime = System.currentTimeMillis();
while (loadingThread.getThread().isAlive()) {
if (lastItem != loadingThread.getItem()) {
lastTime = System.currentTimeMillis();
lastItem = loadingThread.getItem();
} else if (System.currentTimeMillis() - lastTime > 2000 && lastItem != null) {
loadingThread.getThread().stop(new TimeoutException("Took to long to advance item", lastItem));
}
try {
Thread.sleep(2000);
} catch (InterruptedException ie) {}
}
}
}
public static class ThreadMatchSearch extends Thread implements IItemCounter
{
private Item item;
public ThreadMatchSearch() {
super("NEI Item Searching Thread");
matching = true;
public PatternItemFilter(Pattern pattern) {
this.pattern = pattern;
}
@Override
public Item getItem() {
return item;
}
@Override
public Thread getThread() {
return this;
}
@Override
public void run() {
//new ThreadLoadMonitor(this).start();
try {
startMatch:
while (matching) {
try {
ArrayList<ItemPanelObject> visibleitems = new ArrayList<ItemPanelObject>();
ItemMatcher matcher = getSearchMatcher();
for (ItemStack stack : items) {
item = stack.getItem();
if (research) {
research = false;
continue startMatch;
}
/*if(stack.hasTagCompound() ? NEIClientConfig.vishash.isItemHidden(item, stack.stackTagCompound) : NEIClientConfig.vishash.isItemHidden(item, stack.getItemDamage()))
continue;*/
if (NEIClientConfig.bannedBlocks.contains(stack))
continue;
if (matcher.matches(stack))
visibleitems.add(new ItemPanelStack(stack));
}
ItemPanel.visibleitems = visibleitems;
} catch (TimeoutException e) {
System.err.println("Removing itemID: " + e.itemID + " from list.");
e.printStackTrace();
erroredItems.add(e.itemID);
loadItems();
}
matching = false;
}
}
finally {
matching = false;
}
public boolean matches(ItemStack item) {
return pattern.matcher(ItemInfo.getSearchName(item)).find();
}
}
private static HashSet<String> stackTraces = new HashSet<String>();
public static class ThreadLoadItems extends Thread implements IItemCounter
public static interface ItemsLoadedCallback
{
private Item item;
public void itemsLoaded();
}
public static boolean itemMatches(ItemStack item, List<ItemFilter> filters) {
for(ItemFilter filter : filters)
if(!filter.matches(item))
return false;
return true;
}
public static boolean itemMatches(ItemStack item) {
return itemMatches(item, getItemFilters());
}
public static List<ItemFilter> getItemFilters() {
LinkedList<ItemFilter> filters = new LinkedList<ItemFilter>();
synchronized (itemFilterers) {
for(ItemFilterProvider p : itemFilterers)
filters.add(p.getFilter());
}
return filters;
}
private static class ThreadLoadItems extends Thread
{
public ThreadLoadItems() {
super("NEI Item Loading Thread");
loading = true;
super("NEI Item Loading");
}
@Override
public Item getItem() {
return item;
}
@Override
public Thread getThread() {
return this;
private void damageSearch(Item item, List<ItemStack> permutations) {
HashSet<String> damageIconSet = new HashSet<String>();
for (int damage = 0; damage < 16; damage++)
try {
ItemStack itemstack = new ItemStack(item, 1, damage);
IIcon icon = item.getIconIndex(itemstack);
String name = GuiContainerManager.concatenatedDisplayName(itemstack, false);
String s = name + "@" + (icon == null ? 0 : icon.hashCode());
if (!damageIconSet.contains(s)) {
damageIconSet.add(s);
permutations.add(itemstack);
}
}
catch(TimeoutException t) {
throw t;
}
catch(Throwable t) {
NEIServerUtils.logOnce(t, stackTraces, "Ommiting "+item+":"+damage+" "+item.getClass().getSimpleName(), item.toString());
}
}
@Override
public void run() {
new ThreadLoadMonitor(this).start();
startSearch:
while (loading) {
try {
ArrayList<ItemStack> items = new ArrayList<ItemStack>();
ArrayList<ItemStack> permutations = new ArrayList<ItemStack>();
ListMultimap<Item, ItemStack> itemMap = ArrayListMultimap.create();
ThreadOperationTimer timer = ThreadOperationTimer.start(this, 500);
restart:
do {
reload = false;
LinkedList<ItemStack> items = new LinkedList<ItemStack>();
LinkedList<ItemStack> permutations = new LinkedList<ItemStack>();
ListMultimap<Item, ItemStack> itemMap = ArrayListMultimap.create();
for (Item item : (Iterable<Item>) Item.itemRegistry) {
this.item = item;
if (reload) {
reload = false;
continue startSearch;
}
timer.setLimit(500);
for (Item item : (Iterable<Item>) Item.itemRegistry) {
if (reload)
continue restart;
if (item == null || ItemInfo.isHidden(item))
continue;
if (item == null || erroredItems.contains(item))
continue;
try {
timer.reset(item);
permutations.clear();
permutations.addAll(ItemInfo.getItemOverrides(item));
if(permutations.isEmpty()) {
try {
item.getSubItems(item, null, permutations);
} catch (Exception e) {
System.err.println("Removing itemID: " + item + " from list.");
e.printStackTrace();
erroredItems.add(item);
continue;
}
}
if(permutations.isEmpty()) {
HashSet<String> damageIconSet = new HashSet<String>();
for (int damage = 0; damage < 16; damage++) {
ItemStack itemstack = new ItemStack(item, 1, damage);
try {
IIcon icon = item.getIconIndex(itemstack);
String name = GuiContainerManager.concatenatedDisplayName(itemstack, false);
String s = name + "@" + (icon == null ? 0 : icon.hashCode());
if (!damageIconSet.contains(s)) {
damageIconSet.add(s);
permutations.add(itemstack);
}
if (permutations.isEmpty())
item.getSubItems(item, null, permutations);
} catch (Throwable t) {
StringWriter sw = new StringWriter();
t.printStackTrace(new PrintWriter(sw));
String stackTrace = itemstack + sw.toString();
if (!stackTraces.contains(stackTrace)) {
System.err.println("NEI: Omitting #" + this.item + ":" + damage + " " + item.getClass().getSimpleName());
t.printStackTrace();
stackTraces.add(stackTrace);
}
}
}
}
if (permutations.isEmpty())
damageSearch(item, permutations);
for(Iterator<ItemStack> it = permutations.iterator(); it.hasNext(); )
if(ItemInfo.isHidden(it.next()))
it.remove();
timer.reset();
items.addAll(permutations);
itemMap.putAll(item, permutations);
} catch (Throwable t) {
NEIServerConfig.logger.error("Removing item: " + item + " from list.", t);
erroredItems.add(item);
}
item = null;
/*DropDownFile dropDownInstance = DropDownFile.dropDownInstance;
dropDownInstance.resetHashes();
for(ItemStack stack : items)
{
if(reload)
{
reload = false;
continue startSearch;
}
dropDownInstance.addItemIfInRange(stack.getItem(), stack.getItemDamage(), stack.stackTagCompound);
}
dropDownInstance.updateState();*/
ItemList.items = items;
ItemList.itemMap = itemMap;
if (reload) {
reload = false;
continue;
}
loading = false;
} catch (TimeoutException e) {
System.err.println("Removing itemID: " + e.itemID + " from list.");
e.printStackTrace();
erroredItems.add(e.itemID);
}
ItemList.items = items;
ItemList.itemMap = itemMap;
for(ItemsLoadedCallback callback : loadCallbacks)
callback.itemsLoaded();
updateFilter();
}
updateSearch();
while (reload);
loading = false;
}
}
public static boolean isMatching() {
return matching;
public static class ThreadFilterItems extends Thread {
public ThreadFilterItems() {
super("NEI Item Filtering");
}
@Override
public void run() {
restart:
do {
refilter = false;
ArrayList<ItemStack> filtered = new ArrayList<ItemStack>();
List<ItemFilter> filters = getItemFilters();
for(ItemStack item : items) {
if(refilter)
continue restart;
if(itemMatches(item, filters))
filtered.add(item);
}
ItemSorter.sort(filtered);
ItemPanel.updateItemList(filtered);
}
while(refilter);
filtering = false;
}
}
public static void updateSearch() {
if (matching)
research = true;
else
new ThreadMatchSearch().start();
public static void updateFilter() {
if (filtering)
refilter = true;
else {
filtering = true;
new ThreadFilterItems().start();
}
}
public static void loadItems() {
if (loading)
reload = true;
else
else {
loading = true;
new ThreadLoadItems().start();
}
}
}