mirror of
https://github.com/KAMKEEL/CustomNPC-Plus.git
synced 2026-11-12 18:57:32 +00:00
406 lines
13 KiB
Java
406 lines
13 KiB
Java
package noppes.npcs.controllers;
|
|
|
|
import net.minecraft.nbt.CompressedStreamTools;
|
|
import net.minecraft.nbt.NBTTagCompound;
|
|
import net.minecraft.nbt.NBTTagList;
|
|
import noppes.npcs.CustomNpcs;
|
|
import noppes.npcs.LogWriter;
|
|
import noppes.npcs.api.handler.ILinkedItemHandler;
|
|
import noppes.npcs.api.handler.data.ILinkedItem;
|
|
import noppes.npcs.api.item.IItemStack;
|
|
import noppes.npcs.controllers.data.IScriptHandler;
|
|
import noppes.npcs.controllers.data.LinkedItem;
|
|
import noppes.npcs.controllers.data.LinkedItemScript;
|
|
import noppes.npcs.util.NBTJsonUtil;
|
|
|
|
import java.io.BufferedInputStream;
|
|
import java.io.DataInputStream;
|
|
import java.io.File;
|
|
import java.io.FileInputStream;
|
|
import java.io.FileOutputStream;
|
|
import java.io.IOException;
|
|
import java.util.HashMap;
|
|
import java.util.HashSet;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.UUID;
|
|
import java.util.zip.GZIPInputStream;
|
|
|
|
public class LinkedItemController implements ILinkedItemHandler {
|
|
private static LinkedItemController Instance;
|
|
private int lastUsedID = 0;
|
|
|
|
public HashMap<Integer, LinkedItem> linkedItems = new HashMap<>();
|
|
public HashMap<Integer, LinkedItemScript> linkedItemsScripts = new HashMap<>();
|
|
|
|
private HashMap<Integer, String> bootOrder;
|
|
public CategoryManager categoryManager = new CategoryManager();
|
|
|
|
private LinkedItemController() {
|
|
}
|
|
|
|
public static LinkedItemController getInstance() {
|
|
if (Instance == null) {
|
|
Instance = new LinkedItemController();
|
|
}
|
|
return Instance;
|
|
}
|
|
|
|
@Override
|
|
public ILinkedItem createItem(String name) {
|
|
return new LinkedItem(name);
|
|
}
|
|
|
|
@Override
|
|
public IItemStack createItemStack(int id) {
|
|
LinkedItem linkedItem = (LinkedItem) this.get(id);
|
|
if (linkedItem != null) {
|
|
return linkedItem.createStack();
|
|
}
|
|
return null;
|
|
}
|
|
|
|
@Override
|
|
public void add(ILinkedItem linkedItem) {
|
|
if (linkedItem != null) {
|
|
String name = linkedItem.getName();
|
|
if (name != null && !name.isEmpty()) {
|
|
int linkedItemId = linkedItem.getId();
|
|
int id = this.linkedItems.containsKey(linkedItemId) ? linkedItemId : this.getUnusedId();
|
|
this.linkedItems.put(id, (LinkedItem) linkedItem);
|
|
linkedItem.setId(id);
|
|
this.addScript(id);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void addScript(int id) {
|
|
this.linkedItemsScripts.put(id, new LinkedItemScript());
|
|
}
|
|
|
|
@Override
|
|
public LinkedItem remove(int id) {
|
|
this.removeScript(id);
|
|
return this.linkedItems.remove(id);
|
|
}
|
|
|
|
private void removeScript(int id) {
|
|
this.linkedItemsScripts.remove(id);
|
|
}
|
|
|
|
@Override
|
|
public LinkedItem get(int id) {
|
|
return (LinkedItem) this.linkedItems.get(id);
|
|
}
|
|
|
|
@Override
|
|
public boolean contains(int id) {
|
|
return this.linkedItems.containsKey(id);
|
|
}
|
|
|
|
@Override
|
|
public boolean contains(ILinkedItem linkedItem) {
|
|
return this.linkedItems.containsValue((LinkedItem) linkedItem);
|
|
}
|
|
|
|
public IScriptHandler getScriptHandler(int id) {
|
|
return this.linkedItemsScripts.get(id);
|
|
}
|
|
|
|
/// /////////////////////////////////////////////////////
|
|
/// /////////////////////////////////////////////////////
|
|
|
|
public void load() {
|
|
lastUsedID = 0;
|
|
bootOrder = new HashMap<>();
|
|
linkedItems = new HashMap<>();
|
|
LogWriter.info("Loading linked items...");
|
|
readLinkedMap();
|
|
loadLinkedItems();
|
|
LogWriter.info("Done loading linked items.");
|
|
}
|
|
|
|
private void loadLinkedItems() {
|
|
linkedItems.clear();
|
|
|
|
File dir = getDir();
|
|
if (!dir.exists()) {
|
|
dir.mkdir();
|
|
return;
|
|
}
|
|
|
|
categoryManager.loadCategories(dir);
|
|
|
|
// Load uncategorized items (root level .json files)
|
|
loadItemsFromDir(dir, CategoryManager.UNCATEGORIZED_ID);
|
|
|
|
// Load categorized items (subdirectories)
|
|
for (Map.Entry<Integer, noppes.npcs.controllers.data.Category> entry : categoryManager.getCategories().entrySet()) {
|
|
File catDir = categoryManager.getCategoryDir(entry.getKey());
|
|
loadItemsFromDir(catDir, entry.getKey());
|
|
}
|
|
|
|
saveLinkedItemsMap();
|
|
}
|
|
|
|
private void loadItemsFromDir(File dir, int catId) {
|
|
File[] files = dir.listFiles();
|
|
if (files == null) return;
|
|
for (File file : files) {
|
|
if (!file.isFile() || !file.getName().endsWith(".json"))
|
|
continue;
|
|
try {
|
|
LinkedItem linkedItem = new LinkedItem();
|
|
linkedItem.readFromNBT(NBTJsonUtil.LoadFile(file));
|
|
linkedItem.name = file.getName().substring(0, file.getName().length() - 5);
|
|
|
|
if (linkedItem.id == -1) {
|
|
linkedItem.id = getUnusedId();
|
|
}
|
|
|
|
int originalID = linkedItem.id;
|
|
int setID = linkedItem.id;
|
|
while (bootOrder.containsKey(setID) || linkedItems.containsKey(setID)) {
|
|
if (bootOrder.containsKey(setID))
|
|
if (bootOrder.get(setID).equals(linkedItem.name))
|
|
break;
|
|
|
|
setID++;
|
|
}
|
|
|
|
linkedItem.id = setID;
|
|
if (originalID != setID) {
|
|
LogWriter.info("Found Linked Item ID Mismatch: " + linkedItem.name + ", New ID: " + setID);
|
|
linkedItem.save();
|
|
}
|
|
|
|
linkedItems.put(linkedItem.id, linkedItem);
|
|
categoryManager.registerItem(linkedItem.id, catId);
|
|
} catch (Exception e) {
|
|
LogWriter.error("Error loading: " + file.getAbsolutePath(), e);
|
|
}
|
|
}
|
|
}
|
|
|
|
private File getDir() {
|
|
return new File(CustomNpcs.getWorldSaveDirectory(), "linkeditems");
|
|
}
|
|
|
|
public int getUnusedId() {
|
|
if (lastUsedID == 0) {
|
|
for (int catid : linkedItems.keySet()) {
|
|
if (catid > lastUsedID)
|
|
lastUsedID = catid;
|
|
}
|
|
|
|
}
|
|
lastUsedID++;
|
|
return lastUsedID;
|
|
}
|
|
|
|
public boolean hasName(String newName) {
|
|
if (newName.trim().isEmpty())
|
|
return true;
|
|
for (LinkedItem linkedItem : linkedItems.values())
|
|
if (linkedItem.name.equals(newName))
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
public ILinkedItem saveLinkedItem(ILinkedItem linkedItem) {
|
|
if (linkedItem.getId() < 0) {
|
|
linkedItem.setId(getUnusedId());
|
|
while (hasName(linkedItem.getName()))
|
|
linkedItem.setName(linkedItem.getName() + "_");
|
|
}
|
|
|
|
while (hasOther(linkedItem.getName(), linkedItem.getId()))
|
|
linkedItem.setName(linkedItem.getName() + "_");
|
|
|
|
TagController.validateTagUUIDs(((LinkedItem) linkedItem).tagUUIDs);
|
|
linkedItems.remove(linkedItem.getId());
|
|
linkedItems.put(linkedItem.getId(), (LinkedItem) linkedItem);
|
|
saveLinkedItemsMap();
|
|
|
|
// Save Linked Item File
|
|
File dir = categoryManager.getItemDir(linkedItem.getId());
|
|
if (!dir.exists())
|
|
dir.mkdirs();
|
|
|
|
File file = new File(dir, linkedItem.getName() + ".json_new");
|
|
File file2 = new File(dir, linkedItem.getName() + ".json");
|
|
|
|
try {
|
|
NBTJsonUtil.SaveFile(file, ((LinkedItem) linkedItem).writeToNBT(true));
|
|
if (file2.exists())
|
|
file2.delete();
|
|
file.renameTo(file2);
|
|
} catch (Exception e) {
|
|
LogWriter.except(e);
|
|
}
|
|
return linkedItems.get(linkedItem.getId());
|
|
}
|
|
|
|
private boolean hasOther(String name, int id) {
|
|
for (LinkedItem linkedItem : linkedItems.values()) {
|
|
if (linkedItem.getId() != id && linkedItem.getName().equalsIgnoreCase(name))
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public void delete(int id) {
|
|
LinkedItem linkedItem = (LinkedItem) get(id);
|
|
if (linkedItem != null) {
|
|
LinkedItem foundItem = remove(id);
|
|
if (foundItem != null && foundItem.name != null) {
|
|
File dir = categoryManager.getItemDir(id);
|
|
File file = new File(dir, foundItem.name + ".json");
|
|
if (file.exists()) {
|
|
file.delete();
|
|
}
|
|
categoryManager.removeItem(id);
|
|
saveLinkedItemsMap();
|
|
}
|
|
}
|
|
}
|
|
|
|
public void deleteLinkedItemFile(String prevName) {
|
|
categoryManager.deleteFile(prevName + ".json");
|
|
}
|
|
|
|
|
|
/// /////////////////////////////////////////////////////
|
|
/// /////////////////////////////////////////////////////
|
|
// LINKED ITEMS MAP
|
|
public File getMapDir() {
|
|
File dir = CustomNpcs.getWorldSaveDirectory();
|
|
if (!dir.exists())
|
|
dir.mkdir();
|
|
return dir;
|
|
}
|
|
|
|
public void readLinkedMap() {
|
|
bootOrder.clear();
|
|
|
|
try {
|
|
File file = new File(getMapDir(), "linkeditems.dat");
|
|
if (file.exists()) {
|
|
loadLinkedMap(file);
|
|
}
|
|
} catch (Exception e) {
|
|
try {
|
|
File file = new File(getMapDir(), "linkeditems.dat_old");
|
|
if (file.exists()) {
|
|
loadLinkedMap(file);
|
|
}
|
|
} catch (Exception ignored) {
|
|
}
|
|
}
|
|
}
|
|
|
|
public NBTTagCompound writeMapNBT() {
|
|
NBTTagCompound nbt = new NBTTagCompound();
|
|
NBTTagList linkedList = new NBTTagList();
|
|
for (Integer key : linkedItems.keySet()) {
|
|
LinkedItem linkedItem = linkedItems.get(key);
|
|
if (!linkedItem.getName().isEmpty()) {
|
|
NBTTagCompound linkedCompound = new NBTTagCompound();
|
|
linkedCompound.setString("Name", linkedItem.getName());
|
|
linkedCompound.setInteger("ID", key);
|
|
|
|
linkedList.appendTag(linkedCompound);
|
|
}
|
|
}
|
|
nbt.setTag("LinkedItems", linkedList);
|
|
nbt.setInteger("lastID", lastUsedID);
|
|
return nbt;
|
|
}
|
|
|
|
public void readMapNBT(NBTTagCompound compound) {
|
|
lastUsedID = compound.getInteger("lastID");
|
|
NBTTagList list = compound.getTagList("LinkedItems", 10);
|
|
if (list != null) {
|
|
for (int i = 0; i < list.tagCount(); i++) {
|
|
NBTTagCompound nbttagcompound = list.getCompoundTagAt(i);
|
|
String linkedName = nbttagcompound.getString("Name");
|
|
Integer key = nbttagcompound.getInteger("ID");
|
|
bootOrder.put(key, linkedName);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void loadLinkedMap(File file) throws IOException {
|
|
DataInputStream var1 = new DataInputStream(new BufferedInputStream(new GZIPInputStream(new FileInputStream(file))));
|
|
readLinkedMap(var1);
|
|
var1.close();
|
|
}
|
|
|
|
public void readLinkedMap(DataInputStream stream) throws IOException {
|
|
NBTTagCompound nbtCompound = CompressedStreamTools.read(stream);
|
|
this.readMapNBT(nbtCompound);
|
|
}
|
|
|
|
public void saveLinkedItemsMap() {
|
|
try {
|
|
File saveDir = getMapDir();
|
|
File file = new File(saveDir, "linkeditems.dat_new");
|
|
File file1 = new File(saveDir, "linkeditems.dat_old");
|
|
File file2 = new File(saveDir, "linkeditems.dat");
|
|
CompressedStreamTools.writeCompressed(this.writeMapNBT(), new FileOutputStream(file));
|
|
if (file1.exists()) {
|
|
file1.delete();
|
|
}
|
|
file2.renameTo(file1);
|
|
if (file2.exists()) {
|
|
file2.delete();
|
|
}
|
|
file.renameTo(file2);
|
|
if (file.exists()) {
|
|
file.delete();
|
|
}
|
|
} catch (Exception e) {
|
|
LogWriter.except(e);
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////
|
|
// CATEGORY HELPERS
|
|
////////////////////////////////////////////////////////
|
|
|
|
public Map<String, Integer> getCategoryScrollData() {
|
|
return categoryManager.getCategoryScrollData();
|
|
}
|
|
|
|
public void moveItemToCategory(int itemId, int catId) {
|
|
LinkedItem item = linkedItems.get(itemId);
|
|
if (item == null) return;
|
|
categoryManager.moveItem(itemId, item.name + ".json", catId);
|
|
saveLinkedItemsMap();
|
|
}
|
|
|
|
public Map<String, Integer> getItemsByCategoryScrollData(int catId) {
|
|
Map<String, Integer> map = new HashMap<>();
|
|
List<Integer> itemIds = categoryManager.getItemsInCategory(catId, linkedItems.keySet());
|
|
for (int itemId : itemIds) {
|
|
LinkedItem item = linkedItems.get(itemId);
|
|
if (item != null) {
|
|
map.put(item.name, item.id);
|
|
}
|
|
}
|
|
return map;
|
|
}
|
|
|
|
public HashMap<String, HashSet<UUID>> getItemTagMapForCategory(int catId) {
|
|
HashMap<String, HashSet<UUID>> tagMap = new HashMap<>();
|
|
List<Integer> itemIds = categoryManager.getItemsInCategory(catId, linkedItems.keySet());
|
|
for (int itemId : itemIds) {
|
|
LinkedItem item = linkedItems.get(itemId);
|
|
if (item != null && !item.tagUUIDs.isEmpty()) {
|
|
tagMap.put(item.name, item.tagUUIDs);
|
|
}
|
|
}
|
|
return tagMap;
|
|
}
|
|
}
|