diff --git a/src/main/java/WayofTime/alchemicalWizardry/AlchemicalWizardry.java b/src/main/java/WayofTime/alchemicalWizardry/AlchemicalWizardry.java index 430e5ef3..2a521d1f 100644 --- a/src/main/java/WayofTime/alchemicalWizardry/AlchemicalWizardry.java +++ b/src/main/java/WayofTime/alchemicalWizardry/AlchemicalWizardry.java @@ -250,8 +250,8 @@ import WayofTime.alchemicalWizardry.common.spell.simple.SpellTeleport; import WayofTime.alchemicalWizardry.common.spell.simple.SpellWateryGrave; import WayofTime.alchemicalWizardry.common.spell.simple.SpellWindGust; import WayofTime.alchemicalWizardry.common.summoning.SummoningHelperAW; -import WayofTime.alchemicalWizardry.common.summoning.meteor.Meteor; import WayofTime.alchemicalWizardry.common.summoning.meteor.MeteorReagentRegistry; +import WayofTime.alchemicalWizardry.common.summoning.meteor.MeteorRegistry; import WayofTime.alchemicalWizardry.common.tileEntity.TEAlchemicCalcinator; import WayofTime.alchemicalWizardry.common.tileEntity.TEAltar; import WayofTime.alchemicalWizardry.common.tileEntity.TEBellJar; @@ -308,6 +308,8 @@ public class AlchemicalWizardry { public static boolean parseTextFiles = false; + public static int defaultMeteorCost = 1000000; + public static String defaultMeteorBlock; public static boolean doMeteorsDestroyBlocks = true; public static String[] allowedCrushedOresArray; @@ -621,35 +623,12 @@ public class AlchemicalWizardry { @EventHandler public void preInit(FMLPreInitializationEvent event) { - File bmDirectory = new File("config/BloodMagic/schematics"); - if (!bmDirectory.exists() && bmDirectory.mkdirs()) { - try { - InputStream in = AlchemicalWizardry.class - .getResourceAsStream("/assets/alchemicalwizardry/schematics/building/buildings.zip"); - logger.info("none yet!"); - if (in != null) { - logger.info("I have found a zip!"); - ZipInputStream zipStream = new ZipInputStream(in); - ZipEntry entry; - - while ((entry = zipStream.getNextEntry()) != null) { - File file = new File(bmDirectory, entry.getName()); - if (file.exists() && file.length() > 3L) { - continue; - } - FileOutputStream out = new FileOutputStream(file); - - byte[] buffer = new byte[8192]; - int len; - while ((len = zipStream.read(buffer)) != -1) { - out.write(buffer, 0, len); - } - out.close(); - } - } - } catch (Exception e) {} - } + generateDefaultConfig( + "config/BloodMagic/schematics", + "/assets/alchemicalwizardry/schematics/building/buildings.zip"); + generateDefaultConfig("config/BloodMagic/meteors", "/assets/alchemicalwizardry/meteors/meteors.zip"); + generateDefaultConfig("config/BloodMagic/meteors/reagents", "/assets/alchemicalwizardry/meteors/reagents.zip"); TEDemonPortal.loadBuildingList(); @@ -708,6 +687,42 @@ public class AlchemicalWizardry { ModAchievements.init(); } + /** + * Attempt to generate default configs at the given destination using a zip located at the given source. + * + * @param destination The destination path for the config, starting inside .minecraft. + * @param source The source path for the config's zip, starting in src/main/resources/ + */ + private static void generateDefaultConfig(String destination, String source) { + File destinationDirectory = new File(destination); + if (!destinationDirectory.exists() && destinationDirectory.mkdirs()) { + try { + InputStream in = AlchemicalWizardry.class.getResourceAsStream(source); + logger.info("Attempting to load default config for {}", destinationDirectory); + if (in != null) { + logger.info("Unpacking zip found at {}", source); + ZipInputStream zipStream = new ZipInputStream(in); + ZipEntry entry; + + while ((entry = zipStream.getNextEntry()) != null) { + File file = new File(destinationDirectory, entry.getName()); + if (file.exists() && file.length() > 3L) { + continue; + } + FileOutputStream out = new FileOutputStream(file); + + byte[] buffer = new byte[8192]; + int len; + while ((len = zipStream.read(buffer)) != -1) { + out.write(buffer, 0, len); + } + out.close(); + } + } + } catch (Exception e) {} + } + } + @EventHandler public void load(FMLInitializationEvent event) { int craftingConstant = OreDictionary.WILDCARD_VALUE; @@ -3321,7 +3336,8 @@ public class AlchemicalWizardry { BloodMagicConfiguration.loadCustomLPValues(); DemonVillageLootRegistry.init(); - Meteor.loadConfig(); + + MeteorRegistry.loadConfig(); MeteorReagentRegistry.loadConfig(); this.initCompressionHandlers(); diff --git a/src/main/java/WayofTime/alchemicalWizardry/BloodMagicConfiguration.java b/src/main/java/WayofTime/alchemicalWizardry/BloodMagicConfiguration.java index 6619a480..5106abc6 100644 --- a/src/main/java/WayofTime/alchemicalWizardry/BloodMagicConfiguration.java +++ b/src/main/java/WayofTime/alchemicalWizardry/BloodMagicConfiguration.java @@ -29,6 +29,7 @@ import WayofTime.alchemicalWizardry.common.AlchemicalWizardryEventHooks; import WayofTime.alchemicalWizardry.common.demonVillage.DemonVillagePath; import WayofTime.alchemicalWizardry.common.demonVillage.tileEntity.TEDemonPortal; import WayofTime.alchemicalWizardry.common.items.armour.BoundArmour; +import WayofTime.alchemicalWizardry.common.summoning.meteor.MeteorComponent; import cpw.mods.fml.common.FMLCommonHandler; import cpw.mods.fml.common.registry.GameRegistry; import cpw.mods.fml.relauncher.Side; @@ -102,6 +103,23 @@ public class BloodMagicConfiguration { AlchemicalWizardry.doMeteorsDestroyBlocks = config.get("meteor", "doMeteorsDestroyBlocks", true) .getBoolean(true); + AlchemicalWizardry.defaultMeteorCost = config.getInt( + "defaultMeteorCost", + "meteor", + 1000000, + 0, + Integer.MAX_VALUE, + "The default LP cost to use for meteors if the \"cost\" property is not present in its config file.\n"); + AlchemicalWizardry.defaultMeteorBlock = config.getString( + "defaultMeteorBlock", + "meteor", + "", + "The block to use for filler in meteors if none is provided in the meteor's config file and " + + "that\nmeteor's fillerChance is greater than 0. Also used as a fallback for empty ore " + + "lists in meteor configs.\nSpecify the block with the " + + "format:\n\"modId:itemName:meta\"\nDefaults to minecraft:stone:0 if no block is provided or " + + "the provided block cannot be found."); + MeteorComponent.setDefaultMeteorBlock(); AlchemicalWizardry.allowedCrushedOresArray = config.get( "oreCrushing", "allowedOres", diff --git a/src/main/java/WayofTime/alchemicalWizardry/client/nei/NEIMeteorRecipeHandler.java b/src/main/java/WayofTime/alchemicalWizardry/client/nei/NEIMeteorRecipeHandler.java index caacb45a..ce857103 100644 --- a/src/main/java/WayofTime/alchemicalWizardry/client/nei/NEIMeteorRecipeHandler.java +++ b/src/main/java/WayofTime/alchemicalWizardry/client/nei/NEIMeteorRecipeHandler.java @@ -19,8 +19,8 @@ import org.lwjgl.opengl.GL11; import com.google.common.base.Joiner; import WayofTime.alchemicalWizardry.api.alchemy.energy.Reagent; -import WayofTime.alchemicalWizardry.common.summoning.meteor.MeteorParadigm; -import WayofTime.alchemicalWizardry.common.summoning.meteor.MeteorParadigmComponent; +import WayofTime.alchemicalWizardry.common.summoning.meteor.Meteor; +import WayofTime.alchemicalWizardry.common.summoning.meteor.MeteorComponent; import WayofTime.alchemicalWizardry.common.summoning.meteor.MeteorRegistry; import codechicken.lib.gui.GuiDraw; import codechicken.nei.NEIServerUtils; @@ -38,55 +38,56 @@ public class NEIMeteorRecipeHandler extends TemplateRecipeHandler { private final int radius; private Point focus; - public CachedMeteorRecipe(MeteorParadigm meteor, ItemStack focusStack) { - this.input.add(new PositionedStack(meteor.focusStack, 74, 4)); + public CachedMeteorRecipe(Meteor meteor, ItemStack focusStack) { + this.input.add(new PositionedStack(meteor.focusItem, 74, 4)); int row = 0; int col = 0; - float totalComponentWeight = meteor.getTotalListWeight(meteor.componentList); - int fillerChance = meteor.fillerChance; - List sortedComponents = new ArrayList<>(meteor.componentList); + float totalComponentWeight = MeteorComponent.getTotalListWeight(meteor.ores); + float fillerChance = meteor.fillerChance; + List sortedComponents = new ArrayList<>(meteor.ores); sortedComponents.sort(Comparator.comparingInt(c -> -c.getWeight())); float fillerRatio = (float) (fillerChance / 100.0); float componentRatio = 1 - fillerRatio; - for (MeteorParadigmComponent component : sortedComponents) { - ItemStack stack = component.getBlock(); - int xPos = 3 + 18 * col; - int yPos = 37 + 18 * row; + if (fillerChance < 100) { + for (MeteorComponent component : sortedComponents) { + ItemStack stack = component.getBlock(); + int xPos = 3 + 18 * col; + int yPos = 37 + 18 * row; - List tooltips = new ArrayList<>(); - float chance = component.getWeight() / totalComponentWeight * componentRatio; - tooltips.add(I18n.format("nei.recipe.meteor.chance", getFormattedChance(chance))); - tooltips.add(I18n.format("nei.recipe.meteor.amount", getEstimatedAmount(chance, meteor.radius))); - if (!component.getRequiredReagents().isEmpty()) { - tooltips.add(I18n.format("nei.recipe.meteor.reagent", getReagentStrings(component))); - } - this.outputs.add(new TooltipStack(stack, xPos, yPos, tooltips)); + List tooltips = new ArrayList<>(); + float chance = component.getWeight() / totalComponentWeight * componentRatio; + tooltips.add(I18n.format("nei.recipe.meteor.chance", getFormattedChance(chance))); + tooltips.add(I18n.format("nei.recipe.meteor.amount", getEstimatedAmount(chance, meteor.radius))); + if (!component.getRequiredReagents().isEmpty()) { + tooltips.add(I18n.format("nei.recipe.meteor.reagent", getReagentStrings(component))); + } + this.outputs.add(new TooltipStack(stack, xPos, yPos, tooltips)); - col++; - if (col > 8) { - col = 0; - row++; - } + col++; + if (col > 8) { + col = 0; + row++; + } - if (matchItem(focusStack, stack)) { - this.focus = new Point(xPos - 1, yPos - 1); + if (matchItem(focusStack, stack)) { + this.focus = new Point(xPos - 1, yPos - 1); + } } } - if (fillerChance > 0) { if (col != 0) { col = 0; row++; } - List sortedFiller = new ArrayList<>(meteor.fillerList); + List sortedFiller = new ArrayList<>(meteor.filler); sortedFiller.sort(Comparator.comparingInt(c -> -c.getWeight())); - float totalFillerWeight = meteor.getTotalListWeight(meteor.fillerList); + float totalFillerWeight = MeteorComponent.getTotalListWeight(meteor.filler); - for (MeteorParadigmComponent filler : sortedFiller) { + for (MeteorComponent filler : sortedFiller) { ItemStack stack = filler.getBlock(); int xPos = 3 + 18 * col; int yPos = 37 + 18 * row; @@ -117,7 +118,7 @@ public class NEIMeteorRecipeHandler extends TemplateRecipeHandler { this.cost = meteor.cost; } - private String getReagentStrings(MeteorParadigmComponent component) { + private String getReagentStrings(MeteorComponent component) { ArrayList reagents = component.getRequiredReagents(); ArrayList reagentNames = new ArrayList<>(); for (Reagent r : reagents) { @@ -158,7 +159,7 @@ public class NEIMeteorRecipeHandler extends TemplateRecipeHandler { @Override public void loadCraftingRecipes(String outputId, Object... results) { if (outputId.equals(getOverlayIdentifier()) && getClass() == NEIMeteorRecipeHandler.class) { - for (MeteorParadigm meteor : getSortedMeteors()) { + for (Meteor meteor : getSortedMeteors()) { arecipes.add(new CachedMeteorRecipe(meteor, null)); } } else { @@ -168,11 +169,11 @@ public class NEIMeteorRecipeHandler extends TemplateRecipeHandler { @Override public void loadCraftingRecipes(ItemStack result) { - for (MeteorParadigm meteor : getSortedMeteors()) { - if (meteor.componentList.stream().anyMatch(m -> matchItem(result, m.getBlock()))) { + for (Meteor meteor : getSortedMeteors()) { + if (meteor.ores.stream().anyMatch(m -> matchItem(result, m.getBlock()))) { arecipes.add(new CachedMeteorRecipe(meteor, result)); } - if (meteor.fillerList.stream().anyMatch(m -> matchItem(result, m.getBlock()))) { + if (meteor.filler.stream().anyMatch(m -> matchItem(result, m.getBlock()))) { arecipes.add(new CachedMeteorRecipe(meteor, result)); } } @@ -180,8 +181,8 @@ public class NEIMeteorRecipeHandler extends TemplateRecipeHandler { @Override public void loadUsageRecipes(ItemStack ingredient) { - for (MeteorParadigm meteor : getSortedMeteors()) { - if (matchItem(ingredient, meteor.focusStack)) { + for (Meteor meteor : getSortedMeteors()) { + if (matchItem(ingredient, meteor.focusItem)) { arecipes.add(new CachedMeteorRecipe(meteor, null)); } } @@ -255,8 +256,8 @@ public class NEIMeteorRecipeHandler extends TemplateRecipeHandler { return I18n.format("nei.recipe.meteor.category"); } - private List getSortedMeteors() { - return MeteorRegistry.paradigmList.stream().sorted(Comparator.comparing(m -> m.cost)) + private List getSortedMeteors() { + return MeteorRegistry.meteorList.stream().sorted(Comparator.comparing(m -> m.cost)) .collect(Collectors.toList()); } diff --git a/src/main/java/WayofTime/alchemicalWizardry/common/rituals/RitualEffectSummonMeteor.java b/src/main/java/WayofTime/alchemicalWizardry/common/rituals/RitualEffectSummonMeteor.java index ba888b3a..43d14960 100644 --- a/src/main/java/WayofTime/alchemicalWizardry/common/rituals/RitualEffectSummonMeteor.java +++ b/src/main/java/WayofTime/alchemicalWizardry/common/rituals/RitualEffectSummonMeteor.java @@ -44,9 +44,9 @@ public class RitualEffectSummonMeteor extends RitualEffect { if (entities == null) return; for (EntityItem entityItem : entities) { - if (entityItem != null && MeteorRegistry.isValidParadigmItem(entityItem.getEntityItem())) { - int meteorID = MeteorRegistry.getParadigmIDForItem(entityItem.getEntityItem()); - int cost = MeteorRegistry.paradigmList.get(meteorID).cost; + if (entityItem != null && MeteorRegistry.isValidMeteorFocusItem(entityItem.getEntityItem())) { + int meteorID = MeteorRegistry.getMeteorIDForItem(entityItem.getEntityItem()); + int cost = MeteorRegistry.meteorList.get(meteorID).cost; if (currentEssence < cost) { EntityPlayer entityOwner = SpellHelper.getPlayerForUsername(owner); diff --git a/src/main/java/WayofTime/alchemicalWizardry/common/summoning/meteor/Meteor.java b/src/main/java/WayofTime/alchemicalWizardry/common/summoning/meteor/Meteor.java index 6f298e0e..780f5924 100644 --- a/src/main/java/WayofTime/alchemicalWizardry/common/summoning/meteor/Meteor.java +++ b/src/main/java/WayofTime/alchemicalWizardry/common/summoning/meteor/Meteor.java @@ -1,60 +1,235 @@ package WayofTime.alchemicalWizardry.common.summoning.meteor; -import java.io.BufferedReader; -import java.io.File; -import java.io.FileNotFoundException; -import java.io.FileReader; +import static WayofTime.alchemicalWizardry.common.summoning.meteor.MeteorComponent.defaultMeteorBlock; +import static WayofTime.alchemicalWizardry.common.summoning.meteor.MeteorComponent.getTotalListWeight; +import static WayofTime.alchemicalWizardry.common.summoning.meteor.MeteorReagentRegistry.getFillerList; + +import java.util.ArrayList; +import java.util.List; +import java.util.Random; import net.minecraft.init.Items; +import net.minecraft.item.ItemBlock; import net.minecraft.item.ItemStack; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; -import com.google.gson.Gson; -import com.google.gson.GsonBuilder; -import com.google.gson.JsonSyntaxException; - +import WayofTime.alchemicalWizardry.AlchemicalWizardry; +import WayofTime.alchemicalWizardry.api.alchemy.energy.Reagent; +import cpw.mods.fml.common.Optional; import cpw.mods.fml.common.registry.GameRegistry; +import gregtech.common.blocks.TileEntityOres; public class Meteor { - public String[] ores; + public List ores; + public List filler; public int radius; public int cost; - public String focusModId; - public String focusName; - public int focusMeta; - private String[] filler; - private int fillerChance; + public float fillerChance; // Out of 100.0 + public transient ItemStack focusItem; + private String focusModId; + private String focusName; + private int focusMeta; + private int maxWeight; - public static void loadConfig() { - Gson gson = new GsonBuilder().setPrettyPrinting().create(); - File file = new File("config/BloodMagic/meteors"); - File[] files = file.listFiles(); - if (files != null) { - try { - for (File f : files) { - if (f.isDirectory()) { + public static Random rand = new Random(); + + public Meteor() { + this.radius = 1; + this.cost = AlchemicalWizardry.defaultMeteorCost; + this.fillerChance = 0; + this.maxWeight = 0; + this.preventNullLists(); + } + + public Meteor(ItemStack focusStack, int radius, int cost, int fillerChance, List oreList, + List fillerList) { + this.focusItem = focusStack; + this.radius = radius; + this.cost = cost; + this.fillerChance = fillerChance; + this.ores = oreList; + this.filler = fillerList; + } + + public void createMeteorImpact(World world, int x, int y, int z, List reagents) { + int radius = getNewRadius(this.radius, reagents); + float fillerChance = getNewFillerChance(this.fillerChance, reagents); + + if (MeteorReagentRegistry.doExplosions(reagents)) { + world.createExplosion(null, x, y, z, radius * 4, MeteorReagentRegistry.doMeteorsDestroyBlocks(reagents)); + } + + List oreList = removeBlocksMissingRequiredReagents(this.ores, reagents); + List fillerList = getNewFillerList(this.filler, reagents); + + int totalComponentWeight = MeteorComponent.getTotalListWeight(oreList); + int totalFillerWeight = MeteorComponent.getTotalListWeight(fillerList); + + for (int i = -radius; i <= radius; i++) { + for (int j = -radius; j <= radius; j++) { + for (int k = -radius; k <= radius; k++) { + if (i * i + j * j + k * k >= (radius + 0.50f) * (radius + 0.50f)) { continue; } - BufferedReader br = new BufferedReader(new FileReader(f)); - Meteor m = gson.fromJson(br, Meteor.class); - MeteorRegistry.registerMeteorParadigm( - findItemStack(m.focusModId, m.focusName, m.focusMeta), - m.ores, - m.radius, - m.cost, - m.filler, - m.fillerChance); + + if (!world.isAirBlock(x + i, y + j, z + k)) { + continue; + } + + if (fillerChance < 100 && (fillerChance <= 0 || world.rand.nextFloat() * 100 >= fillerChance)) { + setMeteorBlock(x + i, y + j, z + k, world, oreList, totalComponentWeight); + } else { + setMeteorBlock(x + i, y + j, z + k, world, fillerList, totalFillerWeight); + } } - } catch (FileNotFoundException | JsonSyntaxException e) { - e.printStackTrace(); } } } - private static ItemStack findItemStack(String modid, String name, int meta) { - ItemStack is = GameRegistry.findItemStack(modid, name, 1); - if (is == null) return null; - Items.feather.setDamage(is, meta); - return is; + private int getNewRadius(int radius, List reagents) { + radius += MeteorReagentRegistry.getLargestRadiusIncrease(reagents); + radius += MeteorReagentRegistry.getLargestRadiusDecrease(reagents); + return Math.max(radius, 1); + } + + private float getNewFillerChance(float fillerChance, List reagents) { + // Don't add filler to meteors that have none + if (fillerChance <= 0) { + return 0; + } + + float increase = MeteorReagentRegistry.getLargestFillerChanceIncrease(reagents); + float decrease = MeteorReagentRegistry.getLargestFillerChanceDecrease(reagents); + // Avoid division by zero + if (decrease == -100) { + return 0; + } + + fillerChance += MeteorReagentRegistry.getLargestRawFillerChanceIncrease(reagents); + fillerChance += MeteorReagentRegistry.getLargestRawFillerChanceDecrease(reagents); + if (increase > 0) { + fillerChance = 100 * (fillerChance + increase) / (100 + increase); + } else if (decrease < 0) { + fillerChance = 100 * (fillerChance + decrease) / (100 + decrease); + } + return Math.max(0, Math.min(fillerChance, 100)); + } + + /** + * @return a new filler list. The original list is entirely replaced if any of the supplied reagents have a filler + * config. + */ + private List getNewFillerList(List fillerList, List reagents) { + List reagentFillers = getFillerList(reagents); + reagentFillers = removeBlocksMissingRequiredReagents(reagentFillers, reagents); + if (!reagentFillers.isEmpty() && reagentFillers.get(0) != defaultMeteorBlock) { + return reagentFillers; + } + return removeBlocksMissingRequiredReagents(fillerList, reagents); + } + + private List removeBlocksMissingRequiredReagents(List blockList, + List reagents) { + ArrayList newList = new ArrayList<>(); + for (MeteorComponent component : blockList) { + if (component.checkForReagent(reagents)) { + newList.add(component); + } + } + if (newList.isEmpty()) { // Use the default if every filler requires a reagent + newList.add(defaultMeteorBlock); + } + return newList; + } + + /** + * Sets a randomly chosen block from blocklist according to the MeteorComponent weights at position x, y, z in the + * provided world. + */ + private void setMeteorBlock(int x, int y, int z, World world, List blockList, + int totalListWeight) { + int randNum = world.rand.nextInt(totalListWeight); + for (MeteorComponent component : blockList) { + randNum -= component.getWeight(); + + if (randNum < 0) { + ItemStack blockStack = component.getBlock(); + if (blockStack != null && blockStack.getItem() instanceof ItemBlock) { + ((ItemBlock) blockStack.getItem()) + .placeBlockAt(blockStack, null, world, x, y, z, 0, 0, 0, 0, blockStack.getItemDamage()); + if (AlchemicalWizardry.isGregTechLoaded) setGTOresNaturalIfNeeded(world, x, y, z); + world.markBlockForUpdate(x, y, z); + break; + } + } + } + } + + public void validate() { + this.preventNullLists(); + this.clampNumericalValues(); + this.buildFocusItem(); + this.maxWeightToFillerChance(); + } + + private void preventNullLists() { + if (ores == null || ores.isEmpty()) { + ores = new ArrayList<>(); + ores.add(defaultMeteorBlock); + } + while (ores.contains(null)) { + ores.remove(null); + } + if (filler == null || filler.isEmpty()) { + filler = new ArrayList<>(); + filler.add(defaultMeteorBlock); + } + while (filler.contains(null)) { + filler.remove(null); + } + } + + /** + * Clamps all numerical values to their minimum/maximum values. + */ + private void clampNumericalValues() { + radius = Math.max(1, radius); + cost = Math.max(0, cost); + fillerChance = Math.max(0f, Math.min(fillerChance, 100.0f)); + focusMeta = Math.max(0, focusMeta); + maxWeight = Math.max(0, maxWeight); + } + + /** + * Construct the focus item for this meteor from its modid, name, and metadata + */ + private void buildFocusItem() { + if (this.focusItem != null) return; + this.focusItem = GameRegistry.findItemStack(this.focusModId, this.focusName, 1); + if (this.focusItem == null) return; + Items.feather.setDamage(this.focusItem, this.focusMeta); + } + + /** + * Turn the maximum weight into an equivalent filler chance based on the provided block list. Does NOT restrict + * blocks over the max weight like the old weight system! Specify required reagents for the blocks you want to + * restrict in the ores tag for the meteor's config instead! This is used for the default meteors which include + * certain ores which may not be present in all environments. + */ + private void maxWeightToFillerChance() { + if (maxWeight <= 0 || fillerChance > 0) { + return; + } + this.fillerChance = Math.max(0f, Math.min(100f * (1 - ((float) getTotalListWeight(ores) / maxWeight)), 100.0f)); + } + + @Optional.Method(modid = "gregtech") + private static void setGTOresNaturalIfNeeded(World world, int x, int y, int z) { + final TileEntity tileEntity = world.getTileEntity(x, y, z); + if (tileEntity instanceof TileEntityOres) { + ((TileEntityOres) tileEntity).mNatural = true; + } } } diff --git a/src/main/java/WayofTime/alchemicalWizardry/common/summoning/meteor/MeteorComponent.java b/src/main/java/WayofTime/alchemicalWizardry/common/summoning/meteor/MeteorComponent.java new file mode 100644 index 00000000..4aa72e53 --- /dev/null +++ b/src/main/java/WayofTime/alchemicalWizardry/common/summoning/meteor/MeteorComponent.java @@ -0,0 +1,140 @@ +package WayofTime.alchemicalWizardry.common.summoning.meteor; + +import java.util.ArrayList; +import java.util.List; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +import net.minecraft.init.Blocks; +import net.minecraft.init.Items; +import net.minecraft.item.ItemBlock; +import net.minecraft.item.ItemStack; +import net.minecraftforge.oredict.OreDictionary; + +import WayofTime.alchemicalWizardry.AlchemicalWizardry; +import WayofTime.alchemicalWizardry.api.alchemy.energy.Reagent; +import cpw.mods.fml.common.registry.GameRegistry; + +public class MeteorComponent { + + private final int weight; + private final ItemStack itemStack; + private final ArrayList reagent; + public static MeteorComponent defaultMeteorBlock; + + public static void setDefaultMeteorBlock() { + String string = AlchemicalWizardry.defaultMeteorBlock; + String[] split = string.split(":"); + ItemStack stack = null; + if (!string.isEmpty() && split.length >= 3) { + stack = GameRegistry.findItemStack(split[0], split[1], 1); + } + if (stack != null) { + Items.feather.setDamage(stack, Integer.parseInt(split[2])); + } else { + stack = new ItemStack(Blocks.stone); + } + defaultMeteorBlock = new MeteorComponent(stack, 1); + } + + public MeteorComponent(ItemStack stack, int weight) { + this(stack, weight, new ArrayList<>()); + } + + public MeteorComponent(ItemStack stack, int weight, ArrayList reagent) { + this.itemStack = stack; + this.weight = weight; + this.reagent = reagent; + } + + public static List parseStringArray(String[] blockArray) { + List addList = new ArrayList<>(); + if (blockArray == null) { + return addList; + } + for (String blockName : blockArray) { + MeteorComponent component = parseString(blockName); + if (component != null) { + addList.add(component); + } + } + return addList; + } + + // modId:itemName:meta:weight(:reagent1, reagent2, ... optional) + private static final Pattern itemNamePattern = Pattern.compile("(.*):(.*):(\\d+):(\\d+)(:.*)?"); + // OREDICT:oreDictName:weight(:reagent1, reagent2, ... optional) + private static final Pattern oredictPattern = Pattern.compile("OREDICT:(.*):(\\d+)(:.*)?"); + + public static MeteorComponent parseString(String blockName) { + Matcher matcher = itemNamePattern.matcher(blockName); + if (matcher.matches()) { + String modID = matcher.group(1); + String itemName = matcher.group(2); + int meta = Integer.parseInt(matcher.group(3)); + int weight = Integer.parseInt(matcher.group(4)); + String reagent = matcher.group(5); + + ArrayList reagentList = MeteorReagent.parseReagents(reagent, blockName); + + ItemStack stack = GameRegistry.findItemStack(modID, itemName, 1); + if (stack != null && stack.getItem() instanceof ItemBlock) { + stack.setItemDamage(meta); + return new MeteorComponent(stack, weight, reagentList); + } + + } else if ((matcher = oredictPattern.matcher(blockName)).matches()) { + String oreDict = matcher.group(1); + int weight = Integer.parseInt(matcher.group(2)); + String reagent = matcher.group(3); + + ArrayList reagentList = MeteorReagent.parseReagents(reagent, blockName); + + List list = OreDictionary.getOres(oreDict); + for (ItemStack stack : list) { + if (stack != null && stack.getItem() instanceof ItemBlock) { + return new MeteorComponent(stack, weight, reagentList); + } + } + + } + AlchemicalWizardry.logger.warn("Unable to add Meteor Component \"{}\"", blockName); + AlchemicalWizardry.logger.warn( + "Valid formats are \"modId:itemName:meta:weight(:reagent1, reagent2, ... optional)\" and \"OREDICT:oreDictName:weight(:reagent1, reagent2, ... optional)\"."); + return null; + } + + public int getWeight() { + return this.weight; + } + + public static int getTotalListWeight(List blockList) { + int totalWeight = 0; + for (MeteorComponent component : blockList) { + totalWeight += component.getWeight(); + } + return totalWeight; + } + + public ItemStack getBlock() { + return itemStack; + } + + public ArrayList getRequiredReagents() { + return reagent; + } + + public boolean checkForReagent(List reagentList) { + if (reagent.isEmpty()) { + return true; + } + for (Reagent r1 : reagentList) { + for (Reagent r2 : reagent) { + if (r1.equals(r2)) { + return true; + } + } + } + return false; + } +} diff --git a/src/main/java/WayofTime/alchemicalWizardry/common/summoning/meteor/MeteorComponentAdapter.java b/src/main/java/WayofTime/alchemicalWizardry/common/summoning/meteor/MeteorComponentAdapter.java new file mode 100644 index 00000000..d477cbe4 --- /dev/null +++ b/src/main/java/WayofTime/alchemicalWizardry/common/summoning/meteor/MeteorComponentAdapter.java @@ -0,0 +1,20 @@ +package WayofTime.alchemicalWizardry.common.summoning.meteor; + +import java.io.IOException; + +import com.google.gson.TypeAdapter; +import com.google.gson.stream.JsonReader; +import com.google.gson.stream.JsonWriter; + +class MeteorComponentAdapter extends TypeAdapter { + + @Override + public MeteorComponent read(JsonReader reader) throws IOException { + return MeteorComponent.parseString(reader.nextString()); + } + + @Override + public void write(JsonWriter writer, MeteorComponent mpc) throws IOException { + // Not implemented because it is not needed. + } +} diff --git a/src/main/java/WayofTime/alchemicalWizardry/common/summoning/meteor/MeteorParadigm.java b/src/main/java/WayofTime/alchemicalWizardry/common/summoning/meteor/MeteorParadigm.java deleted file mode 100644 index dbe9178a..00000000 --- a/src/main/java/WayofTime/alchemicalWizardry/common/summoning/meteor/MeteorParadigm.java +++ /dev/null @@ -1,236 +0,0 @@ -package WayofTime.alchemicalWizardry.common.summoning.meteor; - -import static WayofTime.alchemicalWizardry.common.summoning.meteor.MeteorReagentRegistry.getFillerList; - -import java.util.ArrayList; -import java.util.List; -import java.util.Random; -import java.util.regex.Matcher; -import java.util.regex.Pattern; - -import net.minecraft.item.ItemBlock; -import net.minecraft.item.ItemStack; -import net.minecraft.tileentity.TileEntity; -import net.minecraft.world.World; -import net.minecraftforge.oredict.OreDictionary; - -import WayofTime.alchemicalWizardry.AlchemicalWizardry; -import WayofTime.alchemicalWizardry.api.alchemy.energy.Reagent; -import WayofTime.alchemicalWizardry.api.alchemy.energy.ReagentRegistry; -import cpw.mods.fml.common.Optional; -import cpw.mods.fml.common.registry.GameRegistry; -import gregtech.common.blocks.TileEntityOres; - -public class MeteorParadigm { - - public List componentList = new ArrayList<>(); - public List fillerList = new ArrayList<>(); - public ItemStack focusStack; - public int radius; - public int cost; - public int fillerChance; // Out of 100 - - public static Random rand = new Random(); - - public MeteorParadigm(ItemStack focusStack, int radius, int cost, int fillerChance) { - this.focusStack = focusStack; - this.radius = radius; - this.cost = cost; - this.fillerChance = fillerChance; - } - - // modId:itemName:meta:weight(:reagent1, reagent2, ... optional) - private static final Pattern itemNamePattern = Pattern.compile("(.*):(.*):(\\d+):(\\d+)(:.*)?"); - // OREDICT:oreDictName:weight(:reagent1, reagent2, ... optional) - private static final Pattern oredictPattern = Pattern.compile("OREDICT:(.*):(\\d+)(:.*)?"); - - public static List parseStringArray(String[] blockArray) { - List addList = new ArrayList<>(); - for (int i = 0; i < blockArray.length; ++i) { - String blockName = blockArray[i]; - boolean success = false; - - Matcher matcher = itemNamePattern.matcher(blockName); - if (matcher.matches()) { - String modID = matcher.group(1); - String itemName = matcher.group(2); - int meta = Integer.parseInt(matcher.group(3)); - int weight = Integer.parseInt(matcher.group(4)); - String reagent = matcher.group(5); - - ArrayList reagentList = getReagents(reagent, blockName); - - ItemStack stack = GameRegistry.findItemStack(modID, itemName, 1); - if (stack != null && stack.getItem() instanceof ItemBlock) { - stack.setItemDamage(meta); - addList.add(new MeteorParadigmComponent(stack, weight, reagentList)); - success = true; - } - - } else if ((matcher = oredictPattern.matcher(blockName)).matches()) { - String oreDict = matcher.group(1); - int weight = Integer.parseInt(matcher.group(2)); - String reagent = matcher.group(3); - - ArrayList reagentList = getReagents(reagent, blockName); - - List list = OreDictionary.getOres(oreDict); - for (ItemStack stack : list) { - if (stack != null && stack.getItem() instanceof ItemBlock) { - addList.add(new MeteorParadigmComponent(stack, weight, reagentList)); - success = true; - break; - } - } - - } - - if (!success) { - AlchemicalWizardry.logger.warn("Unable to add Meteor Paradigm \"{}\"", blockName); - AlchemicalWizardry.logger.warn( - "Valid formats are \"modId:itemName:meta:weight(:reagent1, reagent2, ... optional)\" and \"OREDICT:oreDictName:weight(:reagent1, reagent2, ... optional)\"."); - } - } - return addList; - } - - private static ArrayList getReagents(String reagent, String blockName) { - ArrayList reagentList = new ArrayList<>(); - if (reagent != null) { - String[] reagents = reagent.substring(1).split(", ?"); - for (String str : reagents) { - Reagent r = ReagentRegistry.getReagentForKey(str); - if (r == null) { - AlchemicalWizardry.logger.warn("Unable to add reagent \"{}\" for {}.", str, blockName); - continue; - } - reagentList.add(r); - } - } - return reagentList; - } - - public int getTotalListWeight(List blockList) { - int totalWeight = 0; - for (MeteorParadigmComponent mpc : blockList) { - totalWeight += mpc.getWeight(); - } - return totalWeight; - } - - public void createMeteorImpact(World world, int x, int y, int z, List reagents) { - int radius = getNewRadius(this.radius, reagents); - int fillerChance = getNewFillerChance(this.fillerChance, reagents); - - if (MeteorReagentRegistry.doExplosions(reagents)) { - world.createExplosion(null, x, y, z, radius * 4, MeteorReagentRegistry.doMeteorsDestroyBlocks(reagents)); - } - - List componentList = removeBlocksMissingRequiredReagents(this.componentList, reagents); - List fillerList = getNewFillerList(this.fillerList, reagents); - - int totalComponentWeight = getTotalListWeight(componentList); - int totalFillerWeight = getTotalListWeight(fillerList); - - for (int i = -radius; i <= radius; i++) { - for (int j = -radius; j <= radius; j++) { - for (int k = -radius; k <= radius; k++) { - if (i * i + j * j + k * k >= (radius + 0.50f) * (radius + 0.50f)) { - continue; - } - - if (!world.isAirBlock(x + i, y + j, z + k)) { - continue; - } - - if (fillerChance <= 0 || world.rand.nextInt(100) >= fillerChance) { - setMeteorBlock(x + i, y + j, z + k, world, componentList, totalComponentWeight); - } else { - setMeteorBlock(x + i, y + j, z + k, world, fillerList, totalFillerWeight); - } - } - } - } - } - - private int getNewRadius(int radius, List reagents) { - radius += MeteorReagentRegistry.getLargestRadiusIncrease(reagents); - radius += MeteorReagentRegistry.getLargestRadiusDecrease(reagents); - return Math.max(radius, 1); - } - - private int getNewFillerChance(int fillerChance, List reagents) { - // Don't add filler to meteors with none - if (fillerChance <= 0) { - return 0; - } - - int increase = MeteorReagentRegistry.getLargestFillerChanceIncrease(reagents); - int decrease = MeteorReagentRegistry.getLargestFillerChanceDecrease(reagents); - // Avoid division by zero - if (decrease == -100) { - return 0; - } - - fillerChance += MeteorReagentRegistry.getLargestRawFillerChanceIncrease(reagents); - fillerChance += MeteorReagentRegistry.getLargestRawFillerChanceDecrease(reagents); - if (increase > 0) { - fillerChance = (fillerChance + increase) * 100 / (100 + increase); - } else if (decrease < 0) { - fillerChance = (fillerChance + decrease) * 100 / (100 + decrease); - } - return Math.max(0, Math.min(fillerChance, 100)); - } - - private List getNewFillerList(List fillerList, - List reagents) { - List reagentFillers = getFillerList(reagents); - reagentFillers = removeBlocksMissingRequiredReagents(reagentFillers, reagents); - if (!reagentFillers.isEmpty()) { - return reagentFillers; - } - List newFillers = removeBlocksMissingRequiredReagents(fillerList, reagents); - if (newFillers.isEmpty()) { // Use the default if every filler requires a reagent - newFillers.add(MeteorRegistry.getDefaultMeteorParadigmComponent()); - } - return newFillers; - } - - private List removeBlocksMissingRequiredReagents(List blockList, - List reagents) { - ArrayList newList = new ArrayList<>(); - for (MeteorParadigmComponent mpc : blockList) { - if (mpc.checkForReagent(reagents)) { - newList.add(mpc); - } - } - return newList; - } - - private void setMeteorBlock(int x, int y, int z, World world, List blockList, - int totalListWeight) { - int randNum = world.rand.nextInt(totalListWeight); - for (MeteorParadigmComponent mpc : blockList) { - randNum -= mpc.getWeight(); - - if (randNum < 0) { - ItemStack blockStack = mpc.getBlock(); - if (blockStack != null && blockStack.getItem() instanceof ItemBlock) { - ((ItemBlock) blockStack.getItem()) - .placeBlockAt(blockStack, null, world, x, y, z, 0, 0, 0, 0, blockStack.getItemDamage()); - if (AlchemicalWizardry.isGregTechLoaded) setGTOresNaturalIfNeeded(world, x, y, z); - world.markBlockForUpdate(x, y, z); - break; - } - } - } - } - - @Optional.Method(modid = "gregtech") - private static void setGTOresNaturalIfNeeded(World world, int x, int y, int z) { - final TileEntity tileEntity = world.getTileEntity(x, y, z); - if (tileEntity instanceof TileEntityOres) { - ((TileEntityOres) tileEntity).mNatural = true; - } - } -} diff --git a/src/main/java/WayofTime/alchemicalWizardry/common/summoning/meteor/MeteorParadigmComponent.java b/src/main/java/WayofTime/alchemicalWizardry/common/summoning/meteor/MeteorParadigmComponent.java deleted file mode 100644 index 7ce5df25..00000000 --- a/src/main/java/WayofTime/alchemicalWizardry/common/summoning/meteor/MeteorParadigmComponent.java +++ /dev/null @@ -1,51 +0,0 @@ -package WayofTime.alchemicalWizardry.common.summoning.meteor; - -import java.util.ArrayList; -import java.util.List; - -import net.minecraft.item.ItemStack; - -import WayofTime.alchemicalWizardry.api.alchemy.energy.Reagent; - -public class MeteorParadigmComponent { - - protected int weight; - protected ItemStack itemStack; - protected ArrayList reagent = new ArrayList<>(); - - public MeteorParadigmComponent(ItemStack stack, int weight) { - this(stack, weight, new ArrayList<>()); - } - - public MeteorParadigmComponent(ItemStack stack, int weight, ArrayList reagent) { - this.itemStack = stack; - this.weight = weight; - this.reagent = reagent; - } - - public int getWeight() { - return this.weight; - } - - public ItemStack getBlock() { - return itemStack; - } - - public ArrayList getRequiredReagents() { - return reagent; - } - - public boolean checkForReagent(List reagentList) { - if (reagent.isEmpty()) { - return true; - } - for (Reagent r1 : reagentList) { - for (Reagent r2 : reagent) { - if (r1.equals(r2)) { - return true; - } - } - } - return false; - } -} diff --git a/src/main/java/WayofTime/alchemicalWizardry/common/summoning/meteor/MeteorReagent.java b/src/main/java/WayofTime/alchemicalWizardry/common/summoning/meteor/MeteorReagent.java index fc3344a6..44e592dd 100644 --- a/src/main/java/WayofTime/alchemicalWizardry/common/summoning/meteor/MeteorReagent.java +++ b/src/main/java/WayofTime/alchemicalWizardry/common/summoning/meteor/MeteorReagent.java @@ -3,14 +3,32 @@ package WayofTime.alchemicalWizardry.common.summoning.meteor; import java.util.ArrayList; import java.util.List; +import WayofTime.alchemicalWizardry.AlchemicalWizardry; +import WayofTime.alchemicalWizardry.api.alchemy.energy.Reagent; +import WayofTime.alchemicalWizardry.api.alchemy.energy.ReagentRegistry; + public class MeteorReagent { public boolean disableExplosions = false; public boolean invertExplosionBlockDamage = false; public int radiusChange = 0; public int fillerChanceChange = 0; - public int rawFillerChanceChange = 0; - public String[] filler = {}; - public transient List parsedFiller = new ArrayList<>(); + public float rawFillerChanceChange = 0; + public List filler = new ArrayList<>(); + public static ArrayList parseReagents(String reagent, String blockName) { + ArrayList reagentList = new ArrayList<>(); + if (reagent != null) { + String[] reagents = reagent.substring(1).split(", ?"); + for (String str : reagents) { + Reagent r = ReagentRegistry.getReagentForKey(str); + if (r == null) { + AlchemicalWizardry.logger.warn("Unable to add reagent \"{}\" for {}.", str, blockName); + continue; + } + reagentList.add(r); + } + } + return reagentList; + } } diff --git a/src/main/java/WayofTime/alchemicalWizardry/common/summoning/meteor/MeteorReagentRegistry.java b/src/main/java/WayofTime/alchemicalWizardry/common/summoning/meteor/MeteorReagentRegistry.java index 41d97f5f..798c4cf1 100644 --- a/src/main/java/WayofTime/alchemicalWizardry/common/summoning/meteor/MeteorReagentRegistry.java +++ b/src/main/java/WayofTime/alchemicalWizardry/common/summoning/meteor/MeteorReagentRegistry.java @@ -6,13 +6,7 @@ import java.io.BufferedReader; import java.io.File; import java.io.FileNotFoundException; import java.io.FileReader; -import java.io.IOException; -import java.nio.file.Files; -import java.nio.file.Path; -import java.nio.file.Paths; -import java.nio.file.StandardOpenOption; import java.util.ArrayList; -import java.util.Arrays; import java.util.HashMap; import java.util.List; import java.util.Map; @@ -30,15 +24,13 @@ public class MeteorReagentRegistry { public static Map reagents = new HashMap<>(); public static void loadConfig() { - Gson gson = new GsonBuilder().setPrettyPrinting().create(); + Gson gson = new GsonBuilder().setPrettyPrinting() + .registerTypeAdapter(MeteorComponent.class, new MeteorComponentAdapter()).create(); File file = new File("config/BloodMagic/meteors/reagents/"); - if (!file.isDirectory()) { - MeteorReagentRegistry.generateDefaultConfig(); - } File[] files = file.listFiles(); if (files != null) { - try { - for (String reagent : reagentList.keySet()) { + for (String reagent : reagentList.keySet()) { + try { File f = new File("config/BloodMagic/meteors/reagents/" + reagent + ".json"); if (!f.isFile()) { continue; @@ -48,18 +40,18 @@ public class MeteorReagentRegistry { if (r == null) { continue; } - if (r.filler.length > 0) { - r.parsedFiller = MeteorParadigm.parseStringArray(r.filler); - } reagents.put(ReagentRegistry.getReagentForKey(reagent), r); + } catch (FileNotFoundException | JsonSyntaxException e) { + AlchemicalWizardry.logger.warn("Error adding reagent {}", reagent); + e.printStackTrace(); } - } catch (FileNotFoundException | JsonSyntaxException e) { - e.printStackTrace(); } } } - // Returns the one largest radius increase (positive config). + /** + * @return the one largest radius increase from all given reagents (positive value in config). + */ public static int getLargestRadiusIncrease(List reagentList) { int increase = 0; for (Reagent r : reagentList) { @@ -74,7 +66,9 @@ public class MeteorReagentRegistry { return increase; } - // Returns the one largest radius decrease (negative config). + /** + * @return the one largest radius decrease from all given reagents (negative value in config). + */ public static int getLargestRadiusDecrease(List reagentList) { int decrease = 0; for (Reagent r : reagentList) { @@ -89,7 +83,9 @@ public class MeteorReagentRegistry { return decrease; } - // Returns the one largest filler chance increase (positive config). + /** + * @return the one largest filler chance increase from all given reagents (positive value in config). + */ public static int getLargestFillerChanceIncrease(List reagentList) { int increase = 0; for (Reagent r : reagentList) { @@ -104,7 +100,9 @@ public class MeteorReagentRegistry { return increase; } - // Returns the one largest filler chance decrease (negative config). + /** + * @return the one largest filler chance decrease from all given reagents (negative value in config). + */ public static int getLargestFillerChanceDecrease(List reagentList) { int decrease = 0; for (Reagent r : reagentList) { @@ -119,14 +117,16 @@ public class MeteorReagentRegistry { return decrease; } - // Returns the one largest raw filler chance increase (positive config). - public static int getLargestRawFillerChanceIncrease(List reagentList) { - int increase = 0; + /** + * @return the one largest raw filler chance increase from all given reagents (positive value in config). + */ + public static float getLargestRawFillerChanceIncrease(List reagentList) { + float increase = 0; for (Reagent r : reagentList) { if (!reagents.containsKey(r)) { continue; } - int change = reagents.get(r).rawFillerChanceChange; + float change = reagents.get(r).rawFillerChanceChange; if (change > increase) { increase = change; } @@ -134,14 +134,16 @@ public class MeteorReagentRegistry { return increase; } - // Returns the one largest raw filler chance decrease (negative config). - public static int getLargestRawFillerChanceDecrease(List reagentList) { - int decrease = 0; + /** + * @return the one largest raw filler chance decrease from all given reagents (negative value in config). + */ + public static float getLargestRawFillerChanceDecrease(List reagentList) { + float decrease = 0; for (Reagent r : reagentList) { if (!reagents.containsKey(r)) { continue; } - int change = reagents.get(r).rawFillerChanceChange; + float change = reagents.get(r).rawFillerChanceChange; if (change < decrease) { decrease = change; } @@ -149,14 +151,16 @@ public class MeteorReagentRegistry { return decrease; } - // Returns a list of the blocks that the given reagents will use to replace filler. - public static List getFillerList(List reagentList) { - List fillerList = new ArrayList<>(); + /** + * @return a list of the MeteorComponents that the given reagents will use to replace filler. + */ + public static List getFillerList(List reagentList) { + List fillerList = new ArrayList<>(); for (Reagent r : reagentList) { if (!reagents.containsKey(r)) { continue; } - List filler = reagents.get(r).parsedFiller; + List filler = reagents.get(r).filler; if (filler != null && !filler.isEmpty()) { fillerList.addAll(filler); } @@ -164,7 +168,9 @@ public class MeteorReagentRegistry { return fillerList; } - // Returns false if any of the given reagents disable explosions, otherwise true + /** + * @return false if any of the given reagents disable explosions, otherwise true + */ public static boolean doExplosions(List reagentList) { for (Reagent r : reagentList) { if (!reagents.containsKey(r)) { @@ -178,9 +184,9 @@ public class MeteorReagentRegistry { } /** - * Returns the value of the config AlchemicalWizardry.doMeteorsDestroyBlocks if no reagent inverts explosion block - * damage Returns the inverse of the value of AlchemicalWizardry.doMeteorsDestroyBlocks if any reagent inverts - * explosion block damage + * @return the value of the config AlchemicalWizardry.doMeteorsDestroyBlocks if no reagent inverts explosion block + * damage. If any reagent inverts explosion block damage, the inverse of the config + * AlchemicalWizardry.doMeteorsDestroyBlocks is returned. */ public static boolean doMeteorsDestroyBlocks(List reagentList) { for (Reagent r : reagentList) { @@ -193,29 +199,4 @@ public class MeteorReagentRegistry { } return AlchemicalWizardry.doMeteorsDestroyBlocks; } - - public static void generateDefaultConfig() { - Map lineMap = new HashMap<>(); - lineMap.put("terrae", new String[] { "{", " \"radiusChange\": 1,", " \"fillerChanceChange\": 10", "}", }); - lineMap.put( - "orbisTerrae", - new String[] { "{", " \"radiusChange\": 2,", " \"fillerChanceChange\": 20", "}", }); - lineMap.put("tenebrae", new String[] { "{", " \"filler\": [\"minecraft:obsidian:0:180\"]", "}", }); - lineMap.put( - "incendium", - new String[] { "{", " \"filler\": [", " \"minecraft:netherrack:0:60\",", - " \"minecraft:glowstone:0:60\",", " \"minecraft:soul_sand:0:60\"", " ]", "}", }); - lineMap.put("crystallos", new String[] { "{", " \"filler\": [\"minecraft:ice:0:180\"]", "}", }); - try { - Files.createDirectories(Paths.get("config/BloodMagic/meteors/reagents/")); - String[] reagents = { "terrae", "orbisTerrae", "tenebrae", "incendium", "crystallos" }; - for (String reagent : reagents) { - Path path = Paths.get("config/BloodMagic/meteors/reagents/" + reagent + ".json"); - Files.createFile(path); - Files.write(path, Arrays.asList(lineMap.get(reagent)), StandardOpenOption.WRITE); - } - } catch (IOException e) { - e.printStackTrace(); - } - } } diff --git a/src/main/java/WayofTime/alchemicalWizardry/common/summoning/meteor/MeteorRegistry.java b/src/main/java/WayofTime/alchemicalWizardry/common/summoning/meteor/MeteorRegistry.java index 1bfb3648..f8d545b9 100644 --- a/src/main/java/WayofTime/alchemicalWizardry/common/summoning/meteor/MeteorRegistry.java +++ b/src/main/java/WayofTime/alchemicalWizardry/common/summoning/meteor/MeteorRegistry.java @@ -1,58 +1,80 @@ package WayofTime.alchemicalWizardry.common.summoning.meteor; +import java.io.BufferedReader; +import java.io.File; +import java.io.FileNotFoundException; +import java.io.FileReader; import java.util.ArrayList; import java.util.List; -import net.minecraft.init.Blocks; import net.minecraft.item.ItemStack; import net.minecraft.world.World; import net.minecraftforge.oredict.OreDictionary; +import com.google.gson.Gson; +import com.google.gson.GsonBuilder; +import com.google.gson.JsonSyntaxException; + +import WayofTime.alchemicalWizardry.AlchemicalWizardry; import WayofTime.alchemicalWizardry.api.alchemy.energy.Reagent; public class MeteorRegistry { - public static List paradigmList = new ArrayList<>(); + public static List meteorList = new ArrayList<>(); - public static void registerMeteorParadigm(MeteorParadigm paradigm) { - paradigmList.add(paradigm); - } - - public static void registerMeteorParadigm(ItemStack stack, String[] componentList, int radius, int cost) { - registerMeteorParadigm(stack, componentList, radius, cost, null, 0); - } - - public static void registerMeteorParadigm(ItemStack stack, String[] componentList, int radius, int cost, - String[] fillerList, int fillerChance) { - if (stack != null && componentList != null) { - MeteorParadigm meteor = new MeteorParadigm(stack, radius, cost, fillerChance); - meteor.componentList = MeteorParadigm.parseStringArray(componentList); - if (fillerList != null && fillerList.length > 0) { - meteor.fillerList = MeteorParadigm.parseStringArray(fillerList); - } else { - meteor.fillerList.add(getDefaultMeteorParadigmComponent()); + public static void loadConfig() { + Gson gson = new GsonBuilder().setPrettyPrinting() + .registerTypeAdapter(MeteorComponent.class, new MeteorComponentAdapter()).create(); + File file = new File("config/BloodMagic/meteors"); + File[] files = file.listFiles(); + if (files != null) { + for (File f : files) { + try { + if (f.isDirectory() || !f.getName().endsWith(".json")) { + continue; + } + BufferedReader br = new BufferedReader(new FileReader(f)); + Meteor m = gson.fromJson(br, Meteor.class); + MeteorRegistry.registerMeteor(m); + } catch (FileNotFoundException | JsonSyntaxException e) { + AlchemicalWizardry.logger.warn("Error adding meteor {}", f.getName()); + e.printStackTrace(); + } } - paradigmList.add(meteor); } } - public static MeteorParadigmComponent getDefaultMeteorParadigmComponent() { - return new MeteorParadigmComponent(new ItemStack(Blocks.stone), 1); + public static void registerMeteor(Meteor meteor) { + meteor.validate(); + meteorList.add(meteor); } - public static void createMeteorImpact(World world, int x, int y, int z, int paradigmID, List reagents) { - if (paradigmID < paradigmList.size()) { - paradigmList.get(paradigmID).createMeteorImpact(world, x, y, z, reagents); + public static void registerMeteor(ItemStack stack, String[] componentList, int radius, int cost) { + registerMeteor(stack, MeteorComponent.parseStringArray(componentList), radius, cost, null, 0); + } + + public static void registerMeteor(ItemStack stack, List componentList, int radius, int cost, + List fillerList, int fillerChance) { + if (stack != null && componentList != null) { + Meteor meteor = new Meteor(stack, radius, cost, fillerChance, componentList, fillerList); + meteor.validate(); + meteorList.add(meteor); } } - public static int getParadigmIDForItem(ItemStack stack) { + public static void createMeteorImpact(World world, int x, int y, int z, int meteorID, List reagents) { + if (meteorID < meteorList.size()) { + meteorList.get(meteorID).createMeteorImpact(world, x, y, z, reagents); + } + } + + public static int getMeteorIDForItem(ItemStack stack) { if (stack == null) { return -1; } - for (int i = 0; i < paradigmList.size(); i++) { - ItemStack focusStack = paradigmList.get(i).focusStack; + for (int i = 0; i < meteorList.size(); i++) { + ItemStack focusStack = meteorList.get(i).focusItem; if (focusStack != null && focusStack.getItem() == stack.getItem() && (focusStack.getItemDamage() == OreDictionary.WILDCARD_VALUE @@ -64,7 +86,7 @@ public class MeteorRegistry { return -1; } - public static boolean isValidParadigmItem(ItemStack stack) { - return getParadigmIDForItem(stack) != -1; + public static boolean isValidMeteorFocusItem(ItemStack stack) { + return getMeteorIDForItem(stack) != -1; } } diff --git a/src/main/java/WayofTime/alchemicalWizardry/common/tweaker/FallingTower.java b/src/main/java/WayofTime/alchemicalWizardry/common/tweaker/FallingTower.java index 2c2ddcd1..9e78285f 100644 --- a/src/main/java/WayofTime/alchemicalWizardry/common/tweaker/FallingTower.java +++ b/src/main/java/WayofTime/alchemicalWizardry/common/tweaker/FallingTower.java @@ -7,7 +7,8 @@ import java.util.Iterator; import net.minecraft.item.ItemStack; import net.minecraftforge.oredict.OreDictionary; -import WayofTime.alchemicalWizardry.common.summoning.meteor.MeteorParadigm; +import WayofTime.alchemicalWizardry.common.summoning.meteor.Meteor; +import WayofTime.alchemicalWizardry.common.summoning.meteor.MeteorComponent; import WayofTime.alchemicalWizardry.common.summoning.meteor.MeteorRegistry; import minetweaker.IUndoableAction; import minetweaker.MineTweakerAPI; @@ -61,43 +62,46 @@ public class FallingTower { private static class Add implements IUndoableAction { - private MeteorParadigm paradigm; + private Meteor meteor; public Add(ItemStack stack, int radius, int cost, String[] components) { new Add(stack, radius, cost, components, null, 0); } public Add(ItemStack stack, int radius, int cost, String[] components, String[] filler, int fillerChance) { - paradigm = new MeteorParadigm(stack, radius, cost, fillerChance); - paradigm.componentList = MeteorParadigm.parseStringArray(components); - if (filler != null) { - paradigm.fillerList = MeteorParadigm.parseStringArray(filler); - } + meteor = new Meteor( + stack, + radius, + cost, + fillerChance, + MeteorComponent.parseStringArray(components), + MeteorComponent.parseStringArray(filler)); + meteor.validate(); } @Override public void apply() { - MeteorRegistry.registerMeteorParadigm(paradigm); + MeteorRegistry.registerMeteor(meteor); } @Override public boolean canUndo() { - return MeteorRegistry.paradigmList != null; + return MeteorRegistry.meteorList != null; } @Override public void undo() { - MeteorRegistry.paradigmList.remove(paradigm); + MeteorRegistry.meteorList.remove(meteor); } @Override public String describe() { - return "Adding Falling Tower Focus for " + paradigm.focusStack.getDisplayName(); + return "Adding Falling Tower Focus for " + meteor.focusItem.getDisplayName(); } @Override public String describeUndo() { - return "Removing Falling Tower Focus for " + paradigm.focusStack.getDisplayName(); + return "Removing Falling Tower Focus for " + meteor.focusItem.getDisplayName(); } @Override @@ -109,7 +113,7 @@ public class FallingTower { private static class Remove implements IUndoableAction { private final ItemStack focus; - private MeteorParadigm paradigm; + private Meteor paradigm; public Remove(ItemStack focus) { this.focus = focus; @@ -117,9 +121,9 @@ public class FallingTower { @Override public void apply() { - for (Iterator itr = MeteorRegistry.paradigmList.iterator(); itr.hasNext();) { - MeteorParadigm paradigm = itr.next(); - if (OreDictionary.itemMatches(paradigm.focusStack, focus, false)) { + for (Iterator itr = MeteorRegistry.meteorList.iterator(); itr.hasNext();) { + Meteor paradigm = itr.next(); + if (OreDictionary.itemMatches(paradigm.focusItem, focus, false)) { this.paradigm = paradigm; itr.remove(); break; @@ -129,12 +133,12 @@ public class FallingTower { @Override public boolean canUndo() { - return MeteorRegistry.paradigmList != null && paradigm != null; + return MeteorRegistry.meteorList != null && paradigm != null; } @Override public void undo() { - MeteorRegistry.paradigmList.add(paradigm); + MeteorRegistry.meteorList.add(paradigm); } @Override diff --git a/src/main/resources/assets/alchemicalwizardry/meteors/meteors.zip b/src/main/resources/assets/alchemicalwizardry/meteors/meteors.zip new file mode 100644 index 00000000..c21c564c Binary files /dev/null and b/src/main/resources/assets/alchemicalwizardry/meteors/meteors.zip differ diff --git a/src/main/resources/assets/alchemicalwizardry/meteors/reagents.zip b/src/main/resources/assets/alchemicalwizardry/meteors/reagents.zip new file mode 100644 index 00000000..8d8b02f0 Binary files /dev/null and b/src/main/resources/assets/alchemicalwizardry/meteors/reagents.zip differ