mirror of
https://github.com/KAMKEEL/CustomNPC-Plus.git
synced 2026-11-12 21:17:32 +00:00
388 lines
13 KiB
Java
388 lines
13 KiB
Java
package noppes.npcs.controllers;
|
|
|
|
import kamkeel.npcs.controllers.SyncController;
|
|
import net.minecraft.inventory.InventoryCrafting;
|
|
import net.minecraft.item.ItemStack;
|
|
import net.minecraft.item.crafting.CraftingManager;
|
|
import net.minecraft.nbt.CompressedStreamTools;
|
|
import net.minecraft.nbt.NBTTagCompound;
|
|
import net.minecraft.nbt.NBTTagList;
|
|
import noppes.npcs.CustomNpcs;
|
|
import noppes.npcs.api.handler.IRecipeHandler;
|
|
import noppes.npcs.api.handler.data.IAnvilRecipe;
|
|
import noppes.npcs.api.handler.data.IRecipe;
|
|
import noppes.npcs.controllers.data.RecipeAnvil;
|
|
import noppes.npcs.controllers.data.RecipeCarpentry;
|
|
import noppes.npcs.controllers.data.RecipeScript;
|
|
import noppes.npcs.controllers.data.RecipesDefault;
|
|
|
|
import java.io.File;
|
|
import java.io.FileInputStream;
|
|
import java.io.FileOutputStream;
|
|
import java.io.IOException;
|
|
import java.util.ArrayList;
|
|
import java.util.Collection;
|
|
import java.util.HashMap;
|
|
import java.util.HashSet;
|
|
import java.util.List;
|
|
|
|
public class RecipeController implements IRecipeHandler {
|
|
private static Collection<RecipeCarpentry> prevRecipes;
|
|
|
|
public HashMap<Integer, RecipeCarpentry> globalRecipes = new HashMap<Integer, RecipeCarpentry>();
|
|
public HashMap<Integer, RecipeCarpentry> carpentryRecipes = new HashMap<Integer, RecipeCarpentry>();
|
|
public HashMap<Integer, RecipeAnvil> anvilRecipes = new HashMap<Integer, RecipeAnvil>();
|
|
|
|
public HashMap<Integer, RecipeScript> carpentryScripts = new HashMap<>();
|
|
public HashMap<Integer, RecipeScript> anvilScripts = new HashMap<>();
|
|
|
|
public static RecipeController Instance;
|
|
|
|
public static final int version = 1;
|
|
public int nextId = 1;
|
|
public int nextAnvilId = 1;
|
|
|
|
public static HashMap<Integer, RecipeCarpentry> syncRecipes = new HashMap<Integer, RecipeCarpentry>();
|
|
public static HashMap<Integer, RecipeAnvil> syncAnvilRecipes = new HashMap<Integer, RecipeAnvil>();
|
|
|
|
public RecipeController() {
|
|
Instance = this;
|
|
}
|
|
|
|
public void load() {
|
|
loadCategories();
|
|
reloadGlobalRecipes(globalRecipes);
|
|
}
|
|
|
|
public static void reloadGlobalRecipes(HashMap<Integer, RecipeCarpentry> globalRecipes) {
|
|
List list = CraftingManager.getInstance().getRecipeList();
|
|
if (prevRecipes != null) {
|
|
list.removeAll(prevRecipes);
|
|
}
|
|
|
|
prevRecipes = new HashSet<RecipeCarpentry>();
|
|
for (RecipeCarpentry recipe : globalRecipes.values()) {
|
|
if (recipe.isValid())
|
|
prevRecipes.add(recipe);
|
|
}
|
|
list.addAll(prevRecipes);
|
|
}
|
|
|
|
private void loadCategories() {
|
|
File saveDir = CustomNpcs.getWorldSaveDirectory();
|
|
try {
|
|
File file = new File(saveDir, "recipes.dat");
|
|
if (file.exists()) {
|
|
loadCategories(file);
|
|
} else {
|
|
globalRecipes.clear();
|
|
carpentryRecipes.clear();
|
|
anvilRecipes.clear();
|
|
loadDefaultRecipes(-1);
|
|
}
|
|
} catch (Exception e) {
|
|
e.printStackTrace();
|
|
try {
|
|
File file = new File(saveDir, "recipes.dat_old");
|
|
if (file.exists()) {
|
|
loadCategories(file);
|
|
}
|
|
} catch (Exception ee) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
}
|
|
|
|
private void loadDefaultRecipes(int i) {
|
|
if (i == version)
|
|
return;
|
|
RecipesDefault.loadDefaultRecipes(i);
|
|
saveCategories();
|
|
}
|
|
|
|
private void loadCategories(File file) throws Exception {
|
|
NBTTagCompound nbttagcompound1;
|
|
try (FileInputStream fis = new FileInputStream(file)) {
|
|
nbttagcompound1 = CompressedStreamTools.readCompressed(fis);
|
|
}
|
|
nextId = nbttagcompound1.getInteger("LastId");
|
|
nextAnvilId = nbttagcompound1.getInteger("LastAnvilId");
|
|
NBTTagList list = nbttagcompound1.getTagList("Data", 10);
|
|
HashMap<Integer, RecipeCarpentry> globalRecipes = new HashMap<Integer, RecipeCarpentry>();
|
|
HashMap<Integer, RecipeCarpentry> carpentryRecipes = new HashMap<Integer, RecipeCarpentry>();
|
|
HashMap<Integer, RecipeAnvil> anvilRecipes = new HashMap<Integer, RecipeAnvil>();
|
|
if (list != null) {
|
|
for (int i = 0; i < list.tagCount(); i++) {
|
|
NBTTagCompound compound = list.getCompoundTagAt(i);
|
|
if (compound.hasKey("IsAnvil")) {
|
|
RecipeAnvil anvil = new RecipeAnvil();
|
|
anvil.readNBT(compound);
|
|
anvilRecipes.put(anvil.id, anvil);
|
|
if (anvil.id > nextAnvilId)
|
|
nextAnvilId = anvil.id;
|
|
} else {
|
|
RecipeCarpentry recipe = RecipeCarpentry.create(compound);
|
|
recipe.readNBT(compound);
|
|
if (recipe.isGlobal)
|
|
globalRecipes.put(recipe.id, recipe);
|
|
else
|
|
carpentryRecipes.put(recipe.id, recipe);
|
|
if (recipe.id > nextId)
|
|
nextId = recipe.id;
|
|
}
|
|
}
|
|
}
|
|
this.carpentryRecipes = carpentryRecipes;
|
|
this.globalRecipes = globalRecipes;
|
|
this.anvilRecipes = anvilRecipes;
|
|
loadDefaultRecipes(nbttagcompound1.getInteger("Version"));
|
|
}
|
|
|
|
private void saveCategories() {
|
|
try {
|
|
File saveDir = CustomNpcs.getWorldSaveDirectory();
|
|
NBTTagList list = new NBTTagList();
|
|
for (RecipeCarpentry recipe : globalRecipes.values()) {
|
|
list.appendTag(recipe.writeNBT(true));
|
|
}
|
|
for (RecipeCarpentry recipe : carpentryRecipes.values()) {
|
|
list.appendTag(recipe.writeNBT(true));
|
|
}
|
|
for (RecipeAnvil recipe : anvilRecipes.values()) {
|
|
list.appendTag(recipe.writeNBT(true));
|
|
}
|
|
NBTTagCompound nbttagcompound = new NBTTagCompound();
|
|
nbttagcompound.setTag("Data", list);
|
|
nbttagcompound.setInteger("LastId", nextId);
|
|
nbttagcompound.setInteger("LastAnvilId", nextAnvilId);
|
|
nbttagcompound.setInteger("Version", version);
|
|
File file = new File(saveDir, "recipes.dat_new");
|
|
File file1 = new File(saveDir, "recipes.dat_old");
|
|
File file2 = new File(saveDir, "recipes.dat");
|
|
CompressedStreamTools.writeCompressed(nbttagcompound, 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) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
|
|
public RecipeCarpentry findMatchingRecipe(InventoryCrafting par1InventoryCrafting) {
|
|
for (RecipeCarpentry recipe : carpentryRecipes.values()) {
|
|
if (recipe.isValid() && recipe.matches(par1InventoryCrafting, null))
|
|
return recipe;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public RecipeCarpentry getRecipe(int id) {
|
|
if (globalRecipes.containsKey(id))
|
|
return globalRecipes.get(id);
|
|
if (carpentryRecipes.containsKey(id))
|
|
return carpentryRecipes.get(id);
|
|
return null;
|
|
}
|
|
|
|
public RecipeAnvil getAnvilRecipe(int id) {
|
|
if (anvilRecipes.containsKey(id))
|
|
return anvilRecipes.get(id);
|
|
return null;
|
|
}
|
|
|
|
public RecipeCarpentry saveRecipe(NBTTagCompound compound) throws IOException {
|
|
RecipeCarpentry recipe = RecipeCarpentry.create(compound);
|
|
recipe.readNBT(compound);
|
|
|
|
RecipeCarpentry current = getRecipe(recipe.id);
|
|
if (current != null && !current.name.equals(recipe.name)) {
|
|
while (containsRecipeName(recipe.name))
|
|
recipe.name += "_";
|
|
}
|
|
|
|
if (recipe.id == -1) {
|
|
recipe.id = getUniqueId();
|
|
while (containsRecipeName(recipe.name))
|
|
recipe.name += "_";
|
|
}
|
|
if (recipe.isGlobal) {
|
|
carpentryRecipes.remove(recipe.id);
|
|
globalRecipes.put(recipe.id, recipe);
|
|
} else {
|
|
globalRecipes.remove(recipe.id);
|
|
carpentryRecipes.put(recipe.id, recipe);
|
|
}
|
|
saveCategories();
|
|
reloadGlobalRecipes(globalRecipes);
|
|
return recipe;
|
|
}
|
|
|
|
public RecipeAnvil saveAnvilRecipe(NBTTagCompound compound) throws IOException {
|
|
RecipeAnvil recipe = new RecipeAnvil();
|
|
recipe.readNBT(compound);
|
|
|
|
RecipeAnvil current = getAnvilRecipe(recipe.id);
|
|
if (current != null && !current.name.equals(recipe.name)) {
|
|
while (containsAnvilRecipeName(recipe.name))
|
|
recipe.name += "_";
|
|
}
|
|
|
|
if (recipe.id == -1) {
|
|
recipe.id = getUniqueAnvilId();
|
|
while (containsAnvilRecipeName(recipe.name))
|
|
recipe.name += "_";
|
|
}
|
|
|
|
anvilRecipes.put(recipe.id, recipe);
|
|
saveCategories();
|
|
return recipe;
|
|
}
|
|
|
|
private int getUniqueId() {
|
|
return nextId++;
|
|
}
|
|
|
|
private int getUniqueAnvilId() {
|
|
return nextAnvilId++;
|
|
}
|
|
|
|
private boolean containsRecipeName(String name) {
|
|
name = name.toLowerCase();
|
|
for (RecipeCarpentry recipe : globalRecipes.values()) {
|
|
if (recipe.name.toLowerCase().equals(name))
|
|
return true;
|
|
}
|
|
for (RecipeCarpentry recipe : carpentryRecipes.values()) {
|
|
if (recipe.name.toLowerCase().equals(name))
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private boolean containsAnvilRecipeName(String name) {
|
|
name = name.toLowerCase();
|
|
for (RecipeAnvil recipe : anvilRecipes.values()) {
|
|
if (recipe.name.toLowerCase().equals(name))
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public RecipeCarpentry delete(int id) {
|
|
RecipeCarpentry recipe = getRecipe(id);
|
|
if (recipe == null)
|
|
return null;
|
|
RecipeCarpentry globalRecipe = globalRecipes.remove(recipe.id);
|
|
if (globalRecipe != null)
|
|
SyncController.syncAllWorkbenchRecipes();
|
|
|
|
RecipeCarpentry carpentry = carpentryRecipes.remove(recipe.id);
|
|
if (carpentry != null) {
|
|
carpentryScripts.remove(recipe.id);
|
|
SyncController.syncAllCarpentryRecipes();
|
|
}
|
|
|
|
saveCategories();
|
|
reloadGlobalRecipes(globalRecipes);
|
|
return recipe;
|
|
}
|
|
|
|
public RecipeAnvil deleteAnvil(int id) {
|
|
RecipeAnvil recipe = getAnvilRecipe(id);
|
|
if (recipe == null)
|
|
return null;
|
|
|
|
RecipeAnvil anvilRecipe = anvilRecipes.remove(recipe.id);
|
|
if (anvilRecipe != null)
|
|
SyncController.syncAllAnvilRecipes();
|
|
|
|
saveCategories();
|
|
return recipe;
|
|
}
|
|
|
|
public void addRecipe(RecipeCarpentry recipeCarpentry) {
|
|
recipeCarpentry.id = getUniqueId();
|
|
if (!recipeCarpentry.isGlobal)
|
|
RecipeController.Instance.carpentryRecipes.put(recipeCarpentry.id, recipeCarpentry);
|
|
else {
|
|
RecipeController.Instance.globalRecipes.put(recipeCarpentry.id, recipeCarpentry);
|
|
}
|
|
}
|
|
|
|
public void addAnvilRecipe(RecipeAnvil recipeAnvil) {
|
|
recipeAnvil.id = getUniqueAnvilId();
|
|
anvilRecipes.put(recipeAnvil.id, recipeAnvil);
|
|
}
|
|
|
|
@Override
|
|
public List<IRecipe> getGlobalList() {
|
|
return new ArrayList(this.globalRecipes.values());
|
|
}
|
|
|
|
@Override
|
|
public List<IRecipe> getCarpentryList() {
|
|
return new ArrayList(this.carpentryRecipes.values());
|
|
}
|
|
|
|
@Override
|
|
public List<IAnvilRecipe> getAnvilList() {
|
|
List<IAnvilRecipe> list = new ArrayList<>();
|
|
list.addAll(anvilRecipes.values());
|
|
return list;
|
|
}
|
|
|
|
@Override
|
|
public void addRecipe(String name, boolean global, ItemStack result, Object... objects) {
|
|
RecipeCarpentry recipe = new RecipeCarpentry(name);
|
|
recipe.isGlobal = global;
|
|
recipe = RecipeCarpentry.saveRecipe(recipe, result, objects);
|
|
|
|
try {
|
|
this.saveRecipe(recipe.writeNBT(true));
|
|
} catch (Exception var7) {
|
|
var7.printStackTrace();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void addRecipe(String name, boolean global, ItemStack result, int width, int height, ItemStack... objects) {
|
|
ArrayList<ItemStack> list = new ArrayList<>();
|
|
int var9 = objects.length;
|
|
|
|
for (int var10 = 0; var10 < var9; ++var10) {
|
|
ItemStack item = objects[var10];
|
|
if (item.stackSize > 0) {
|
|
list.add(item);
|
|
}
|
|
}
|
|
|
|
RecipeCarpentry recipe = new RecipeCarpentry(width, height, list.toArray(new ItemStack[0]), result);
|
|
recipe.isGlobal = global;
|
|
recipe.name = name;
|
|
|
|
try {
|
|
this.saveRecipe(recipe.writeNBT(true));
|
|
} catch (IOException var12) {
|
|
var12.printStackTrace();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void addAnvilRecipe(String name, boolean global, ItemStack itemToRepair, ItemStack repairMaterial, int xpCost, float repairPercentage) {
|
|
RecipeAnvil recipe = new RecipeAnvil(name, itemToRepair, repairMaterial, xpCost, repairPercentage);
|
|
try {
|
|
this.saveAnvilRecipe(recipe.writeNBT(true));
|
|
} catch (Exception e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
}
|