mirror of
https://github.com/GTNewHorizons/BloodMagic.git
synced 2026-11-17 19:05:02 +00:00
Misc. interconnected meteor loose ends and code cleanup (#66)
This commit is contained in:
1 parent
e629d04310
commit
7e607b4c58
15 files changed
+618
-510
No files matched your search
@@ -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();
|
||||
|
||||
@@ -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",
|
||||
|
||||
@@ -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<MeteorParadigmComponent> sortedComponents = new ArrayList<>(meteor.componentList);
|
||||
float totalComponentWeight = MeteorComponent.getTotalListWeight(meteor.ores);
|
||||
float fillerChance = meteor.fillerChance;
|
||||
List<MeteorComponent> 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<String> 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<String> 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<MeteorParadigmComponent> sortedFiller = new ArrayList<>(meteor.fillerList);
|
||||
List<MeteorComponent> 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<Reagent> reagents = component.getRequiredReagents();
|
||||
ArrayList<String> 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<MeteorParadigm> getSortedMeteors() {
|
||||
return MeteorRegistry.paradigmList.stream().sorted(Comparator.comparing(m -> m.cost))
|
||||
private List<Meteor> getSortedMeteors() {
|
||||
return MeteorRegistry.meteorList.stream().sorted(Comparator.comparing(m -> m.cost))
|
||||
.collect(Collectors.toList());
|
||||
}
|
||||
|
||||
|
||||
+3
-3
@@ -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);
|
||||
|
||||
@@ -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<MeteorComponent> ores;
|
||||
public List<MeteorComponent> 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<MeteorComponent> oreList,
|
||||
List<MeteorComponent> 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<Reagent> 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<MeteorComponent> oreList = removeBlocksMissingRequiredReagents(this.ores, reagents);
|
||||
List<MeteorComponent> 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<Reagent> reagents) {
|
||||
radius += MeteorReagentRegistry.getLargestRadiusIncrease(reagents);
|
||||
radius += MeteorReagentRegistry.getLargestRadiusDecrease(reagents);
|
||||
return Math.max(radius, 1);
|
||||
}
|
||||
|
||||
private float getNewFillerChance(float fillerChance, List<Reagent> 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<MeteorComponent> getNewFillerList(List<MeteorComponent> fillerList, List<Reagent> reagents) {
|
||||
List<MeteorComponent> reagentFillers = getFillerList(reagents);
|
||||
reagentFillers = removeBlocksMissingRequiredReagents(reagentFillers, reagents);
|
||||
if (!reagentFillers.isEmpty() && reagentFillers.get(0) != defaultMeteorBlock) {
|
||||
return reagentFillers;
|
||||
}
|
||||
return removeBlocksMissingRequiredReagents(fillerList, reagents);
|
||||
}
|
||||
|
||||
private List<MeteorComponent> removeBlocksMissingRequiredReagents(List<MeteorComponent> blockList,
|
||||
List<Reagent> reagents) {
|
||||
ArrayList<MeteorComponent> 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<MeteorComponent> 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;
|
||||
}
|
||||
}
|
||||
}
|
||||
+140
@@ -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> 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> reagent) {
|
||||
this.itemStack = stack;
|
||||
this.weight = weight;
|
||||
this.reagent = reagent;
|
||||
}
|
||||
|
||||
public static List<MeteorComponent> parseStringArray(String[] blockArray) {
|
||||
List<MeteorComponent> 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<Reagent> 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<Reagent> reagentList = MeteorReagent.parseReagents(reagent, blockName);
|
||||
|
||||
List<ItemStack> 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<MeteorComponent> blockList) {
|
||||
int totalWeight = 0;
|
||||
for (MeteorComponent component : blockList) {
|
||||
totalWeight += component.getWeight();
|
||||
}
|
||||
return totalWeight;
|
||||
}
|
||||
|
||||
public ItemStack getBlock() {
|
||||
return itemStack;
|
||||
}
|
||||
|
||||
public ArrayList<Reagent> getRequiredReagents() {
|
||||
return reagent;
|
||||
}
|
||||
|
||||
public boolean checkForReagent(List<Reagent> reagentList) {
|
||||
if (reagent.isEmpty()) {
|
||||
return true;
|
||||
}
|
||||
for (Reagent r1 : reagentList) {
|
||||
for (Reagent r2 : reagent) {
|
||||
if (r1.equals(r2)) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
}
|
||||
+20
@@ -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<MeteorComponent> {
|
||||
|
||||
@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.
|
||||
}
|
||||
}
|
||||
-236
@@ -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<MeteorParadigmComponent> componentList = new ArrayList<>();
|
||||
public List<MeteorParadigmComponent> 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<MeteorParadigmComponent> parseStringArray(String[] blockArray) {
|
||||
List<MeteorParadigmComponent> 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<Reagent> 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<Reagent> reagentList = getReagents(reagent, blockName);
|
||||
|
||||
List<ItemStack> 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<Reagent> getReagents(String reagent, String blockName) {
|
||||
ArrayList<Reagent> 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<MeteorParadigmComponent> 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<Reagent> 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<MeteorParadigmComponent> componentList = removeBlocksMissingRequiredReagents(this.componentList, reagents);
|
||||
List<MeteorParadigmComponent> 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<Reagent> reagents) {
|
||||
radius += MeteorReagentRegistry.getLargestRadiusIncrease(reagents);
|
||||
radius += MeteorReagentRegistry.getLargestRadiusDecrease(reagents);
|
||||
return Math.max(radius, 1);
|
||||
}
|
||||
|
||||
private int getNewFillerChance(int fillerChance, List<Reagent> 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<MeteorParadigmComponent> getNewFillerList(List<MeteorParadigmComponent> fillerList,
|
||||
List<Reagent> reagents) {
|
||||
List<MeteorParadigmComponent> reagentFillers = getFillerList(reagents);
|
||||
reagentFillers = removeBlocksMissingRequiredReagents(reagentFillers, reagents);
|
||||
if (!reagentFillers.isEmpty()) {
|
||||
return reagentFillers;
|
||||
}
|
||||
List<MeteorParadigmComponent> newFillers = removeBlocksMissingRequiredReagents(fillerList, reagents);
|
||||
if (newFillers.isEmpty()) { // Use the default if every filler requires a reagent
|
||||
newFillers.add(MeteorRegistry.getDefaultMeteorParadigmComponent());
|
||||
}
|
||||
return newFillers;
|
||||
}
|
||||
|
||||
private List<MeteorParadigmComponent> removeBlocksMissingRequiredReagents(List<MeteorParadigmComponent> blockList,
|
||||
List<Reagent> reagents) {
|
||||
ArrayList<MeteorParadigmComponent> 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<MeteorParadigmComponent> 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;
|
||||
}
|
||||
}
|
||||
}
|
||||
-51
@@ -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> reagent = new ArrayList<>();
|
||||
|
||||
public MeteorParadigmComponent(ItemStack stack, int weight) {
|
||||
this(stack, weight, new ArrayList<>());
|
||||
}
|
||||
|
||||
public MeteorParadigmComponent(ItemStack stack, int weight, ArrayList<Reagent> reagent) {
|
||||
this.itemStack = stack;
|
||||
this.weight = weight;
|
||||
this.reagent = reagent;
|
||||
}
|
||||
|
||||
public int getWeight() {
|
||||
return this.weight;
|
||||
}
|
||||
|
||||
public ItemStack getBlock() {
|
||||
return itemStack;
|
||||
}
|
||||
|
||||
public ArrayList<Reagent> getRequiredReagents() {
|
||||
return reagent;
|
||||
}
|
||||
|
||||
public boolean checkForReagent(List<Reagent> reagentList) {
|
||||
if (reagent.isEmpty()) {
|
||||
return true;
|
||||
}
|
||||
for (Reagent r1 : reagentList) {
|
||||
for (Reagent r2 : reagent) {
|
||||
if (r1.equals(r2)) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
}
|
||||
+21
-3
@@ -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<MeteorParadigmComponent> parsedFiller = new ArrayList<>();
|
||||
public float rawFillerChanceChange = 0;
|
||||
public List<MeteorComponent> filler = new ArrayList<>();
|
||||
|
||||
public static ArrayList<Reagent> parseReagents(String reagent, String blockName) {
|
||||
ArrayList<Reagent> 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;
|
||||
}
|
||||
}
|
||||
+43
-62
@@ -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<Reagent, MeteorReagent> 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<Reagent> 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<Reagent> 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<Reagent> 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<Reagent> 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<Reagent> 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<Reagent> 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<Reagent> 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<Reagent> 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<MeteorParadigmComponent> getFillerList(List<Reagent> reagentList) {
|
||||
List<MeteorParadigmComponent> fillerList = new ArrayList<>();
|
||||
/**
|
||||
* @return a list of the MeteorComponents that the given reagents will use to replace filler.
|
||||
*/
|
||||
public static List<MeteorComponent> getFillerList(List<Reagent> reagentList) {
|
||||
List<MeteorComponent> fillerList = new ArrayList<>();
|
||||
for (Reagent r : reagentList) {
|
||||
if (!reagents.containsKey(r)) {
|
||||
continue;
|
||||
}
|
||||
List<MeteorParadigmComponent> filler = reagents.get(r).parsedFiller;
|
||||
List<MeteorComponent> 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<Reagent> 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<Reagent> reagentList) {
|
||||
for (Reagent r : reagentList) {
|
||||
@@ -193,29 +199,4 @@ public class MeteorReagentRegistry {
|
||||
}
|
||||
return AlchemicalWizardry.doMeteorsDestroyBlocks;
|
||||
}
|
||||
|
||||
public static void generateDefaultConfig() {
|
||||
Map<String, String[]> 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();
|
||||
}
|
||||
}
|
||||
}
|
||||
+52
-30
@@ -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<MeteorParadigm> paradigmList = new ArrayList<>();
|
||||
public static List<Meteor> 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<Reagent> 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<MeteorComponent> componentList, int radius, int cost,
|
||||
List<MeteorComponent> 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<Reagent> 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;
|
||||
}
|
||||
}
|
||||
@@ -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<MeteorParadigm> itr = MeteorRegistry.paradigmList.iterator(); itr.hasNext();) {
|
||||
MeteorParadigm paradigm = itr.next();
|
||||
if (OreDictionary.itemMatches(paradigm.focusStack, focus, false)) {
|
||||
for (Iterator<Meteor> 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
|
||||
|
||||
Reference in new issue
Block a user