mirror of
https://github.com/HbmMods/Hbm-s-Nuclear-Tech-GIT.git
synced 2026-01-25 10:32:49 +00:00
263 lines
8.5 KiB
Java
263 lines
8.5 KiB
Java
package com.hbm.util;
|
|
|
|
import com.hbm.config.GeneralConfig;
|
|
import com.hbm.handler.HazmatRegistry;
|
|
import com.hbm.hazard.HazardRegistry;
|
|
import com.hbm.inventory.FluidContainer;
|
|
import com.hbm.inventory.FluidContainerRegistry;
|
|
import com.hbm.inventory.fluid.Fluids;
|
|
import com.hbm.main.MainRegistry;
|
|
import cpw.mods.fml.common.FMLCommonHandler;
|
|
import cpw.mods.fml.common.Loader;
|
|
import cpw.mods.fml.common.eventhandler.EventBus;
|
|
import cpw.mods.fml.common.eventhandler.IEventListener;
|
|
import cpw.mods.fml.relauncher.ReflectionHelper;
|
|
import net.minecraft.block.Block;
|
|
import net.minecraft.item.Item;
|
|
import net.minecraft.item.ItemStack;
|
|
import net.minecraft.nbt.NBTBase;
|
|
import net.minecraft.nbt.NBTTagCompound;
|
|
import net.minecraft.tileentity.TileEntity;
|
|
import net.minecraft.world.World;
|
|
|
|
import java.lang.reflect.Method;
|
|
import java.util.ArrayList;
|
|
import java.util.List;
|
|
import java.util.concurrent.ConcurrentHashMap;
|
|
|
|
public class Compat {
|
|
|
|
public static final String MOD_GT6 = "gregtech";
|
|
public static final String MOD_GCC = "GalacticraftCore";
|
|
public static final String MOD_AR = "advancedrocketry";
|
|
public static final String MOD_EF = "etfuturum";
|
|
public static final String MOD_REC = "ReactorCraft";
|
|
public static final String MOD_TIC = "TConstruct";
|
|
public static final String MOD_RC = "Railcraft";
|
|
public static final String MOD_TC = "tc";
|
|
public static final String MOD_EIDS = "endlessids";
|
|
public static final String MOD_ANG = "angelica";
|
|
|
|
public static Item tryLoadItem(String domain, String name) {
|
|
return (Item) Item.itemRegistry.getObject(getReg(domain, name));
|
|
}
|
|
|
|
public static Block tryLoadBlock(String domain, String name) {
|
|
return (Block) Block.blockRegistry.getObject(getReg(domain, name));
|
|
}
|
|
|
|
private static String getReg(String domain, String name) {
|
|
return domain + ":" + name;
|
|
}
|
|
|
|
public static ItemStack getPreferredOreOutput(List<ItemStack> oreList) {
|
|
int lowestPref = -1;
|
|
ItemStack preferredStack = null;
|
|
|
|
for(ItemStack item : oreList) {
|
|
String modid = ItemStackUtil.getModIdFromItemStack(item);
|
|
for(int i = 0; i < GeneralConfig.preferredOutputMod.length; i++) {
|
|
if (modid.equals(GeneralConfig.preferredOutputMod[i])){
|
|
if (lowestPref<0 || i <lowestPref) {
|
|
preferredStack = item;
|
|
lowestPref = i;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (preferredStack != null) {
|
|
return preferredStack.copy();
|
|
}
|
|
return oreList.get(0).copy();
|
|
}
|
|
|
|
public static boolean isModLoaded(String modid) {
|
|
return Loader.isModLoaded(modid);
|
|
}
|
|
|
|
public static enum ReikaIsotope {
|
|
C14(HazardRegistry.gen_10K),
|
|
U235(HazardRegistry.u235),
|
|
U238(HazardRegistry.u238),
|
|
Pu239(HazardRegistry.pu239),
|
|
Pu244(HazardRegistry.gen_100M),
|
|
Th232(HazardRegistry.th232),
|
|
Rn222(HazardRegistry.gen_10D),
|
|
Ra226(HazardRegistry.ra226),
|
|
Sr90(HazardRegistry.gen_10Y),
|
|
Po210(HazardRegistry.po210),
|
|
Cs134(HazardRegistry.gen_1Y),
|
|
Xe135(HazardRegistry.xe135),
|
|
Zr93(HazardRegistry.gen_1M),
|
|
Mo99(HazardRegistry.gen_10D),
|
|
Cs137(HazardRegistry.cs137),
|
|
Tc99(HazardRegistry.tc99),
|
|
I131(HazardRegistry.i131),
|
|
Pm147(HazardRegistry.gen_1Y),
|
|
I129(HazardRegistry.gen_10M),
|
|
Sm151(HazardRegistry.gen_100Y),
|
|
Ru106(HazardRegistry.gen_1Y),
|
|
Kr85(HazardRegistry.gen_10Y),
|
|
Pd107(HazardRegistry.gen_10M),
|
|
Se79(HazardRegistry.gen_100K),
|
|
Gd155(HazardRegistry.gen_1Y),
|
|
Sb125(HazardRegistry.gen_1Y),
|
|
Sn126(HazardRegistry.gen_100K),
|
|
Xe136(0),
|
|
I135(HazardRegistry.gen_H),
|
|
Xe131(HazardRegistry.gen_10D),
|
|
Ru103(HazardRegistry.gen_S),
|
|
Pm149(HazardRegistry.gen_10D),
|
|
Rh105(HazardRegistry.gen_H);
|
|
|
|
private float rads;
|
|
|
|
private ReikaIsotope(float rads) {
|
|
this.rads = rads;
|
|
}
|
|
|
|
public float getRad() {
|
|
return this.rads;
|
|
}
|
|
}
|
|
|
|
public static List<ItemStack> scrapeItemFromME(ItemStack meDrive) {
|
|
List<ItemStack> stacks = new ArrayList();
|
|
|
|
try {
|
|
if(meDrive != null && meDrive.hasTagCompound()) {
|
|
NBTTagCompound nbt = meDrive.getTagCompound();
|
|
int types = nbt.getShort("it"); //ITEM_TYPE_TAG
|
|
|
|
for(int i = 0; i < types; i++) {
|
|
NBTBase stackTag = nbt.getTag("#" + i);
|
|
|
|
if(stackTag instanceof NBTTagCompound) {
|
|
NBTTagCompound compound = (NBTTagCompound) stackTag;
|
|
ItemStack stack = ItemStack.loadItemStackFromNBT(compound);
|
|
|
|
int count = nbt.getInteger("@" + i);
|
|
stack.stackSize = count;
|
|
stacks.add(stack);
|
|
}
|
|
}
|
|
}
|
|
} catch(Exception ex) { }
|
|
|
|
return stacks;
|
|
}
|
|
|
|
public static void registerCompatHazmat() {
|
|
|
|
double helmet = 0.2D;
|
|
double chest = 0.4D;
|
|
double legs = 0.3D;
|
|
double boots = 0.1D;
|
|
|
|
double p90 = 1.0D; // 90%
|
|
double p99 = 2D; // 99%
|
|
|
|
tryRegisterHazmat(Compat.MOD_GT6, "gt.armor.hazmat.radiation.head", p90 * helmet);
|
|
tryRegisterHazmat(Compat.MOD_GT6, "gt.armor.hazmat.radiation.chest", p90 * chest);
|
|
tryRegisterHazmat(Compat.MOD_GT6, "gt.armor.hazmat.radiation.legs", p90 * legs);
|
|
tryRegisterHazmat(Compat.MOD_GT6, "gt.armor.hazmat.radiation.boots", p90 * boots);
|
|
|
|
tryRegisterHazmat(Compat.MOD_GT6, "gt.armor.hazmat.universal.head", p99 * helmet);
|
|
tryRegisterHazmat(Compat.MOD_GT6, "gt.armor.hazmat.universal.chest", p99 * chest);
|
|
tryRegisterHazmat(Compat.MOD_GT6, "gt.armor.hazmat.universal.legs", p99 * legs);
|
|
tryRegisterHazmat(Compat.MOD_GT6, "gt.armor.hazmat.universal.boots", p99 * boots);
|
|
|
|
tryRegisterHazmat(Compat.MOD_REC, "reactorcraft_item_hazhelmet", p99 * helmet);
|
|
tryRegisterHazmat(Compat.MOD_REC, "reactorcraft_item_hazchest", p99 * chest);
|
|
tryRegisterHazmat(Compat.MOD_REC, "reactorcraft_item_hazlegs", p99 * legs);
|
|
tryRegisterHazmat(Compat.MOD_REC, "reactorcraft_item_hazboots", p99 * boots);
|
|
|
|
tryRegisterHazmat(Compat.MOD_EF, "netherite_helmet", p90 * helmet);
|
|
tryRegisterHazmat(Compat.MOD_EF, "netherite_chestplate", p90 * chest);
|
|
tryRegisterHazmat(Compat.MOD_EF, "netherite_leggings", p90 * legs);
|
|
tryRegisterHazmat(Compat.MOD_EF, "netherite_boots", p90 * boots);
|
|
}
|
|
|
|
private static void tryRegisterHazmat(String mod, String name, double resistance) {
|
|
Item item = Compat.tryLoadItem(mod, name);
|
|
if(item != null) {
|
|
HazmatRegistry.registerHazmat(item, resistance);
|
|
}
|
|
}
|
|
|
|
public static void registerCompatFluidContainers() {
|
|
|
|
if(Compat.isModLoaded(Compat.MOD_TC) && GeneralConfig.enableFluidContainerCompat) {
|
|
Item canister = Compat.tryLoadItem(Compat.MOD_TC, "emptyCanister");
|
|
Item diesel = Compat.tryLoadItem(Compat.MOD_TC, "diesel");
|
|
if(diesel != null && canister != null) FluidContainerRegistry.registerContainer(new FluidContainer(new ItemStack(diesel), new ItemStack(canister), Fluids.DIESEL, 1000));
|
|
}
|
|
}
|
|
|
|
public static void handleRailcraftNonsense() {
|
|
|
|
if(!Loader.isModLoaded(MOD_RC)) return;
|
|
|
|
MainRegistry.logger.info("#######################################################");
|
|
MainRegistry.logger.info("| Railcraft detected, deploying anti-nonsense measures...");
|
|
|
|
try {
|
|
|
|
ConcurrentHashMap<Object, ArrayList<IEventListener>> listeners = ReflectionHelper.getPrivateValue(EventBus.class, FMLCommonHandler.instance().bus(), "listeners");
|
|
Object nonsense = null;
|
|
for(Object o : listeners.keySet()) {
|
|
if(o.getClass().getName().equals("mods.railcraft.common.blocks.hidden.TrailTicker")) {
|
|
MainRegistry.logger.info("| Found TrailTicker!");
|
|
nonsense = o;
|
|
break;
|
|
}
|
|
}
|
|
|
|
FMLCommonHandler.instance().bus().unregister(nonsense);
|
|
MainRegistry.logger.info("| Successfully removed Railcraft nonsense.");
|
|
|
|
} catch(Exception x) {
|
|
MainRegistry.logger.error("| Tried to remove Railcraft block but failed due to " + x.getMessage());
|
|
}
|
|
MainRegistry.logger.info("#######################################################");
|
|
}
|
|
|
|
public static Class getChunkBiomeHook() {
|
|
try {
|
|
return Class.forName("com.falsepattern.endlessids.mixin.helpers.ChunkBiomeHook");
|
|
} catch(ClassNotFoundException e) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public static Method getBiomeShortArray;
|
|
|
|
public static Method getBiomeShortArray() {
|
|
if(getBiomeShortArray != null) return getBiomeShortArray;
|
|
try {
|
|
Method m = getChunkBiomeHook().getDeclaredMethod("getBiomeShortArray");
|
|
getBiomeShortArray = m;
|
|
return m;
|
|
} catch(Exception e) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public static short[] getBiomeShortArray(Object instance) {
|
|
Method m = getBiomeShortArray();
|
|
if(m != null) {
|
|
try {
|
|
return (short[]) m.invoke(instance);
|
|
} catch(Exception e) { }
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/** A standard implementation of safely grabbing a tile entity without loading chunks, might have more fluff added to it later on. */
|
|
public static TileEntity getTileStandard(World world, int x, int y, int z) {
|
|
if(!world.getChunkProvider().chunkExists(x >> 4, z >> 4)) return null;
|
|
return world.getTileEntity(x, y, z);
|
|
}
|
|
}
|