diff --git a/.gitignore b/.gitignore index 8d16946..b629d71 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,7 @@ +bin +.classpath +.project +.settings .gradle .idea build diff --git a/build.gradle b/build.gradle index ee53ffc..6c93b29 100644 --- a/build.gradle +++ b/build.gradle @@ -17,6 +17,9 @@ buildscript { apply plugin: 'forge' +sourceCompatibility = JavaVersion.VERSION_1_8 +targetCompatibility = JavaVersion.VERSION_1_8 + version = "1.0" group= "modgroup" archivesBaseName = "modid" diff --git a/src/main/java/atomicscience/AtomicScience.java b/src/main/java/atomicscience/AtomicScience.java new file mode 100644 index 0000000..af5a540 --- /dev/null +++ b/src/main/java/atomicscience/AtomicScience.java @@ -0,0 +1,675 @@ +package atomicscience; + +import atomicscience.api.BlockRadioactive; +import atomicscience.api.ISteamReceptor; +import atomicscience.api.Plasma; +import atomicscience.api.poison.PoisonRadiation; +import atomicscience.api.poison.PotionRadiation; +import atomicscience.fanwusu.BAccelerator; +import atomicscience.fanwusu.BFulminationGenerator; +import atomicscience.fanwusu.EMatter; +import atomicscience.fanwusu.FulminationEventHandler; +import atomicscience.fanwusu.ItAntimatterCell; +import atomicscience.fanwusu.TAccelerator; +import atomicscience.fanwusu.TFulminationGenerator; +import atomicscience.fenlie.BCentrifuge; +import atomicscience.fenlie.BControlRod; +import atomicscience.fenlie.BFissionReactor; +import atomicscience.fenlie.BNuclearBoiler; +import atomicscience.fenlie.BReactorTap; +import atomicscience.fenlie.BSiren; +import atomicscience.fenlie.BUraniumOre; +import atomicscience.fenlie.ItRadioactive; +import atomicscience.fenlie.ItStrangeMatter; +import atomicscience.fenlie.ItUranium; +import atomicscience.fenlie.TCentrifuge; +import atomicscience.fenlie.TFissionReactor; +import atomicscience.fenlie.TNuclearBoiler; +import atomicscience.fenlie.TReactorTap; +import atomicscience.hecheng.BElectromagnet; +import atomicscience.hecheng.BElectromagnetGlass; +import atomicscience.hecheng.BFusionReactor; +import atomicscience.hecheng.BPlasma; +import atomicscience.hecheng.IBAccelerator; +import atomicscience.hecheng.IBPlasma; +import atomicscience.hecheng.IBSiren; +import atomicscience.hecheng.TElectromagnet; +import atomicscience.hecheng.TFusionReactor; +import atomicscience.jiqi.BChemicalExtractor; +import atomicscience.jiqi.BFunnel; +import atomicscience.jiqi.BThermometer; +import atomicscience.jiqi.BTurbine; +import atomicscience.jiqi.ItHazmatSuite; +import atomicscience.jiqi.ItThermometer; +import atomicscience.jiqi.TChemicalExtractor; +import atomicscience.jiqi.TFunnel; +import atomicscience.jiqi.TThermometer; +import atomicscience.jiqi.TTurbine; +import atomicscience.wujian.ItBreederFuel; +import atomicscience.wujian.ItCell; +import atomicscience.wujian.ItFissileFuel; +import calclavia.lib.UniversalRecipes; +import cpw.mods.fml.common.Loader; +import cpw.mods.fml.common.Mod; +import cpw.mods.fml.common.Mod.EventHandler; +import cpw.mods.fml.common.Mod.Instance; +import cpw.mods.fml.common.Mod.Metadata; +import cpw.mods.fml.common.ModMetadata; +import cpw.mods.fml.common.SidedProxy; +import cpw.mods.fml.common.event.FMLInitializationEvent; +import cpw.mods.fml.common.event.FMLPostInitializationEvent; +import cpw.mods.fml.common.event.FMLPreInitializationEvent; +import cpw.mods.fml.common.eventhandler.SubscribeEvent; +import cpw.mods.fml.common.network.NetworkRegistry; +import cpw.mods.fml.common.registry.EntityRegistry; +import cpw.mods.fml.common.registry.GameRegistry; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import java.util.Arrays; +import java.util.logging.Logger; +import net.minecraft.block.Block; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.init.Blocks; +import net.minecraft.init.Items; +import net.minecraft.item.Item; +import net.minecraft.item.ItemArmor.ArmorMaterial; +import net.minecraft.item.ItemBucket; +import net.minecraft.item.ItemStack; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; +import net.minecraftforge.client.event.TextureStitchEvent.Post; +import net.minecraftforge.common.ForgeChunkManager; +import net.minecraftforge.common.ForgeChunkManager.Ticket; +import net.minecraftforge.common.ForgeChunkManager.Type; +import net.minecraftforge.common.MinecraftForge; +import net.minecraftforge.common.config.Configuration; +import net.minecraftforge.common.util.EnumHelper; +import net.minecraftforge.fluids.Fluid; +import net.minecraftforge.fluids.FluidContainerRegistry; +import net.minecraftforge.fluids.FluidContainerRegistry.FluidContainerData; +import net.minecraftforge.fluids.FluidRegistry; +import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.oredict.OreDictionary; +import net.minecraftforge.oredict.ShapedOreRecipe; +import net.minecraftforge.oredict.ShapelessOreRecipe; +import universalelectricity.core.item.ElectricItemHelper; +import universalelectricity.core.item.ItemElectric; +import universalelectricity.core.vector.Vector3; +import universalelectricity.prefab.TranslationHelper; +import universalelectricity.prefab.ore.OreGenBase; +import universalelectricity.prefab.ore.OreGenReplaceStone; +import universalelectricity.prefab.ore.OreGenerator; + +@Mod(modid = "AtomicScience", name = "Atomic Science", version = "0.6.2", + dependencies = "required-after:basiccomponents") +public class AtomicScience { + public static Configuration CONFIGURATION = + new Configuration(Loader.instance().getConfigDir(), "AtomicScience.cfg"); + public static final String ID = "AtomicScience"; + public static final String CHANNEL = "AtomicScience"; + public static final String PREFIX = "atomicscience:"; + @Instance("AtomicScience") public static AtomicScience instance; + @SidedProxy(clientSide = "atomicscience.ClientProxy", + serverSide = "atomicscience.CommonProxy") + public static CommonProxy proxy; + @Metadata("AtomicScience") public static ModMetadata metadata; + public static final String WEN_JIAN_NO_SLASH = "atomicscience/"; + public static final String WEN_JIAN = "/atomicscience/"; + public static final String DIR = "/mods/atomicscience/"; + public static final String TEXTURE_WEN_JIAN = "/mods/atomicscience/textures/"; + public static final String SHI_MIAN_WEN_JIAN = + "/mods/atomicscience/textures/gui/"; + public static final String BLOCK_WEN_JIAN = + "/mods/atomicscience/textures/blocks/"; + public static final String ITEM_WEN_JIAN = + "/mods/atomicscience/textures/items/"; + public static final String MODEL_WEN_JIAN = + "/mods/atomicscience/textures/models/"; + // private static final String YU_YAN_WEN_JIAN = "/mods/atomicscience/yuyan/"; + private static final String[] YU_YAN = new String[] {"en_US"}; + public static float WOLUN_MULTIPLIER_OUTPUT = 30.0F; + public static boolean ALLOW_LAYERED_TURBINES = true; + public static boolean ALLOW_TOXIC_WASTE = true; + public static boolean ALLOW_RADIOACTIVE_ORES = true; + public static final int BLOCK_ID_PREFIX = 3768; + public static final int ENTITY_ID_PREFIX = 49; + public static Block blockRadioactive; + public static Block bCentrifuge; + public static Block bTurbine; + public static Block bNuclearBoiler; + public static Block bControlRod; + public static Block bThermometer; + public static Block bFusionReactor; + public static BPlasma bPlasma; + public static Block bElectromagnet; + public static Block bChemicalExtractor; + public static Block bSiren; + public static Block bElectromagnetGlass; + public static Block bFunnel; + public static Block bAccelerator; + public static Block bAutoBuilder; + public static Block bFulminationGenerator; + public static Block bAtomicAssembler; + public static Block bFissionReactor; + public static Block bReactorTap; + public static final int ITEM_ID_PREFIX = 13768; + public static Item itCell; + public static Item itCellUranium; + public static Item itCellBreederFuel; + public static Item itCellStrangeMatter; + public static Item itCellAntimatter; + public static Item itCellDeuterium; + public static Item itCellWater; + public static Item itBucketToxic; + public static Block bUraniumOre; + public static Item itYellowcake; + public static Item itUranium; + public static ItemElectric itWenDuBiao; + public static Item itHazmatHelmet; + public static Item itHazmatChestplate; + public static Item itHazmanLeggings; + public static Item itHazmatBoots; + public static Block bToxicWaste; + public static Fluid FLUID_URANIUM_HEXAFLOURIDE; + public static Fluid FLUID_STEAM; + public static Fluid FLUID_TOXIC_WASTE; + public static final ArmorMaterial hazmatArmorMaterial = + EnumHelper.addArmorMaterial("HAZMAT", 0, new int[] {0, 0, 0, 0}, 0); + public static OreGenBase uraniumOreGeneration; + public static int URANIUM_HEXAFLOURIDE_RATIO = 200; + public static int STEAM_RATIO = 40; + // public static final String QIZI_FAN_WU_SU_BAO_ZHA = + // FlagRegistry.registerFlag("ban_antimatter_power"); + public static final Logger LOGGER = Logger.getLogger("AtomicScience"); + + @EventHandler + public void preInit(FMLPreInitializationEvent event) { + instance = this; + MinecraftForge.EVENT_BUS.register(this); + AtomicScience.CONFIGURATION.load(); + WOLUN_MULTIPLIER_OUTPUT = (float)AtomicScience.CONFIGURATION + .get("general", "Turbine Output Multiplier", + (double)WOLUN_MULTIPLIER_OUTPUT) + .getDouble((double)WOLUN_MULTIPLIER_OUTPUT); + ALLOW_LAYERED_TURBINES = + AtomicScience.CONFIGURATION + .get("general", "Allow Layered Turbines", ALLOW_LAYERED_TURBINES) + .getBoolean(ALLOW_LAYERED_TURBINES); + ALLOW_TOXIC_WASTE = + AtomicScience.CONFIGURATION + .get("general", "Allow Toxic Waste", ALLOW_TOXIC_WASTE) + .getBoolean(ALLOW_TOXIC_WASTE); + ALLOW_RADIOACTIVE_ORES = + AtomicScience.CONFIGURATION + .get("general", "Allow Radioactive Ores", ALLOW_RADIOACTIVE_ORES) + .getBoolean(ALLOW_RADIOACTIVE_ORES); + PoisonRadiation.disabled = + AtomicScience.CONFIGURATION + .get("general", "Disable Radiation", PoisonRadiation.disabled) + .getBoolean(PoisonRadiation.disabled); + URANIUM_HEXAFLOURIDE_RATIO = + AtomicScience.CONFIGURATION + .get("general", "Uranium Hexafluoride Ratio", + URANIUM_HEXAFLOURIDE_RATIO) + .getInt(URANIUM_HEXAFLOURIDE_RATIO); + STEAM_RATIO = + AtomicScience.CONFIGURATION.get("general", "Steam Ratio", STEAM_RATIO) + .getInt(STEAM_RATIO); + PotionRadiation.INSTANCE.getId(); + blockRadioactive = (new BlockRadioactive() + .setBlockName("atomicscience:radioactive") + .setCreativeTab(TabAS.INSTANCE)); + bUraniumOre = new BUraniumOre(); + bCentrifuge = new BCentrifuge(); + bFissionReactor = new BFissionReactor(); + bTurbine = new BTurbine(); + bNuclearBoiler = new BNuclearBoiler(); + bControlRod = new BControlRod(); + bThermometer = new BThermometer(); + bFusionReactor = new BFusionReactor(); + bPlasma = new BPlasma(); + bElectromagnet = new BElectromagnet(); + bChemicalExtractor = new BChemicalExtractor(); + bSiren = new BSiren(); + bElectromagnetGlass = new BElectromagnetGlass(); + bFunnel = new BFunnel(); + bAccelerator = new BAccelerator(); + bAutoBuilder = new BAutoBuilder(); + bFulminationGenerator = new BFulminationGenerator(); + bAtomicAssembler = new BAtomicAssembler(); + bReactorTap = new BReactorTap(); + itHazmatHelmet = + (new ItHazmatSuite( + + hazmatArmorMaterial, proxy.getArmorIndex("hazmat"), 0)) + .setUnlocalizedName("atomicscience:hazmatMask"); + itHazmatChestplate = (new ItHazmatSuite(hazmatArmorMaterial, + proxy.getArmorIndex("hazmat"), 1)) + .setUnlocalizedName("atomicscience:hazmatBody"); + itHazmanLeggings = (new ItHazmatSuite(hazmatArmorMaterial, + proxy.getArmorIndex("hazmat"), 2)) + .setUnlocalizedName("atomicscience:hazmatLeggings"); + itHazmatBoots = (new ItHazmatSuite(hazmatArmorMaterial, + proxy.getArmorIndex("hazmat"), 3)) + .setUnlocalizedName("atomicscience:hazmatBoots"); + itWenDuBiao = new ItThermometer(1); + itCell = new ItCell("cellEmpty"); + itCellUranium = new ItFissileFuel(); + itCellDeuterium = new ItCell("cellDeuterium"); + itCellStrangeMatter = new ItStrangeMatter(); + itCellAntimatter = new ItAntimatterCell(); + itCellWater = new ItCell("cellWater"); + itCellBreederFuel = new ItBreederFuel(); + itYellowcake = new ItRadioactive("yellowcake"); + itUranium = new ItUranium(0); + FLUID_URANIUM_HEXAFLOURIDE = getOrRegisterFluid("uranium_hexafluoride"); + FLUID_STEAM = getOrRegisterFluid("steam"); + FLUID_TOXIC_WASTE = getOrRegisterFluid("toxic_waste"); + bToxicWaste = + (new BToxicWaste("toxicWaste")).setCreativeTab((CreativeTabs)null); + itBucketToxic = (new ItemBucket(bToxicWaste)) + .setCreativeTab(TabAS.INSTANCE) + .setUnlocalizedName("atomicscience:bucketToxicWaste") + .setContainerItem(Items.bucket); + FluidContainerRegistry.registerFluidContainer(new FluidContainerData( + new FluidStack(FLUID_TOXIC_WASTE, 1000), new ItemStack(itBucketToxic), + new ItemStack(Items.bucket))); + NetworkRegistry.INSTANCE.registerGuiHandler(this, proxy); + GameRegistry.registerBlock(blockRadioactive, "blockRadioactive"); + GameRegistry.registerBlock(bUraniumOre, "bUraniumOre"); + GameRegistry.registerBlock(bCentrifuge, "bCentrifuge"); + GameRegistry.registerBlock(bFissionReactor, "bFissionReactor"); + GameRegistry.registerBlock(bTurbine, "bTurbine"); + GameRegistry.registerBlock(bNuclearBoiler, "bNuclearBoiler"); + GameRegistry.registerBlock(bControlRod, "bControlRod"); + GameRegistry.registerBlock(bThermometer, "bThermometer"); + GameRegistry.registerBlock(bFusionReactor, "bFusionReactor"); + GameRegistry.registerBlock(bPlasma, IBPlasma.class, "bPlasma"); + GameRegistry.registerBlock(bElectromagnet, "bElectromagnet"); + GameRegistry.registerBlock(bChemicalExtractor, "bChemicalExtractor"); + GameRegistry.registerBlock(bSiren, IBSiren.class, "bSiren"); + GameRegistry.registerBlock(bElectromagnetGlass, "bElectromagnetGlass"); + GameRegistry.registerBlock(bFunnel, "bFunnel"); + GameRegistry.registerBlock(bAccelerator, IBAccelerator.class, + "bAccelerator"); + GameRegistry.registerBlock(bAutoBuilder, "bAutoBuilder"); + GameRegistry.registerBlock(bFulminationGenerator, "bFulminationGenerator"); + GameRegistry.registerBlock(bAtomicAssembler, "bAtomicAssembler"); + GameRegistry.registerBlock(bToxicWaste, "bToxicWaste"); + GameRegistry.registerBlock(bReactorTap, "bReactorTap"); + uraniumOreGeneration = new OreGenReplaceStone("Uranium Ore", "oreUranium", + new ItemStack(bUraniumOre), 0, + 25, 9, 3, "pickaxe", 2); + if (OreDictionary.getOres("oreUranium").size() > 1 && + AtomicScience.CONFIGURATION + .get("general", "Auto Disable Uranium If Exist", false) + .getBoolean(false)) { + LOGGER.fine( + "Disabled Uranium Generation. Detected another uranium being generated: " + + OreDictionary.getOres("oreUranium").size()); + } else { + uraniumOreGeneration.enable(AtomicScience.CONFIGURATION); + OreGenerator.addOre(uraniumOreGeneration); + LOGGER.fine("Added Atomic Science uranium to ore generator."); + } + + AtomicScience.CONFIGURATION.save(); + MinecraftForge.EVENT_BUS.register(itCellAntimatter); + MinecraftForge.EVENT_BUS.register(FulminationEventHandler.INSTANCE); + OreDictionary.registerOre("ingotUranium", itUranium); + OreDictionary.registerOre("breederUranium", new ItemStack(itUranium, 1, 1)); + OreDictionary.registerOre("blockRadioactive", blockRadioactive); + OreDictionary.registerOre("cellEmpty", itCell); + OreDictionary.registerOre("cellUranium", itCellUranium); + OreDictionary.registerOre("cellDeuterium", itCellDeuterium); + OreDictionary.registerOre("cellWater", itCellWater); + OreDictionary.registerOre("strangeMatter", itCellStrangeMatter); + OreDictionary.registerOre("antimatterMilligram", + new ItemStack(itCellAntimatter, 1, 0)); + OreDictionary.registerOre("antimatterGram", + new ItemStack(itCellAntimatter, 1, 1)); + FluidContainerRegistry.registerFluidContainer(new FluidContainerData( + new FluidStack(FluidRegistry.WATER, 1000), new ItemStack(itCellWater), + new ItemStack(itCell))); + ForgeChunkManager.setForcedChunkLoadingCallback(this, (tickets, world) -> { + for (Ticket ticket : tickets) { + if (ticket.getType() == Type.ENTITY && ticket.getEntity() != null && + ticket.getEntity() instanceof EMatter) { + ((EMatter)ticket.getEntity()).youPiao = ticket; + } + } + }); + Plasma.blockPlasma = bPlasma; + GameRegistry.registerTileEntity(TCentrifuge.class, "ASCentrifuge"); + GameRegistry.registerTileEntity(TFusionReactor.class, "ASFusionReactor"); + GameRegistry.registerTileEntity(TTurbine.class, "ASTurbine"); + GameRegistry.registerTileEntity(TNuclearBoiler.class, "ASNuclearBoiler"); + GameRegistry.registerTileEntity(TThermometer.class, "ASThermometer"); + GameRegistry.registerTileEntity(TElectromagnet.class, "ASElectromagnet"); + GameRegistry.registerTileEntity(TChemicalExtractor.class, + "ASChemicalExtractor"); + GameRegistry.registerTileEntity(TFunnel.class, "ASFunnel"); + GameRegistry.registerTileEntity(TAccelerator.class, "ASAccelerator"); + GameRegistry.registerTileEntity(TFulminationGenerator.class, + "ASFulminationGenerator"); + GameRegistry.registerTileEntity(TAtomicAssembler.class, + "ASAtomicAssembler"); + GameRegistry.registerTileEntity(TAutoBuilder.class, "ASAutoBuilder"); + GameRegistry.registerTileEntity(TFissionReactor.class, "ASFissionReactor"); + GameRegistry.registerTileEntity(TReactorTap.class, "ASReactorTap"); + proxy.preInit(); + } + + @EventHandler + public void load(FMLInitializationEvent evt) { + metadata.modId = "AtomicScience"; + metadata.name = "Atomic Science"; + metadata.description = + "Electricity generation is always a burden. That\'s why we are here to bring in high tech nuclear power to solve all your electricity-lack problems. With our fission reactors, fusion reactors, and antimatter generators, you won\'t be lacking electricity ever again!"; + metadata.url = "http://www.universalelectricity.com/atomicscience"; + metadata.logoFile = "/as_logo.png"; + metadata.version = "0.6.2.117"; + metadata.authorList = Arrays.asList(new String[] {"Calclavia"}); + metadata.credits = "Please visit the website."; + metadata.autogenerated = false; + LOGGER.fine( + "Loaded Languages: " + + TranslationHelper.loadLanguages("/mods/atomicscience/yuyan/", YU_YAN)); + } + + @EventHandler + public void postInit(FMLPostInitializationEvent event) { + UniversalRecipes.init(); + if (Loader.isModLoaded("IC2")) { + OreDictionary.registerOre("cellEmpty", itCell); + GameRegistry.addRecipe(new ShapelessOreRecipe( + itYellowcake, GameRegistry.findItem("IC2", "reactorUraniumSimple"))); + Item ic2FluidCell = GameRegistry.findItem("IC2", "itemFluidCell"); + GameRegistry.addRecipe(new ShapelessOreRecipe(ic2FluidCell, itCell)); + GameRegistry.addRecipe(new ShapelessOreRecipe(itCell, "cellEmpty")); + } + + GameRegistry.addRecipe(new ShapelessOreRecipe( + new ItemStack(itCellAntimatter, 1, 1), itCellAntimatter, + itCellAntimatter, itCellAntimatter, itCellAntimatter, itCellAntimatter, + itCellAntimatter, itCellAntimatter, itCellAntimatter)); + GameRegistry.addRecipe(new ShapelessOreRecipe( + new ItemStack(itCellAntimatter, 8, 0), + new Object[] {new ItemStack(itCellAntimatter, 1, 1)})); + GameRegistry.addRecipe(new ShapedOreRecipe( + new ItemStack(bFunnel, 2), " B ", "B B", "B B", 'B', "ingotBronze")); + GameRegistry.addRecipe(new ShapedOreRecipe(new ItemStack(bFunnel, 2), " B ", + "B B", "B B", 'B', "ingotIron")); + GameRegistry.addRecipe(new ShapedOreRecipe( + bAtomicAssembler, "CCC", "SXS", "SSS", 'X', bCentrifuge, 'C', + "calclavia:CIRCUIT_T3", 'S', "plateSteel")); + GameRegistry.addRecipe(new ShapedOreRecipe( + bFulminationGenerator, "OSO", "SCS", "OSO", 'O', Blocks.obsidian, 'C', + "calclavia:CIRCUIT_T2", 'S', "plateSteel")); + GameRegistry.addRecipe(new ShapedOreRecipe( + bAccelerator, "SCS", "CMC", "SCS", 'M', "calclavia:MOTOR", 'C', + "calclavia:CIRCUIT_T3", 'S', "plateSteel")); + GameRegistry.addRecipe(new ShapelessOreRecipe( + bElectromagnetGlass, new Object[] {bElectromagnet, Blocks.glass})); + GameRegistry.addRecipe(new ShapedOreRecipe( + bCentrifuge, + new Object[] {"BSB", "MCM", "BSB", Character.valueOf('C'), + "calclavia:CIRCUIT_T2", Character.valueOf('S'), + "plateSteel", Character.valueOf('B'), "ingotBronze", + Character.valueOf('M'), "calclavia:MOTOR"})); + GameRegistry.addRecipe(new ShapedOreRecipe( + bNuclearBoiler, + new Object[] {"S S", "FBF", "SMS", Character.valueOf('F'), + Blocks.furnace, Character.valueOf('S'), "plateSteel", + Character.valueOf('B'), Items.bucket, + Character.valueOf('M'), "calclavia:MOTOR"})); + GameRegistry.addRecipe(new ShapedOreRecipe( + bChemicalExtractor, + new Object[] {"BSB", "MCM", "BSB", Character.valueOf('C'), + "calclavia:CIRCUIT_T3", Character.valueOf('S'), + "plateSteel", Character.valueOf('B'), "ingotBronze", + Character.valueOf('M'), "calclavia:MOTOR"})); + GameRegistry.addRecipe(new ShapedOreRecipe( + new ItemStack(bSiren, 2), + new Object[] {"NPN", Character.valueOf('N'), Blocks.noteblock, + Character.valueOf('P'), "plateBronze"})); + GameRegistry.addRecipe(new ShapedOreRecipe( + bFissionReactor, + new Object[] {"SCS", "MEM", "SCS", Character.valueOf('E'), "cellEmpty", + Character.valueOf('C'), "calclavia:CIRCUIT_T2", + Character.valueOf('S'), "plateSteel", + Character.valueOf('M'), "calclavia:MOTOR"})); + GameRegistry.addRecipe(new ShapedOreRecipe( + bFusionReactor, + new Object[] {"CPC", "PFP", "CPC", Character.valueOf('P'), "plateSteel", + Character.valueOf('F'), bFissionReactor, + Character.valueOf('C'), "calclavia:CIRCUIT_T3"})); + GameRegistry.addRecipe(new ShapedOreRecipe( + bTurbine, new Object[] {" B ", "BMB", " B ", Character.valueOf('B'), + "plateBronze", Character.valueOf('M'), + "calclavia:MOTOR"})); + GameRegistry.addRecipe(new ShapedOreRecipe( + bReactorTap, + new Object[] {"SBS", "TMT", "SBS", Character.valueOf('S'), + "plateBronze", Character.valueOf('T'), "ingotBronze", + Character.valueOf('M'), "calclavia:MOTOR", + Character.valueOf('B'), Items.bucket})); + GameRegistry.addRecipe(new ShapedOreRecipe( + new ItemStack(itCell, 16), + new Object[] {" T ", "TGT", " T ", Character.valueOf('T'), "ingotTin", + Character.valueOf('G'), Blocks.glass})); + GameRegistry.addRecipe(new ShapelessOreRecipe(new ItemStack(itCellWater), + itCell, Items.water_bucket)); + GameRegistry.addRecipe(new ShapedOreRecipe( + ElectricItemHelper.getUncharged(new ItemStack(itWenDuBiao)), + new Object[] {"SSS", "GCG", "GSG", Character.valueOf('S'), "ingotSteel", + Character.valueOf('G'), Blocks.glass, + Character.valueOf('C'), "calclavia:CIRCUIT_T1"})); + GameRegistry.addRecipe(new ShapedOreRecipe( + bThermometer, new Object[] {"SSS", "SWS", "SSS", Character.valueOf('S'), + "ingotSteel", Character.valueOf('W'), + ElectricItemHelper.getUncharged( + new ItemStack(itWenDuBiao))})); + GameRegistry.addRecipe(new ShapedOreRecipe( + bControlRod, new Object[] {"I", "I", "I", Character.valueOf('I'), + Items.iron_ingot})); + GameRegistry.addRecipe(new ShapedOreRecipe( + itCellUranium, + new Object[] {"CUC", "CUC", "CUC", Character.valueOf('U'), + "ingotUranium", Character.valueOf('C'), "cellEmpty"})); + GameRegistry.addRecipe(new ShapedOreRecipe( + itCellBreederFuel, + new Object[] {"CUC", "CUC", "CUC", Character.valueOf('U'), + "breederUranium", Character.valueOf('C'), "cellEmpty"})); + GameRegistry.addRecipe(new ShapedOreRecipe( + new ItemStack(bElectromagnet, 2), + new Object[] {"BBB", "BMB", "BBB", Character.valueOf('B'), + "ingotBronze", Character.valueOf('M'), + "calclavia:MOTOR"})); + GameRegistry.addRecipe(new ShapedOreRecipe( + new ItemStack(bElectromagnet, 2), + new Object[] {"BBB", "BMB", "BBB", Character.valueOf('B'), "ingotIron", + Character.valueOf('M'), "calclavia:MOTOR"})); + GameRegistry.addRecipe(new ShapedOreRecipe( + itHazmatHelmet, + new Object[] {"SSS", "BAB", "SCS", Character.valueOf('A'), + Items.leather_helmet, Character.valueOf('C'), + "calclavia:CIRCUIT_T1", Character.valueOf('S'), + Blocks.wool})); + GameRegistry.addRecipe(new ShapedOreRecipe( + itHazmatChestplate, + new Object[] {"SSS", "BAB", "SCS", Character.valueOf('A'), + Items.leather, Character.valueOf('C'), + "calclavia:CIRCUIT_T1", Character.valueOf('S'), + Blocks.wool})); + GameRegistry.addRecipe(new ShapedOreRecipe( + itHazmanLeggings, + new Object[] {"SSS", "BAB", "SCS", Character.valueOf('A'), + Items.leather_leggings, Character.valueOf('C'), + "calclavia:CIRCUIT_T1", Character.valueOf('S'), + Blocks.wool})); + GameRegistry.addRecipe(new ShapedOreRecipe( + itHazmatBoots, + new Object[] {"SSS", "BAB", "SCS", Character.valueOf('A'), + Items.leather_boots, Character.valueOf('C'), + "calclavia:CIRCUIT_T1", Character.valueOf('S'), + Blocks.wool})); + EntityRegistry.registerGlobalEntityID( + EMatter.class, "ASParticle", EntityRegistry.findGlobalUniqueEntityId()); + EntityRegistry.registerModEntity(EMatter.class, "ASParticle", 49, this, 80, + 3, true); + proxy.init(); + AtomicScience.CONFIGURATION.load(); + if (Loader.isModLoaded("IC2") && + AtomicScience.CONFIGURATION + .get("general", "Disable IC2 Uranium Compression (Recommended)", + true) + .getBoolean(true)) { + try { + // TODO: WTF + // if (Recipes.compressor != null) { + // Map e = Recipes.compressor.getRecipes(); + // Iterator it = e.entrySet().iterator(); + // int i = 0; + + // while (it.hasNext()) { + // Entry entry = (Entry)it.next(); + // if (isUraniumOre((ItemStack)entry.getKey())) { + // ++i; + // it.remove(); + // } + // } + + // LOGGER.fine( + // "Removed " + i + + // " IC2 uranium compression recipe, use centrifuge instead."); + // } + } catch (Exception var6) { + LOGGER.fine("Failed to remove IC2 compressor recipes."); + var6.printStackTrace(); + } + } + + AtomicScience.CONFIGURATION.save(); + } + + public static boolean isCell(ItemStack itemStack) { + return is(itemStack, "cellEmpty"); + } + + public static boolean isCellWater(ItemStack itemStack) { + return is(itemStack, "cellWater"); + } + + public static boolean isUraniumOre(ItemStack itemStack) { + return is(itemStack, "dropUranium", "oreUranium"); + } + + public static boolean isFusionFuel(ItemStack itemStack) { + return is(itemStack, "molecule_1d", "molecule_1h2", "cellDeuterium"); + } + + public static boolean is(ItemStack itemStack, String... names) { + if (itemStack != null && names != null && names.length > 0) { + String name = OreDictionary.getOreName(OreDictionary.getOreID(itemStack)); + String[] arr$ = names; + int len$ = names.length; + + for (int i$ = 0; i$ < len$; ++i$) { + String compareName = arr$[i$]; + if (name.equals(compareName)) { + return true; + } + } + } + + return false; + } + + public static void boilWater(World worldObj, Vector3 pos, int height, + int rpm) { + Block blockID = pos.getBlock(worldObj); + if (blockID == Blocks.flowing_water || blockID == Blocks.water) { + if (!ALLOW_LAYERED_TURBINES) { + height = 1; + } + + if (worldObj.rand.nextInt(80) == 0) { + worldObj.playSoundEffect( + pos.x + 0.5D, pos.y + 0.5D, pos.z + 0.5D, "liquid.lava", 0.5F, + 2.1F + (worldObj.rand.nextFloat() - worldObj.rand.nextFloat()) * + 0.85F); + } + + if (worldObj.rand.nextInt(40) == 0) { + worldObj.playSoundEffect( + pos.x + 0.5D, pos.y + 0.5D, pos.z + 0.5D, "liquid.lavapop", 0.5F, + 2.6F + + (worldObj.rand.nextFloat() - worldObj.rand.nextFloat()) * 0.8F); + } + + worldObj.spawnParticle("bubble", pos.x + 0.5D, + pos.y + 0.20000000298023224D, pos.z + 0.5D, 0.0D, + 0.0D, 0.0D); + if (worldObj.rand.nextInt(5) == 0) { + worldObj.spawnParticle("smoke", pos.x + 0.5D, pos.y + 0.5D, + pos.z + 0.5D, 0.0D, 0.0D, 0.0D); + } + + for (int i = 1; i <= height; ++i) { + TileEntity tileEntity = + worldObj.getTileEntity(pos.intX(), pos.intY() + i, pos.intZ()); + if (tileEntity != null && tileEntity instanceof ISteamReceptor) { + ((ISteamReceptor)tileEntity).onReceiveSteam(rpm); + rpm /= 2; + } + } + } + } + + @SubscribeEvent + @SideOnly(Side.CLIENT) + public void textureHook(Post event) { + // TODO: WTF + // if (event.map == Minecraft.getMinecraft().renderEngine.field_94155_m) { + + FLUID_URANIUM_HEXAFLOURIDE.setIcons( + event.map.registerIcon("atomicscience:uraniumHexafluoride")); + // TODO: might override railcraft icon? + FLUID_STEAM.setIcons(event.map.registerIcon("atomicscience:steam")); + FLUID_TOXIC_WASTE.setIcons( + event.map.registerIcon("atomicscience:toxicWaste")); + } + + // TODO: WTF + // @EventHandler public void serverStarting(FMLServerStartingEvent event) { + // FlagRegistry.registerModFlag( + // "ModFlags", new ModFlag(NBTFileLoader.loadData("ModFlags"))); + // ICommandManager commandManager = FMLCommonHandler.instance() + // .getMinecraftServerInstance() + // .getCommandManager(); + // ServerCommandManager serverCommandManager = + // (ServerCommandManager)commandManager; + // serverCommandManager.registerCommand( + // new CommandFlag(FlagRegistry.getModFlag("ModFlags"))); + // } + + // TODO: WTF + // @ForgeSubscribe + // public void worldSave(Save evt) { + // if (!evt.world.isRemote) { + // NBTFileLoader.saveData("ModFlags", + // FlagRegistry.getModFlag("ModFlags").getNBT()); + // } + // } + + public static int getLiquidAmount(FluidStack liquid) { + return liquid != null ? liquid.amount : 0; + } + + static Fluid getOrRegisterFluid(String id) { + FluidRegistry.registerFluid(new Fluid(id)); + + return FluidRegistry.getFluid(id); + } +} diff --git a/src/main/java/atomicscience/BAtomicAssembler.java b/src/main/java/atomicscience/BAtomicAssembler.java new file mode 100644 index 0000000..6a3a172 --- /dev/null +++ b/src/main/java/atomicscience/BAtomicAssembler.java @@ -0,0 +1,48 @@ +package atomicscience; + +import atomicscience.jiqi.BBase; +import atomicscience.render.RH; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; + +public class BAtomicAssembler extends BBase { + + public BAtomicAssembler() { + super("atomicAssembler"); + } + + @Override + public boolean onMachineActivated(World par1World, int x, int y, int z, EntityPlayer par5EntityPlayer, int side, float hitX, float hitY, float hitZ) { + par1World.getBlockMetadata(x, y, z); + if(!par1World.isRemote) { + par5EntityPlayer.openGui(AtomicScience.instance, CommonProxy.GuiType.GOU_CHENG.ordinal(), par1World, x, y, z); + return true; + } else { + return true; + } + } + + @Override + public TileEntity createNewTileEntity(World var1, int meta) { + return new TAtomicAssembler(); + } + + @Override + public boolean renderAsNormalBlock() { + return false; + } + + @Override + public boolean isOpaqueCube() { + return false; + } + + @Override + @SideOnly(Side.CLIENT) + public int getRenderType() { + return RH.BLOCK_RENDER_ID; + } +} diff --git a/src/main/java/atomicscience/BAutoBuilder.java b/src/main/java/atomicscience/BAutoBuilder.java new file mode 100644 index 0000000..ad42e76 --- /dev/null +++ b/src/main/java/atomicscience/BAutoBuilder.java @@ -0,0 +1,25 @@ +package atomicscience; + +import atomicscience.jiqi.BBase; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; + +public class BAutoBuilder extends BBase { + public static final int BAN_JING = 30; + + public BAutoBuilder() { + super("instantBuilder"); + } + + @Override + public boolean onMachineActivated(World par1World, int x, int y, int z, EntityPlayer par5EntityPlayer, int side, float hitX, float hitY, float hitZ) { + par5EntityPlayer.openGui(AtomicScience.instance, -1, par1World, x, y, z); + return true; + } + + @Override + public TileEntity createNewTileEntity(World var1, int meta) { + return new TAutoBuilder(); + } +} diff --git a/src/main/java/atomicscience/BToxicWaste.java b/src/main/java/atomicscience/BToxicWaste.java new file mode 100644 index 0000000..9896515 --- /dev/null +++ b/src/main/java/atomicscience/BToxicWaste.java @@ -0,0 +1,68 @@ +package atomicscience; + +import atomicscience.api.poison.PoisonRadiation; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import java.util.Random; +import net.minecraft.block.material.Material; +import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.entity.Entity; +import net.minecraft.entity.EntityLiving; +import net.minecraft.util.DamageSource; +import net.minecraft.world.World; +import net.minecraftforge.fluids.BlockFluidClassic; +import universalelectricity.core.vector.Vector3; + +public class BToxicWaste extends BlockFluidClassic { + public BToxicWaste(String name) { + super(AtomicScience.FLUID_TOXIC_WASTE, Material.water); + this.setBlockName("atomicscience:" + name); + this.setCreativeTab(TabAS.INSTANCE); + this.setHardness(100.0F); + this.setLightOpacity(3); + } + + @Override + public int tickRate(World par1World) { + return 20; + } + + @Override + public void randomDisplayTick(World par1World, int x, int y, int z, + Random par5Random) { + super.randomDisplayTick(par1World, x, y, z, par5Random); + if (par5Random.nextInt(100) == 0) { + double d5 = (double)((float)x + par5Random.nextFloat()); + double d7 = (double)y + this.maxY; + double d6 = (double)((float)z + par5Random.nextFloat()); + par1World.spawnParticle("suspended", d5, d7, d6, 0.0D, 0.0D, 0.0D); + par1World.playSound(d5, d7, d6, "liquid.lavapop", + 0.2F + par5Random.nextFloat() * 0.2F, + 0.9F + par5Random.nextFloat() * 0.15F, false); + } + + if (par5Random.nextInt(200) == 0) { + par1World.playSound((double)x, (double)y, (double)z, "liquid.lava", + 0.2F + par5Random.nextFloat() * 0.2F, + 0.9F + par5Random.nextFloat() * 0.15F, false); + } + } + + @Override + public void onEntityCollidedWithBlock(World par1World, int x, int y, int z, + Entity entity) { + if (entity instanceof EntityLiving) { + entity.attackEntityFrom(DamageSource.wither, 3); + PoisonRadiation.INSTANCE.poisonEntity( + new Vector3((double)x, (double)y, (double)z), (EntityLiving)entity, + 4); + } + } + + @Override + @SideOnly(Side.CLIENT) + public void registerBlockIcons(IIconRegister iconRegister) { + this.blockIcon = iconRegister.registerIcon("atomicscience:toxicWaste"); + AtomicScience.FLUID_TOXIC_WASTE.setIcons(this.blockIcon); + } +} diff --git a/src/main/java/atomicscience/ClientProxy.java b/src/main/java/atomicscience/ClientProxy.java new file mode 100644 index 0000000..29dcfa5 --- /dev/null +++ b/src/main/java/atomicscience/ClientProxy.java @@ -0,0 +1,105 @@ +package atomicscience; + +import atomicscience.fanwusu.EMatter; +import atomicscience.fanwusu.TAccelerator; +import atomicscience.fenlie.TCentrifuge; +import atomicscience.fenlie.TFissionReactor; +import atomicscience.fenlie.TNuclearBoiler; +import atomicscience.hecheng.TFusionReactor; +import atomicscience.jiqi.TChemicalExtractor; +import atomicscience.jiqi.TThermometer; +import atomicscience.jiqi.TTurbine; +import atomicscience.render.RAtomicAssembler; +import atomicscience.render.RCentrifuge; +import atomicscience.render.RExtractor; +import atomicscience.render.RFusionReactor; +import atomicscience.render.RH; +import atomicscience.render.RMatter; +import atomicscience.render.RNuclearBoiler; +import atomicscience.render.RReactorCell; +import atomicscience.render.RThermometer; +import atomicscience.render.RTurbine; +import atomicscience.shimian.GAccelerator; +import atomicscience.shimian.GAtomicAssembler; +import atomicscience.shimian.GAutoBuilder; +import atomicscience.shimian.GCentrifuge; +import atomicscience.shimian.GChemicalReactor; +import atomicscience.shimian.GFissionReactor; +import atomicscience.shimian.GNuclearBoiler; +import cpw.mods.fml.client.registry.ClientRegistry; +import cpw.mods.fml.client.registry.RenderingRegistry; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; + +public class ClientProxy extends CommonProxy { + + public void preInit() { + RenderingRegistry.registerBlockHandler(new RH()); + } + + public int getArmorIndex(String armor) { + return RenderingRegistry.addNewArmourRendererPrefix(armor); + } + + public void init() { + super.init(); + ClientRegistry.bindTileEntitySpecialRenderer(TCentrifuge.class, + new RCentrifuge()); + ClientRegistry.bindTileEntitySpecialRenderer(TFusionReactor.class, + new RFusionReactor()); + ClientRegistry.bindTileEntitySpecialRenderer(TNuclearBoiler.class, + new RNuclearBoiler()); + ClientRegistry.bindTileEntitySpecialRenderer(TTurbine.class, + new RTurbine()); + ClientRegistry.bindTileEntitySpecialRenderer(TThermometer.class, + new RThermometer()); + ClientRegistry.bindTileEntitySpecialRenderer(TChemicalExtractor.class, + new RExtractor()); + ClientRegistry.bindTileEntitySpecialRenderer(TAtomicAssembler.class, + new RAtomicAssembler()); + ClientRegistry.bindTileEntitySpecialRenderer(TFissionReactor.class, + new RReactorCell()); + RenderingRegistry.registerEntityRenderingHandler(EMatter.class, + new RMatter()); + } + + public Object getClientGuiElement(int ID, EntityPlayer player, World world, + int x, int y, int z) { + TileEntity tileEntity = world.getTileEntity(x, y, z); + if (tileEntity != null && ID < CommonProxy.GuiType.values().length) { + if (tileEntity instanceof TAutoBuilder) { + return new GAutoBuilder(tileEntity); + } + + if (tileEntity instanceof TCentrifuge) { + return new GCentrifuge(player.inventory, (TCentrifuge)tileEntity); + } + + if (tileEntity instanceof TChemicalExtractor) { + return new GChemicalReactor(player.inventory, + (TChemicalExtractor)tileEntity); + } + + if (tileEntity instanceof TAccelerator) { + return new GAccelerator(player.inventory, (TAccelerator)tileEntity); + } + + if (tileEntity instanceof TAtomicAssembler) { + return new GAtomicAssembler(player.inventory, + (TAtomicAssembler)tileEntity); + } + + if (tileEntity instanceof TNuclearBoiler) { + return new GNuclearBoiler(player.inventory, (TNuclearBoiler)tileEntity); + } + + if (tileEntity instanceof TFissionReactor) { + return new GFissionReactor(player.inventory, + (TFissionReactor)tileEntity); + } + } + + return null; + } +} diff --git a/src/main/java/atomicscience/CommonProxy.java b/src/main/java/atomicscience/CommonProxy.java new file mode 100644 index 0000000..c1a1408 --- /dev/null +++ b/src/main/java/atomicscience/CommonProxy.java @@ -0,0 +1,74 @@ +package atomicscience; + +import atomicscience.fanwusu.CAccelerator; +import atomicscience.fanwusu.TAccelerator; +import atomicscience.fenlie.CCentrifuge; +import atomicscience.fenlie.TCentrifuge; +import atomicscience.fenlie.TFissionReactor; +import atomicscience.fenlie.TNuclearBoiler; +import atomicscience.hecheng.CChemicalExtractor; +import atomicscience.hecheng.CNuclearBoiler; +import atomicscience.jiqi.CAssembler; +import atomicscience.jiqi.TChemicalExtractor; +import atomicscience.shimian.CFissionReactor; +import cpw.mods.fml.common.network.IGuiHandler; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; + +public class CommonProxy implements IGuiHandler { + + public void preInit() {} + + public void init() {} + + public int getArmorIndex(String armor) { return 0; } + + public Object getClientGuiElement(int ID, EntityPlayer player, World world, + int x, int y, int z) { + return null; + } + + public Object getServerGuiElement(int ID, EntityPlayer player, World world, + int x, int y, int z) { + TileEntity tileEntity = world.getTileEntity(x, y, z); + if (tileEntity != null && ID < CommonProxy.GuiType.values().length && + ID >= 0) { + if (tileEntity instanceof TCentrifuge) { + return new CCentrifuge(player.inventory, (TCentrifuge)tileEntity); + } + + if (tileEntity instanceof TChemicalExtractor) { + return new CChemicalExtractor(player.inventory, + (TChemicalExtractor)tileEntity); + } + + if (tileEntity instanceof TAccelerator) { + return new CAccelerator(player.inventory, (TAccelerator)tileEntity); + } + + if (tileEntity instanceof TAtomicAssembler) { + return new CAssembler(player.inventory, (TAtomicAssembler)tileEntity); + } + + if (tileEntity instanceof TNuclearBoiler) { + return new CNuclearBoiler(player.inventory, (TNuclearBoiler)tileEntity); + } + + if (tileEntity instanceof TFissionReactor) { + return new CFissionReactor(player, (TFissionReactor)tileEntity); + } + } + + return null; + } + + public static enum GuiType { + + CENTRIFUGE, + DAO_CHOU_QI, + JIA_SU_QI, + GOU_CHENG, + HE_QI; + } +} diff --git a/src/main/java/atomicscience/MegaTNTExplusion.java b/src/main/java/atomicscience/MegaTNTExplusion.java new file mode 100644 index 0000000..78e604d --- /dev/null +++ b/src/main/java/atomicscience/MegaTNTExplusion.java @@ -0,0 +1,39 @@ +package atomicscience; + +import java.util.Random; +import net.minecraft.block.Block; +import net.minecraft.entity.Entity; +import net.minecraft.init.Blocks; +import net.minecraft.world.ChunkPosition; +import net.minecraft.world.Explosion; +import net.minecraft.world.World; + +public class MegaTNTExplusion extends Explosion { + + private Random explosionRAND = new Random(); + private World worldObj; + + public MegaTNTExplusion(World world, Entity par2Entity, double par3, + double par5, double par7, float par9) { + super(world, par2Entity, par3, par5, par7, par9); + this.worldObj = world; + super.isFlaming = true; + } + + @Override + public void doExplosionB(boolean par1) { + super.doExplosionB(par1); + for (Object chunkposition_obj : super.affectedBlockPositions) { + ChunkPosition chunkposition = (ChunkPosition) chunkposition_obj; + Block id = this.worldObj.getBlock(chunkposition.chunkPosX, + chunkposition.chunkPosY, + chunkposition.chunkPosZ); + if (id == Blocks.air && id.isOpaqueCube() && + this.explosionRAND.nextInt(3) == 0) { + this.worldObj.setBlock(chunkposition.chunkPosX, chunkposition.chunkPosY, + chunkposition.chunkPosZ, + AtomicScience.blockRadioactive); + } + } + } +} diff --git a/src/main/java/atomicscience/PAutoBuilder.java b/src/main/java/atomicscience/PAutoBuilder.java new file mode 100644 index 0000000..74d9830 --- /dev/null +++ b/src/main/java/atomicscience/PAutoBuilder.java @@ -0,0 +1,48 @@ +package atomicscience; + +import cpw.mods.fml.common.network.simpleimpl.IMessage; +import io.netty.buffer.ByteBuf; +import io.netty.buffer.ByteBufInputStream; +import io.netty.buffer.ByteBufOutputStream; +import java.io.DataInputStream; +import java.io.DataOutputStream; +import java.io.IOException; +import net.minecraft.nbt.CompressedStreamTools; +import net.minecraft.nbt.NBTTagCompound; +import universalelectricity.core.vector.Vector3; + +public class PAutoBuilder implements IMessage { + public Vector3 pos; + public TAutoBuilder.AutoBuilderType type; + public int radius; + + @Override + public void fromBytes(ByteBuf buf) { + try { + NBTTagCompound nbt = CompressedStreamTools.read( + new DataInputStream(new ByteBufInputStream(buf))); + + this.pos = Vector3.readFromNBT(nbt.getCompoundTag("pos")); + this.type = TAutoBuilder.AutoBuilderType.get(nbt.getInteger("type")); + this.radius = nbt.getInteger("radius"); + } catch (IOException e) { + e.printStackTrace(); + } + } + + @Override + public void toBytes(ByteBuf buf) { + NBTTagCompound nbt = new NBTTagCompound(); + + nbt.setTag("pos", this.pos.writeToNBT(new NBTTagCompound())); + nbt.setInteger("type", this.type.ordinal()); + nbt.setInteger("radius", this.radius); + + try { + CompressedStreamTools.write( + nbt, new DataOutputStream(new ByteBufOutputStream(buf))); + } catch (IOException e) { + e.printStackTrace(); + } + } +} diff --git a/src/main/java/atomicscience/PHAutoBuilder.java b/src/main/java/atomicscience/PHAutoBuilder.java new file mode 100644 index 0000000..b3a7332 --- /dev/null +++ b/src/main/java/atomicscience/PHAutoBuilder.java @@ -0,0 +1,25 @@ +package atomicscience; + +import cpw.mods.fml.common.network.simpleimpl.IMessage; +import cpw.mods.fml.common.network.simpleimpl.IMessageHandler; +import cpw.mods.fml.common.network.simpleimpl.MessageContext; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; + +public class PHAutoBuilder implements IMessageHandler { + + @Override + public IMessage onMessage(PAutoBuilder packet, MessageContext ctx) { + World world = ctx.getServerHandler().playerEntity.worldObj; + + TileEntity te = packet.pos.getTileEntity(world); + if (!(te instanceof TAutoBuilder)) + return null; + + TAutoBuilder ab = (TAutoBuilder)te; + + ab.onActivatePacket(packet.type, packet.radius); + + return null; + } +} diff --git a/src/main/java/atomicscience/SoundManager.java b/src/main/java/atomicscience/SoundManager.java new file mode 100644 index 0000000..4e48355 --- /dev/null +++ b/src/main/java/atomicscience/SoundManager.java @@ -0,0 +1,10 @@ +package atomicscience; + +public class SoundManager { + public static final String ANTIMATTER = "atomicscience:antimatter"; + public static final String STRANGE_MATTER = "atomicscience:strangematter"; + public static final String ALARM = "atomicscience:alarm"; + public static final String ACCELERATOR = "atomicscience:accelerator"; + public static final String TURBINE = "atomicscience:turbine"; + public static final String ASSEMBLER = "atomicscience:assembler"; +} diff --git a/src/main/java/atomicscience/TAtomicAssembler.java b/src/main/java/atomicscience/TAtomicAssembler.java new file mode 100644 index 0000000..b74e04a --- /dev/null +++ b/src/main/java/atomicscience/TAtomicAssembler.java @@ -0,0 +1,178 @@ +package atomicscience; + +import atomicscience.jiqi.TInventory; +import net.minecraft.entity.item.EntityItem; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.network.NetworkManager; +import net.minecraft.network.Packet; +import net.minecraft.network.play.server.S35PacketUpdateTileEntity; +import universalelectricity.core.UniversalElectricity; +import universalelectricity.core.electricity.ElectricityPack; + +public class TAtomicAssembler extends TInventory { + + public final int SMELTING_TICKS = 1200; + public final float DIAN = 10000.0F; + public int smeltingTicks = 0; + public float rotationYaw1; + public float rotationYaw2; + public float rotationYaw3; + public EntityItem entityItem; + + public void updateEntity() { + super.updateEntity(); + if (!this.isDisabled()) { + if (!this.worldObj.isRemote) { + if (this.canWork()) { + double var10000 = super.wattsReceived; + this.getClass(); + if (var10000 >= 10000.0D) { + if (this.smeltingTicks == 0) { + this.getClass(); + this.smeltingTicks = 1200; + } + + if (this.smeltingTicks > 0) { + --this.smeltingTicks; + if (this.smeltingTicks < 1) { + this.work(); + this.smeltingTicks = 0; + } + } else { + this.smeltingTicks = 0; + } + + super.wattsReceived = 0.0D; + } + } else { + this.smeltingTicks = 0; + } + + if (super.ticks % 10L == 0L) { + this.worldObj.markBlockForUpdate(this.xCoord, this.yCoord, + this.zCoord); + } + } + + if (this.worldObj.isRemote && this.smeltingTicks > 0) { + if (super.ticks % 600L == 0L) { + this.worldObj.playSoundEffect( + (double)this.xCoord, (double)this.yCoord, (double)this.zCoord, + SoundManager.ASSEMBLER, 0.7F, 1.0F); + } + + this.rotationYaw1 += 3.0F; + this.rotationYaw2 += 2.0F; + ++this.rotationYaw3; + ItemStack var3 = this.getStackInSlot(6); + if (var3 != null) { + var3 = var3.copy(); + var3.stackSize = 1; + if (this.entityItem == null) { + this.entityItem = + new EntityItem(this.worldObj, 0.0D, 0.0D, 0.0D, var3); + } else if (!var3.isItemEqual(this.entityItem.getEntityItem())) { + this.entityItem = + new EntityItem(this.worldObj, 0.0D, 0.0D, 0.0D, var3); + } + + ++this.entityItem.age; + } else { + this.entityItem = null; + } + } + } + } + + public ElectricityPack getRequest() { + return this.canWork() + ? new ElectricityPack(10000.0D / this.getVoltage(), this.getVoltage()) + : new ElectricityPack(); + } + + @Override + public void onDataPacket(NetworkManager arg0, + S35PacketUpdateTileEntity arg1) { + NBTTagCompound nbt = arg1.func_148857_g(); + + this.smeltingTicks = nbt.getInteger("smeltingTicks"); + super.disabledTicks = nbt.getInteger("disabledTicks"); + } + + @Override + public Packet getDescriptionPacket() { + NBTTagCompound nbt = new NBTTagCompound(); + + nbt.setInteger("smeltingTicks", this.smeltingTicks); + nbt.setInteger("disabledTicks", super.disabledTicks); + + return new S35PacketUpdateTileEntity(this.xCoord, this.yCoord, this.zCoord, + this.getBlockMetadata(), nbt); + } + + public void openInventory() { + if (!this.worldObj.isRemote) { + this.worldObj.markBlockForUpdate(this.xCoord, this.yCoord, this.zCoord); + } + } + + public boolean canWork() { + if (super.containingItems[6] != null) { + for (int i = 0; i < 6; ++i) { + if (super.containingItems[i] == null) { + return false; + } + + if (super.containingItems[i].getItem() != + AtomicScience.itCellStrangeMatter) { + return false; + } + } + + return super.containingItems[6].stackSize < 64; + } else { + return false; + } + } + + public void work() { + if (this.canWork()) { + for (int i = 0; i < 5; ++i) { + if (super.containingItems[i] != null) { + super.containingItems[i].setItemDamage( + super.containingItems[i].getItemDamage() + 1); + if (super.containingItems[i].getItemDamage() >= 64) { + super.containingItems[i] = null; + } + } + } + + if (super.containingItems[6] != null) { + ++super.containingItems[6].stackSize; + } + } + } + + public void readFromNBT(NBTTagCompound nbt) { + super.readFromNBT(nbt); + this.smeltingTicks = nbt.getInteger("smeltingTicks"); + } + + public void writeToNBT(NBTTagCompound nbt) { + super.writeToNBT(nbt); + nbt.setInteger("smeltingTicks", this.smeltingTicks); + } + + public double getVoltage() { + return UniversalElectricity.isVoltageSensitive ? 480.0D : 120.0D; + } + + public int getSizeInventory() { return 7; } + + public boolean isItemValidForSlot(int slotID, ItemStack itemStack) { + return slotID == 6 + ? true + : itemStack.getItem() == AtomicScience.itCellStrangeMatter; + } +} diff --git a/src/main/java/atomicscience/TAutoBuilder.java b/src/main/java/atomicscience/TAutoBuilder.java new file mode 100644 index 0000000..d9c1af0 --- /dev/null +++ b/src/main/java/atomicscience/TAutoBuilder.java @@ -0,0 +1,350 @@ +package atomicscience; + +import net.minecraft.init.Blocks; +import universalelectricity.core.vector.Vector3; +import universalelectricity.prefab.tile.TileEntityAdvanced; + +public class TAutoBuilder + extends TileEntityAdvanced { + public boolean canUpdate() { return false; } + + public void onActivatePacket(TAutoBuilder.AutoBuilderType type, int radius) { + if (!this.worldObj.isRemote) { + try { + Vector3 diDian = new Vector3(this); + if (radius > 0) { + int r; + int x; + int z; + Vector3 targetPosition; + Vector3 targetPosition1; + byte var16; + int var17; + switch (TAutoBuilder.NamelessClass2141744605 + .$SwitchMap$atomicscience$TJianLi$JianLiType + [type.ordinal()]) { + case 1: + r = radius; + + for (x = -radius; x < r; ++x) { + for (z = -r; z < r; ++z) { + for (var17 = -1; var17 <= 1; ++var17) { + targetPosition1 = diDian.clone(); + targetPosition1.add( + new Vector3((double)x, (double)var17, (double)z)); + if (x == -r || x == r - 1 || z == -r || z == r - 1) { + targetPosition1.setBlock( + this.worldObj, AtomicScience.bElectromagnet); + } + } + } + } + + r = radius - 2; + + for (x = -r; x < r; ++x) { + for (z = -r; z < r; ++z) { + for (var17 = -1; var17 <= 1; ++var17) { + if (x == -r || x == r - 1 || z == -r || z == r - 1) { + targetPosition1 = diDian.clone(); + targetPosition1.add( + new Vector3((double)x, (double)var17, (double)z)); + targetPosition1.setBlock( + this.worldObj, AtomicScience.bElectromagnet); + } + } + } + } + + r = radius - 1; + + for (x = -r; x < r; ++x) { + for (z = -r; z < r; ++z) { + for (var17 = -1; var17 <= 1; ++var17) { + if (x == -r || x == r - 1 || z == -r || z == r - 1) { + targetPosition1 = diDian.clone(); + targetPosition1.add( + new Vector3((double)x, (double)var17, (double)z)); + if (var17 != -1 && var17 != 1) { + if (var17 == 0) { + targetPosition1.setBlock(this.worldObj, Blocks.air); + } + } else { + targetPosition1.setBlock( + this.worldObj, + AtomicScience.bElectromagnetGlass); + } + } + } + } + } + + return; + case 2: + if (radius <= 1) { + var16 = 2; + + for (x = -var16; x <= var16; ++x) { + for (z = -var16; z <= var16; ++z) { + targetPosition = + (new Vector3((double)x, 0.0D, (double)z)).add(diDian); + targetPosition.setBlock(this.worldObj, + Blocks.water); + } + } + + r = var16 - 1; + + for (x = -r; x <= r; ++x) { + for (z = -r; z <= r; ++z) { + targetPosition = + (new Vector3((double)x, 1.0D, (double)z)).add(diDian); + targetPosition.setBlock(this.worldObj, + AtomicScience.bTurbine); + if ((x != -r && x != r || z != -r && z != r) && + (new Vector3((double)x, 0.0D, (double)z)) + .getMagnitude() <= 1.0D) { + targetPosition = + (new Vector3((double)x, -1.0D, (double)z)).add(diDian); + targetPosition.setBlock( + this.worldObj, + AtomicScience.bControlRod); + targetPosition.add(new Vector3(0.0D, -1.0D, 0.0D)); + targetPosition.setBlock( + this.worldObj, Blocks.sticky_piston, 1); + } + } + } + + Vector3.add(diDian, new Vector3(0.0D, -1.0D, 0.0D)) + .setBlock(this.worldObj, + AtomicScience.bThermometer); + Vector3.add(diDian, new Vector3(0.0D, -3.0D, 0.0D)) + .setBlock(this.worldObj, AtomicScience.bSiren); + Vector3.add(diDian, new Vector3(0.0D, -2.0D, 0.0D)) + .setBlock(this.worldObj, Blocks.redstone_wire); + diDian.setBlock(this.worldObj, + AtomicScience.bFissionReactor); + break; + } else { + var16 = 2; + + for (x = 0; x < radius; ++x) { + for (z = -var16; z <= var16; ++z) { + for (var17 = -var16; var17 <= var16; ++var17) { + targetPosition1 = + (new Vector3((double)z, (double)x, (double)var17)) + .add(diDian); + Vector3 leveledDiDian = + Vector3.add(diDian, new Vector3(0.0D, (double)x, 0.0D)); + if (x < radius - 1) { + if (targetPosition1.distanceTo(leveledDiDian) == 2.0D) { + targetPosition1.setBlock( + this.worldObj, + AtomicScience.bControlRod); + } else if (z != -var16 && z != var16 && var17 != -var16 && + var17 != var16) { + if (z == 0 && var17 == 0) { + targetPosition1.setBlock( + this.worldObj, + AtomicScience.bFissionReactor); + } else { + targetPosition1.setBlock( + this.worldObj, + Blocks.water); + } + } else { + targetPosition1.setBlock( + this.worldObj, Blocks.glass); + } + } else if (targetPosition1.distanceTo(leveledDiDian) < + 2.0D) { + targetPosition1.setBlock( + this.worldObj, AtomicScience.bTurbine); + } + } + } + } + + return; + } + case 3: + r = Math.max(radius, 2); + + for (x = -r; x <= r; ++x) { + for (z = -r; z <= r; ++z) { + targetPosition = + (new Vector3((double)x, 0.0D, (double)z)).add(diDian); + targetPosition.setBlock(this.worldObj, + Blocks.water); + } + } + + --r; + + for (x = -r; x <= r; ++x) { + for (z = -r; z <= r; ++z) { + targetPosition = + (new Vector3((double)x, 1.0D, (double)z)).add(diDian); + if ((new Vector3((double)x, 0.0D, (double)z)).getMagnitude() <= + 2.0D) { + if ((x == -r || x == r) && (z == -r || z == r)) { + targetPosition = + (new Vector3((double)x, -1.0D, (double)z)).add(diDian); + targetPosition.setBlock( + this.worldObj, + AtomicScience.bControlRod); + targetPosition.add(new Vector3(0.0D, -1.0D, 0.0D)); + targetPosition.setBlock( + this.worldObj, Blocks.sticky_piston, 1); + } else { + targetPosition = + (new Vector3((double)x, 0.0D, (double)z)).add(diDian); + targetPosition.setBlock(this.worldObj, + AtomicScience.bFissionReactor); + targetPosition = + (new Vector3((double)x, -1.0D, (double)z)).add(diDian); + targetPosition.setBlock( + this.worldObj, + AtomicScience.bThermometer); + targetPosition = + (new Vector3((double)x, -3.0D, (double)z)).add(diDian); + targetPosition.setBlock( + this.worldObj, AtomicScience.bSiren); + targetPosition = + (new Vector3((double)x, -2.0D, (double)z)).add(diDian); + targetPosition.setBlock( + this.worldObj, Blocks.redstone_wire); + } + } + } + } + + Vector3.add(diDian, new Vector3(0.0D, -3.0D, 0.0D)) + .setBlock(this.worldObj, Blocks.stone); + Vector3.add(diDian, new Vector3(0.0D, -2.0D, 0.0D)) + .setBlock(this.worldObj, Blocks.stone); + diDian.setBlock(this.worldObj, AtomicScience.bFissionReactor); + break; + case 4: + r = Math.max(radius, 1); + + for (x = -r; x <= r; ++x) { + for (z = -r; z <= r; ++z) { + targetPosition = new Vector3((double)x, 0.0D, (double)z); + if (targetPosition.getMagnitude() > 1.0D) { + if (targetPosition.getMagnitude() < (double)r) { + targetPosition = + (new Vector3((double)x, 1.0D, (double)z)).add(diDian); + targetPosition.setBlock( + this.worldObj, AtomicScience.bElectromagnet); + targetPosition = + (new Vector3((double)x, -1.0D, (double)z)).add(diDian); + targetPosition.setBlock( + this.worldObj, AtomicScience.bElectromagnet); + targetPosition = + (new Vector3((double)x, 2.0D, (double)z)).add(diDian); + targetPosition.setBlock(this.worldObj, + Blocks.water); + targetPosition = + (new Vector3((double)x, 3.0D, (double)z)).add(diDian); + targetPosition.setBlock( + this.worldObj, AtomicScience.bTurbine); + } else if (targetPosition.getMagnitude() - 0.7D < (double)r) { + targetPosition = + (new Vector3((double)x, 0.0D, (double)z)).add(diDian); + targetPosition.setBlock( + this.worldObj, + AtomicScience.bElectromagnetGlass); + targetPosition = + (new Vector3((double)x, 2.0D, (double)z)).add(diDian); + targetPosition.setBlock( + this.worldObj, + AtomicScience.bElectromagnetGlass); + } + } + } + } + + var16 = 1; + + for (x = -var16; x <= var16; ++x) { + for (z = -var16; z <= var16; ++z) { + targetPosition = + (new Vector3((double)x, 0.0D, (double)z)).add(diDian); + targetPosition.setBlock(this.worldObj, + AtomicScience.bElectromagnet); + } + } + + diDian.setBlock(this.worldObj, + AtomicScience.bFusionReactor); + } + } + } catch (Exception var15) { + var15.printStackTrace(); + } + } + } + + // $FF: synthetic class + static class NamelessClass2141744605 { + + // $FF: synthetic field + static final int[] $SwitchMap$atomicscience$TJianLi$JianLiType = + new int[TAutoBuilder.AutoBuilderType.values().length]; + + static { + try { + $SwitchMap$atomicscience$TJianLi$JianLiType[TAutoBuilder.AutoBuilderType + .JIA_SU_QI.ordinal()] = + 1; + } catch (NoSuchFieldError var4) { + ; + } + + try { + $SwitchMap$atomicscience$TJianLi$JianLiType[TAutoBuilder.AutoBuilderType + .FEN_LIE.ordinal()] = 2; + } catch (NoSuchFieldError var3) { + ; + } + + try { + $SwitchMap$atomicscience$TJianLi$JianLiType[TAutoBuilder.AutoBuilderType + .HUAN_YUAN.ordinal()] = + 3; + } catch (NoSuchFieldError var2) { + ; + } + + try { + $SwitchMap$atomicscience$TJianLi$JianLiType[TAutoBuilder.AutoBuilderType + .HE_CHENG.ordinal()] = + 4; + } catch (NoSuchFieldError var1) { + ; + } + } + } + + public static enum AutoBuilderType { + + JIA_SU_QI("Particle Accelerator"), + FEN_LIE("Fission Reactor"), + HE_CHENG("Fusion Reactor"), + HUAN_YUAN("Breeder Reactor"); + + public final String name; + + private AutoBuilderType(String name) { this.name = name; } + + public static TAutoBuilder.AutoBuilderType get(int id) { + return id >= 0 && id < values().length ? values()[id] : null; + } + + public TAutoBuilder.AutoBuilderType next() { + return values()[(this.ordinal() + 1) % values().length]; + } + } +} diff --git a/src/main/java/atomicscience/TabAS.java b/src/main/java/atomicscience/TabAS.java new file mode 100644 index 0000000..22ecc9e --- /dev/null +++ b/src/main/java/atomicscience/TabAS.java @@ -0,0 +1,18 @@ +package atomicscience; + +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.item.Item; + +public class TabAS extends CreativeTabs { + + public static final TabAS INSTANCE = new TabAS("atomicscience"); + + + public TabAS(String par2Str) { + super(CreativeTabs.getNextID(), par2Str); + } + + public Item getTabIconItem() { + return Item.getItemFromBlock(AtomicScience.bFusionReactor); + } +} diff --git a/src/main/java/atomicscience/accelerator.ogg b/src/main/java/atomicscience/accelerator.ogg new file mode 100644 index 0000000..66c7ddd Binary files /dev/null and b/src/main/java/atomicscience/accelerator.ogg differ diff --git a/src/main/java/atomicscience/alarm.ogg b/src/main/java/atomicscience/alarm.ogg new file mode 100644 index 0000000..7ffd3a8 Binary files /dev/null and b/src/main/java/atomicscience/alarm.ogg differ diff --git a/src/main/java/atomicscience/antimatter.ogg b/src/main/java/atomicscience/antimatter.ogg new file mode 100644 index 0000000..0b0df33 Binary files /dev/null and b/src/main/java/atomicscience/antimatter.ogg differ diff --git a/src/main/java/atomicscience/api/AtomicScience.java b/src/main/java/atomicscience/api/AtomicScience.java new file mode 100644 index 0000000..1fdc223 --- /dev/null +++ b/src/main/java/atomicscience/api/AtomicScience.java @@ -0,0 +1,17 @@ +package atomicscience.api; + +import cpw.mods.fml.common.Loader; +import net.minecraftforge.common.config.Configuration; + +import java.io.File; + +public class AtomicScience { + + public static final String MAJOR_VERSION = "0"; + public static final String MINOR_VERSION = "6"; + public static final String REVISION_VERSION = "2"; + public static final String BUILD_VERSION = "117"; + public static final String VERSION = "0.6.2"; + public static final String NAME = "Atomic Science"; + public static final Configuration CONFIGURATION = new Configuration(new File(Loader.instance().getConfigDir(), "AtomicScience.cfg")); +} diff --git a/src/main/java/atomicscience/api/BlockRadioactive.java b/src/main/java/atomicscience/api/BlockRadioactive.java new file mode 100644 index 0000000..f222338 --- /dev/null +++ b/src/main/java/atomicscience/api/BlockRadioactive.java @@ -0,0 +1,141 @@ +package atomicscience.api; + +import atomicscience.api.poison.PoisonRadiation; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import java.util.List; +import java.util.Random; +import net.minecraft.block.Block; +import net.minecraft.block.material.Material; +import net.minecraft.client.Minecraft; +import net.minecraft.client.particle.EntitySmokeFX; +import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.entity.Entity; +import net.minecraft.entity.EntityLiving; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.init.Blocks; +import net.minecraft.util.AxisAlignedBB; +import net.minecraft.util.IIcon; +import net.minecraft.world.World; +import universalelectricity.core.vector.Vector3; + +public class BlockRadioactive extends Block { + + public static int RECOMMENDED_ID = 3768; + public boolean canSpread; + public float radius; + public int amplifier; + public boolean canWalkPoison; + public boolean isRandomlyRadioactive; + private IIcon iconTop; + private IIcon iconBottom; + + public BlockRadioactive(Material material) { + super(material); + this.canSpread = true; + this.radius = 5.0F; + this.amplifier = 2; + this.canWalkPoison = true; + this.isRandomlyRadioactive = true; + this.setTickRandomly(true); + this.setHardness(0.2F); + this.setLightLevel(0.1F); + } + + public BlockRadioactive() { + this(Material.rock); + } + + @Override + public IIcon getIcon(int side, int metadata) { + return side == 1 ? this.iconTop + : (side == 0 ? this.iconBottom : this.blockIcon); + } + + @Override + @SideOnly(Side.CLIENT) + public void registerBlockIcons(IIconRegister iconRegister) { + super.registerBlockIcons(iconRegister); + this.iconTop = iconRegister.registerIcon( + this.getUnlocalizedName().replace("tile.", "") + "_top"); + this.iconBottom = iconRegister.registerIcon( + this.getUnlocalizedName().replace("tile.", "") + "_bottom"); + } + + @Override + public void onBlockClicked(World world, int x, int y, int z, + EntityPlayer par5EntityPlayer) { + if ((double) world.rand.nextFloat() > 0.8D) { + this.updateTick(world, x, y, z, world.rand); + } + } + + @Override + public void updateTick(World world, int x, int y, int z, Random rand) { + if (!world.isRemote) { + if (this.isRandomlyRadioactive) { + AxisAlignedBB i = AxisAlignedBB.getBoundingBox( + (double) ((float) x - this.radius), (double) ((float) y - this.radius), + (double) ((float) z - this.radius), (double) ((float) x + this.radius), + (double) ((float) y + this.radius), (double) ((float) z + this.radius)); + List newX = world.getEntitiesWithinAABB(EntityLiving.class, i); + + for (EntityLiving newZ : newX) { + PoisonRadiation.INSTANCE.poisonEntity( + new Vector3((double) x, (double) y, (double) z), newZ, + this.amplifier); + } + } + + if (this.canSpread) { + for (int var11 = 0; var11 < 4; ++var11) { + int xOffset = x + rand.nextInt(3) - 1; + int yOffset = y + rand.nextInt(5) - 3; + int zOffset = z + rand.nextInt(3) - 1; + Block block = world.getBlock(xOffset, yOffset, zOffset); + if ((double) rand.nextFloat() > 0.4D && + (block == Blocks.farmland || block == Blocks.grass)) { + world.setBlock(xOffset, yOffset, zOffset, this); + } + } + + if ((double) rand.nextFloat() > 0.85D) { + world.setBlock(x, y, z, Blocks.mycelium); + } + } + } + } + + public void func_71891_b(World par1World, int x, int y, int z, + Entity par5Entity) { + if (par5Entity instanceof EntityLiving && this.canWalkPoison) { + PoisonRadiation.INSTANCE.poisonEntity( + new Vector3((double) x, (double) y, (double) z), + (EntityLiving) par5Entity); + } + } + + public int func_71925_a(Random par1Random) { + return 0; + } + + @SideOnly(Side.CLIENT) + public void func_71862_a(World world, int x, int y, int z, + Random par5Random) { + if (Minecraft.getMinecraft().gameSettings.particleSetting == 0) { + byte radius = 3; + + for (int i = 0; i < 2; ++i) { + Vector3 diDian = new Vector3((double) x, (double) y, (double) z); + diDian.x += Math.random() * (double) radius - (double) (radius / 2); + diDian.y += Math.random() * (double) radius - (double) (radius / 2); + diDian.z += Math.random() * (double) radius - (double) (radius / 2); + EntitySmokeFX fx = new EntitySmokeFX( + world, diDian.x, diDian.y, diDian.z, (Math.random() - 0.5D) / 2.0D, + (Math.random() - 0.5D) / 2.0D, (Math.random() - 0.5D) / 2.0D); + fx.setRBGColorF(0.2F, 0.8F, 0.0F); + Minecraft.getMinecraft().effectRenderer.addEffect(fx); + } + } + } +} diff --git a/src/main/java/atomicscience/api/IAntiPoisonArmor.java b/src/main/java/atomicscience/api/IAntiPoisonArmor.java new file mode 100644 index 0000000..fc05b65 --- /dev/null +++ b/src/main/java/atomicscience/api/IAntiPoisonArmor.java @@ -0,0 +1,14 @@ +package atomicscience.api; + +import atomicscience.api.poison.Poison; +import net.minecraft.entity.EntityLivingBase; +import net.minecraft.item.ItemStack; + +public interface IAntiPoisonArmor { + + boolean isProtectedFromPoison(ItemStack var1, EntityLivingBase var2, Poison var3); + + void onProtectFromPoison(ItemStack var1, EntityLivingBase var2, Poison var3); + + Poison.ArmorType getArmorType(); +} diff --git a/src/main/java/atomicscience/api/IAntiPoisonBlock.java b/src/main/java/atomicscience/api/IAntiPoisonBlock.java new file mode 100644 index 0000000..c013b03 --- /dev/null +++ b/src/main/java/atomicscience/api/IAntiPoisonBlock.java @@ -0,0 +1,9 @@ +package atomicscience.api; + +import atomicscience.api.poison.Poison; +import net.minecraft.world.World; + +public interface IAntiPoisonBlock { + + boolean isPoisonPrevention(World var1, int var2, int var3, int var4, Poison var5); +} diff --git a/src/main/java/atomicscience/api/IElectromagnet.java b/src/main/java/atomicscience/api/IElectromagnet.java new file mode 100644 index 0000000..7b92be0 --- /dev/null +++ b/src/main/java/atomicscience/api/IElectromagnet.java @@ -0,0 +1,8 @@ +package atomicscience.api; + +import net.minecraft.world.World; + +public interface IElectromagnet { + + boolean isRunning(World var1, int var2, int var3, int var4); +} diff --git a/src/main/java/atomicscience/api/IFissileMaterial.java b/src/main/java/atomicscience/api/IFissileMaterial.java new file mode 100644 index 0000000..174c7e7 --- /dev/null +++ b/src/main/java/atomicscience/api/IFissileMaterial.java @@ -0,0 +1,8 @@ +package atomicscience.api; + +import atomicscience.api.ITemperature; + +public interface IFissileMaterial { + + int onFissile(ITemperature var1); +} diff --git a/src/main/java/atomicscience/api/IHeatSource.java b/src/main/java/atomicscience/api/IHeatSource.java new file mode 100644 index 0000000..14a3f7d --- /dev/null +++ b/src/main/java/atomicscience/api/IHeatSource.java @@ -0,0 +1,6 @@ +package atomicscience.api; + +import atomicscience.api.ITemperature; + +public interface IHeatSource extends ITemperature { +} diff --git a/src/main/java/atomicscience/api/IReactor.java b/src/main/java/atomicscience/api/IReactor.java new file mode 100644 index 0000000..1e85b0e --- /dev/null +++ b/src/main/java/atomicscience/api/IReactor.java @@ -0,0 +1,7 @@ +package atomicscience.api; + + +public interface IReactor { + + boolean isOverToxic(); +} diff --git a/src/main/java/atomicscience/api/ISteamReceptor.java b/src/main/java/atomicscience/api/ISteamReceptor.java new file mode 100644 index 0000000..057cbed --- /dev/null +++ b/src/main/java/atomicscience/api/ISteamReceptor.java @@ -0,0 +1,7 @@ +package atomicscience.api; + + +public interface ISteamReceptor { + + void onReceiveSteam(int var1); +} diff --git a/src/main/java/atomicscience/api/ITemperature.java b/src/main/java/atomicscience/api/ITemperature.java new file mode 100644 index 0000000..943e2fa --- /dev/null +++ b/src/main/java/atomicscience/api/ITemperature.java @@ -0,0 +1,9 @@ +package atomicscience.api; + + +public interface ITemperature { + + float getTemperature(); + + void setTemperature(float var1); +} diff --git a/src/main/java/atomicscience/api/Plasma.java b/src/main/java/atomicscience/api/Plasma.java new file mode 100644 index 0000000..4505c99 --- /dev/null +++ b/src/main/java/atomicscience/api/Plasma.java @@ -0,0 +1,17 @@ +package atomicscience.api; + +import net.minecraft.world.World; + +public class Plasma { + + public static Plasma.IPlasma blockPlasma; + + + + public interface IPlasma { + + void spawn(World var1, int var2, int var3, int var4, byte var5); + + boolean canPlace(World var1, int var2, int var3, int var4); + } +} diff --git a/src/main/java/atomicscience/api/poison/Poison.java b/src/main/java/atomicscience/api/poison/Poison.java new file mode 100644 index 0000000..81abe27 --- /dev/null +++ b/src/main/java/atomicscience/api/poison/Poison.java @@ -0,0 +1,77 @@ +package atomicscience.api.poison; + +import atomicscience.api.IAntiPoisonArmor; +import java.util.EnumSet; +import net.minecraft.entity.EntityLiving; +import net.minecraft.entity.EntityLivingBase; +import net.minecraft.entity.player.EntityPlayer; +import universalelectricity.core.vector.Vector3; + +public abstract class Poison { + + public static Poison[] list = new Poison[32]; + protected String name; + protected EnumSet armorRequired; + + public Poison(String name, int id) { + this.armorRequired = EnumSet.range(Poison.ArmorType.HELM, Poison.ArmorType.BOOTS); + this.name = name; + if (list == null) { + list = new Poison[32]; + } + + list[0] = this; + } + + public String getName() { + return this.name; + } + + public EnumSet getArmorRequired() { + return this.armorRequired; + } + + public void poisonEntity(Vector3 emitPosition, EntityLivingBase entity, + int amplifier) { + EnumSet armorWorn = EnumSet.of(Poison.ArmorType.UNKNOWN); + if (entity instanceof EntityPlayer) { + EntityPlayer entityPlayer = (EntityPlayer) entity; + + for (int i = 0; i < entityPlayer.inventory.armorInventory.length; ++i) { + if (entityPlayer.inventory.armorInventory[i] != null && + entityPlayer.inventory.armorInventory[i].getItem() instanceof IAntiPoisonArmor && + ((IAntiPoisonArmor) entityPlayer.inventory.armorInventory[i] + .getItem()) + .isProtectedFromPoison(entityPlayer.inventory.armorInventory[i], + entity, this)) { + ((IAntiPoisonArmor) entityPlayer.inventory.armorInventory[i].getItem()) + .onProtectFromPoison(entityPlayer.inventory.armorInventory[i], + entity, this); + armorWorn.add( + ((IAntiPoisonArmor) entityPlayer.inventory.armorInventory[i] + .getItem()) + .getArmorType()); + } + } + } + + if (!armorWorn.containsAll(this.armorRequired)) { + this.doPoisonEntity(emitPosition, entity, armorWorn, amplifier); + } + } + + public void poisonEntity(Vector3 emitPosition, EntityLivingBase entity) { + this.poisonEntity(emitPosition, entity, 0); + } + + protected abstract void doPoisonEntity(Vector3 var1, EntityLivingBase var2, + EnumSet var3, int var4); + + public static enum ArmorType { + HELM, + BODY, + LEGGINGS, + BOOTS, + UNKNOWN; + } +} diff --git a/src/main/java/atomicscience/api/poison/PoisonRadiation.java b/src/main/java/atomicscience/api/poison/PoisonRadiation.java new file mode 100644 index 0000000..21fc3af --- /dev/null +++ b/src/main/java/atomicscience/api/poison/PoisonRadiation.java @@ -0,0 +1,66 @@ +package atomicscience.api.poison; + +import atomicscience.api.IAntiPoisonBlock; +import java.util.EnumSet; +import net.minecraft.block.Block; +import net.minecraft.entity.EntityLivingBase; +import net.minecraft.init.Blocks; +import net.minecraft.world.World; +import universalelectricity.core.vector.Vector3; +import universalelectricity.prefab.CustomDamageSource; +import universalelectricity.prefab.potion.CustomPotionEffect; + +public class PoisonRadiation extends Poison { + + public static final Poison INSTANCE = new PoisonRadiation("radiation", 0); + public static final CustomDamageSource damageSource = (CustomDamageSource) (new CustomDamageSource("radiation")) + .setDamageBypassesArmor(); + public static boolean disabled = false; + + public PoisonRadiation(String name, int id) { + super(name, id); + } + + @Override + protected void doPoisonEntity(Vector3 emitPosition, EntityLivingBase entity, + EnumSet armorWorn, + int amplifier) { + if (!disabled) { + if (emitPosition == null) { + entity.addPotionEffect( + new CustomPotionEffect(PotionRadiation.INSTANCE.getId(), + 300 * (amplifier + 1), amplifier, null)); + return; + } + + if (this.getAntiRadioactiveCount(entity.worldObj, emitPosition, + new Vector3(entity)) <= amplifier) { + entity.addPotionEffect( + new CustomPotionEffect(PotionRadiation.INSTANCE.getId(), + 400 * (amplifier + 1), amplifier, null)); + } + } + } + + public int getAntiRadioactiveCount(World world, Vector3 startingPosition, + Vector3 endingPosition) { + Vector3 delta = Vector3.subtract(endingPosition, startingPosition).normalize(); + Vector3 targetPosition = startingPosition.clone(); + double totalDistance = startingPosition.distanceTo(endingPosition); + int count = 0; + if (totalDistance > 1.0D) { + for (; targetPosition.distanceTo(endingPosition) <= totalDistance; targetPosition.add(delta)) { + Block block = targetPosition.getBlock(world); + if (block != Blocks.air && block instanceof IAntiPoisonBlock && + ((IAntiPoisonBlock) block) + .isPoisonPrevention(world, targetPosition.intX(), + targetPosition.intY(), + targetPosition.intZ(), this)) { + ++count; + } + } + } + + return count; + } +} diff --git a/src/main/java/atomicscience/api/poison/PotionRadiation.java b/src/main/java/atomicscience/api/poison/PotionRadiation.java new file mode 100644 index 0000000..416ba3e --- /dev/null +++ b/src/main/java/atomicscience/api/poison/PotionRadiation.java @@ -0,0 +1,38 @@ +package atomicscience.api.poison; + +import atomicscience.api.AtomicScience; +import net.minecraft.entity.EntityLivingBase; +import net.minecraft.entity.player.EntityPlayer; +import universalelectricity.prefab.potion.CustomPotion; + +public class PotionRadiation extends CustomPotion { + public static final PotionRadiation INSTANCE; + + public PotionRadiation(int id, boolean isBadEffect, int color, String name) { + super(AtomicScience.CONFIGURATION.get("Potion", name + " potion ID", id) + .getInt(id), + isBadEffect, color, name); + this.setIconIndex(6, 0); + } + + @Override + public void performEffect(EntityLivingBase entity, int amplifier) { + if ((double) entity.worldObj.rand.nextFloat() > 0.9D - (double) amplifier * 0.08D) { + entity.attackEntityFrom(PoisonRadiation.damageSource, 1); + if (entity instanceof EntityPlayer) { + ((EntityPlayer) entity) + .addExhaustion(0.01F * (float) (amplifier + 1)); + } + } + } + + public boolean isReady(int duration, int amplifier) { + return duration % 10 == 0; + } + + static { + AtomicScience.CONFIGURATION.load(); + INSTANCE = new PotionRadiation(21, true, 5149489, "radiation"); + AtomicScience.CONFIGURATION.save(); + } +} diff --git a/src/main/java/atomicscience/assembler.ogg b/src/main/java/atomicscience/assembler.ogg new file mode 100644 index 0000000..4ba6769 Binary files /dev/null and b/src/main/java/atomicscience/assembler.ogg differ diff --git a/src/main/java/atomicscience/fanwusu/BAccelerator.java b/src/main/java/atomicscience/fanwusu/BAccelerator.java new file mode 100644 index 0000000..f054b84 --- /dev/null +++ b/src/main/java/atomicscience/fanwusu/BAccelerator.java @@ -0,0 +1,34 @@ +package atomicscience.fanwusu; + +import atomicscience.CommonProxy; +import atomicscience.AtomicScience; +import atomicscience.api.IElectromagnet; +import atomicscience.jiqi.BBaseRotatable; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; +import universalelectricity.core.UniversalElectricity; + +public class BAccelerator extends BBaseRotatable implements IElectromagnet { + + public BAccelerator() { + super("accelerator", UniversalElectricity.machine); + } + + public boolean onMachineActivated(World par1World, int x, int y, int z, EntityPlayer par5EntityPlayer, int side, float hitX, float hitY, float hitZ) { + par1World.getBlockMetadata(x, y, z); + if(!par1World.isRemote) { + par5EntityPlayer.openGui(AtomicScience.instance, CommonProxy.GuiType.JIA_SU_QI.ordinal(), par1World, x, y, z); + } + + return true; + } + + public TileEntity createNewTileEntity(World world, int meta) { + return new TAccelerator(); + } + + public boolean isRunning(World world, int x, int y, int z) { + return true; + } +} diff --git a/src/main/java/atomicscience/fanwusu/BFulminationGenerator.java b/src/main/java/atomicscience/fanwusu/BFulminationGenerator.java new file mode 100644 index 0000000..61dcf7e --- /dev/null +++ b/src/main/java/atomicscience/fanwusu/BFulminationGenerator.java @@ -0,0 +1,18 @@ +package atomicscience.fanwusu; + +import atomicscience.fanwusu.TFulminationGenerator; +import atomicscience.jiqi.BBase; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; + +public class BFulminationGenerator extends BBase { + + public BFulminationGenerator() { + super("fulmination"); + this.setHardness(50.0F); + } + + public TileEntity createNewTileEntity(World world, int meta) { + return new TFulminationGenerator(); + } +} diff --git a/src/main/java/atomicscience/fanwusu/CAccelerator.java b/src/main/java/atomicscience/fanwusu/CAccelerator.java new file mode 100644 index 0000000..baef626 --- /dev/null +++ b/src/main/java/atomicscience/fanwusu/CAccelerator.java @@ -0,0 +1,77 @@ +package atomicscience.fanwusu; + +import atomicscience.AtomicScience; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.entity.player.InventoryPlayer; +import net.minecraft.inventory.Container; +import net.minecraft.inventory.Slot; +import net.minecraft.inventory.SlotFurnace; +import net.minecraft.item.ItemStack; + +public class CAccelerator extends Container { + private TAccelerator tileEntity; + + public CAccelerator(InventoryPlayer par1InventoryPlayer, TAccelerator tileEntity) { + this.tileEntity = tileEntity; + this.addSlotToContainer(new Slot(tileEntity, 0, 132, 24)); + this.addSlotToContainer(new Slot(tileEntity, 1, 132, 51)); + this.addSlotToContainer(new SlotFurnace(par1InventoryPlayer.player, tileEntity, 2, 152, 51)); + + int var3; + for(var3 = 0; var3 < 3; ++var3) { + for(int var4 = 0; var4 < 9; ++var4) { + this.addSlotToContainer(new Slot(par1InventoryPlayer, var4 + var3 * 9 + 9, 8 + var4 * 18, 84 + var3 * 18)); + } + } + + for(var3 = 0; var3 < 9; ++var3) { + this.addSlotToContainer(new Slot(par1InventoryPlayer, var3, 8 + var3 * 18, 142)); + } + + this.tileEntity.players.add(par1InventoryPlayer.player); + tileEntity.openInventory(); + } + + public void onContainerClosed(EntityPlayer entityplayer) { + super.onContainerClosed(entityplayer); + this.tileEntity.players.remove(entityplayer); + } + + public boolean canInteractWith(EntityPlayer par1EntityPlayer) { + return this.tileEntity.isUseableByPlayer(par1EntityPlayer); + } + + public ItemStack transferStackInSlot(EntityPlayer par1EntityPlayer, int par1) { + ItemStack var2 = null; + Slot var3 = (Slot)super.inventorySlots.get(par1); + if(var3 != null && var3.getHasStack()) { + ItemStack itemStack = var3.getStack(); + var2 = itemStack.copy(); + if(par1 > 2) { + if(itemStack.getItem() == AtomicScience.itCell) { + if(!this.mergeItemStack(itemStack, 1, 2, false)) { + return null; + } + } else if(!this.mergeItemStack(itemStack, 0, 1, false)) { + return null; + } + } else if(!this.mergeItemStack(itemStack, 3, 39, false)) { + return null; + } + + if(itemStack.stackSize == 0) { + var3.putStack((ItemStack)null); + } else { + var3.onSlotChanged(); + } + + if(itemStack.stackSize == var2.stackSize) { + return null; + } + + var3.onPickupFromSlot(par1EntityPlayer, itemStack); + } + + return var2; + } +} diff --git a/src/main/java/atomicscience/fanwusu/EMatter.java b/src/main/java/atomicscience/fanwusu/EMatter.java new file mode 100644 index 0000000..e19de62 --- /dev/null +++ b/src/main/java/atomicscience/fanwusu/EMatter.java @@ -0,0 +1,316 @@ +package atomicscience.fanwusu; + +import atomicscience.AtomicScience; +import atomicscience.api.IElectromagnet; +import atomicscience.api.poison.PoisonRadiation; +import cpw.mods.fml.common.registry.IEntityAdditionalSpawnData; +import io.netty.buffer.ByteBuf; + +import java.util.List; +import net.minecraft.block.Block; +import net.minecraft.entity.Entity; +import net.minecraft.entity.EntityLivingBase; +import net.minecraft.entity.item.EntityItem; +import net.minecraft.init.Blocks; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.AxisAlignedBB; +import net.minecraft.util.MathHelper; +import net.minecraft.world.ChunkCoordIntPair; +import net.minecraft.world.World; +import net.minecraftforge.common.ForgeChunkManager; +import net.minecraftforge.common.ForgeChunkManager.Ticket; +import net.minecraftforge.common.ForgeChunkManager.Type; +import net.minecraftforge.common.util.ForgeDirection; +import universalelectricity.core.vector.Vector3; +import universalelectricity.core.vector.VectorHelper; + +public class EMatter extends Entity implements IEntityAdditionalSpawnData { + + // private static final int FANG_XIANG_DATA = 20; + private int lastTurn; + private Vector3 jiQi; + private ForgeDirection fangXiang; + public Ticket youPiao; + + public EMatter(World par1World) { + super(par1World); + this.lastTurn = 60; + this.jiQi = new Vector3(); + this.fangXiang = ForgeDirection.NORTH; + this.setSize(0.2F, 0.2F); + super.renderDistanceWeight = 3.0D; + super.noClip = true; + super.ignoreFrustumCheck = true; + } + + public EMatter(World par1World, Vector3 diDian, Vector3 jiQi, + ForgeDirection direction) { + this(par1World); + this.setPosition(diDian.x, diDian.y, diDian.z); + this.jiQi = jiQi; + this.fangXiang = direction; + } + + public void writeSpawnData(ByteBuf data) { + data.writeInt(this.jiQi.intX()); + data.writeInt(this.jiQi.intY()); + data.writeInt(this.jiQi.intZ()); + data.writeInt(this.fangXiang.ordinal()); + } + + public void readSpawnData(ByteBuf data) { + this.jiQi.x = (double)data.readInt(); + this.jiQi.y = (double)data.readInt(); + this.jiQi.z = (double)data.readInt(); + this.fangXiang = ForgeDirection.getOrientation(data.readInt()); + } + + protected void entityInit() { + super.dataWatcher.addObject(20, Byte.valueOf((byte)3)); + if (this.youPiao == null) { + this.youPiao = ForgeChunkManager.requestTicket( + AtomicScience.instance, super.worldObj, Type.ENTITY); + this.youPiao.getModData(); + this.youPiao.bindEntity(this); + } + } + + public void onUpdate() { + if (super.ticksExisted % 10 == 0) { + super.worldObj.playSoundAtEntity( + this, "atomicscience.accelerator", 1.5F, + (float)(0.6000000238418579D + 0.4D * (this.getSuDu() / 1.0D))); + } + + TileEntity t = super.worldObj.getTileEntity( + this.jiQi.intX(), this.jiQi.intY(), this.jiQi.intZ()); + if (!(t instanceof TAccelerator)) { + this.setDead(); + } else { + TAccelerator tileEntity = (TAccelerator)t; + if (tileEntity.wuSu == null) { + tileEntity.wuSu = this; + } + + for (int jianKuai = -1; jianKuai < 1; ++jianKuai) { + for (int z = -1; z < 1; ++z) { + ForgeChunkManager.forceChunk( + this.youPiao, + new ChunkCoordIntPair(((int)super.posX >> 4) + jianKuai, + ((int)super.posZ >> 4) + z)); + } + } + + try { + if (!super.worldObj.isRemote) { + super.dataWatcher.updateObject( + 20, Byte.valueOf((byte)this.fangXiang.ordinal())); + } else { + this.fangXiang = ForgeDirection.getOrientation( + super.dataWatcher.getWatchableObjectByte(20)); + } + } catch (Exception var13) { + var13.printStackTrace(); + } + + double var14 = 6.99999975040555E-4D; + ForgeDirection zuoFangXiang = VectorHelper.getOrientationFromSide( + this.fangXiang, ForgeDirection.EAST); + Block zuoBlockID = super.worldObj.getBlock( + MathHelper.floor_double(super.posX + (double)zuoFangXiang.offsetX), + MathHelper.floor_double(super.posY), + MathHelper.floor_double(super.posZ + (double)zuoFangXiang.offsetZ)); + ForgeDirection youFangXiang = VectorHelper.getOrientationFromSide( + this.fangXiang, ForgeDirection.WEST); + Block youBlockID = super.worldObj.getBlock( + MathHelper.floor_double(super.posX + (double)youFangXiang.offsetX), + MathHelper.floor_double(super.posY), + MathHelper.floor_double(super.posZ + (double)youFangXiang.offsetZ)); + if ((zuoBlockID == Blocks.air || youBlockID == Blocks.air) && + this.lastTurn <= 0) { + var14 = this.turn(); + super.motionX = 0.0D; + super.motionY = 0.0D; + super.motionZ = 0.0D; + this.lastTurn = 40; + } + + --this.lastTurn; + if (canCunZai(super.worldObj, new Vector3(this), this.fangXiang) && + !super.isCollided) { + Vector3 dongLi = new Vector3(); + dongLi.modifyPositionFromSide(this.fangXiang); + dongLi.multiply(var14); + super.motionX = Math.min(dongLi.x + super.motionX, 1.0D); + super.motionY = Math.min(dongLi.y + super.motionY, 1.0D); + super.motionZ = Math.min(dongLi.z + super.motionZ, 1.0D); + super.isAirBorne = true; + super.lastTickPosX = super.posX; + super.lastTickPosY = super.posY; + super.lastTickPosZ = super.posZ; + super.posX += super.motionX; + super.posY += super.motionY; + super.posZ += super.motionZ; + this.setPosition(super.posX, super.posY, super.posZ); + if (super.lastTickPosX == super.posX && + super.lastTickPosY == super.posY && + super.lastTickPosZ == super.posZ && this.getSuDu() <= 0.0D && + this.lastTurn <= 0) { + this.setDead(); + } + + super.worldObj.spawnParticle("portal", super.posX, super.posY, + super.posZ, 0.0D, 0.0D, 0.0D); + super.worldObj.spawnParticle("largesmoke", super.posX, super.posY, + super.posZ, 0.0D, 0.0D, 0.0D); + if (super.ticksExisted % 10 == 0) { + float radius = 0.6F; + AxisAlignedBB bounds = AxisAlignedBB.getBoundingBox( + super.posX - (double)radius, super.posY - (double)radius, + super.posZ - (double)radius, super.posX + (double)radius, + super.posY + (double)radius, super.posZ + (double)radius); + List entitiesNearby = + super.worldObj.getEntitiesWithinAABB(Entity.class, bounds); + if (entitiesNearby.size() > 1) { + this.explode(); + return; + } + } + + } else { + this.explode(); + } + } + } + + private double turn() { + ForgeDirection zuoFangXiang = VectorHelper.getOrientationFromSide( + this.fangXiang, ForgeDirection.EAST); + Vector3 zuoBian = new Vector3(this); + zuoBian.modifyPositionFromSide(zuoFangXiang); + ForgeDirection youFangXiang = VectorHelper.getOrientationFromSide( + this.fangXiang, ForgeDirection.WEST); + Vector3 youBian = new Vector3(this); + youBian.modifyPositionFromSide(youFangXiang); + if (zuoBian.getBlock(super.worldObj) == Blocks.air) { + this.fangXiang = zuoFangXiang; + } else { + if (youBian.getBlock(super.worldObj) != Blocks.air) { + this.setDead(); + return 0.0D; + } + + this.fangXiang = youFangXiang; + } + + this.setPosition(Math.floor(super.posX) + 0.5D, + Math.floor(super.posY) + 0.5D, + Math.floor(super.posZ) + 0.5D); + return this.getSuDu() - + this.getSuDu() / + Math.min(Math.max(70.0D * this.getSuDu(), 4.0D), 30.0D); + } + + public void explode() { + if (!super.worldObj.isRemote) { + boolean radius = false; + if (this.getSuDu() > 0.5D) { + float bounds = 1.0F; + AxisAlignedBB livingNearby = AxisAlignedBB.getBoundingBox( + super.posX - (double)bounds, super.posY - (double)bounds, + super.posZ - (double)bounds, super.posX + (double)bounds, + super.posY + (double)bounds, super.posZ + (double)bounds); + List entities = + super.worldObj.getEntitiesWithinAABB(Entity.class, livingNearby); + + for (Entity entity : entities) { + if (entity instanceof EMatter) { + if ((double)super.worldObj.rand.nextFloat() > 0.85D) { + super.worldObj.spawnEntityInWorld(new EntityItem( + super.worldObj, super.posX, super.posY, super.posZ, + new ItemStack(AtomicScience.itCellStrangeMatter))); + } + + radius = true; + } + } + + if ((double)super.worldObj.rand.nextFloat() > 0.95D) { + super.worldObj.spawnEntityInWorld( + new EntityItem(super.worldObj, super.posX, super.posY, super.posZ, + new ItemStack(AtomicScience.itCellStrangeMatter))); + } + } + + if (!radius) { + super.worldObj.createExplosion(this, super.posX, super.posY, super.posZ, + (float)this.getSuDu() * 2.5F, true); + } + } + + float radius1 = 6.0F; + AxisAlignedBB bounds1 = AxisAlignedBB.getBoundingBox( + super.posX - (double)radius1, super.posY - (double)radius1, + super.posZ - (double)radius1, super.posX + (double)radius1, + super.posY + (double)radius1, super.posZ + (double)radius1); + List livingNearby1 = + super.worldObj.getEntitiesWithinAABB(EntityLivingBase.class, bounds1); + + for (EntityLivingBase entity2 : livingNearby1) { + PoisonRadiation.INSTANCE.poisonEntity(new Vector3(entity2), entity2); + } + + super.worldObj.playSoundEffect( + super.posX, super.posY, super.posZ, "atomicscience.antimatter", 1.5F, + 1.0F - super.worldObj.rand.nextFloat() * 0.3F); + this.setDead(); + } + + public double getSuDu() { + return Math.abs(super.motionX) + Math.abs(super.motionY) + + Math.abs(super.motionZ); + } + + public static boolean canCunZai(World worldObj, Vector3 position, + ForgeDirection facing) { + if (position.getBlock(worldObj) != Blocks.air) { + return false; + } else { + for (int i = 0; i <= 1; ++i) { + ForgeDirection dir = ForgeDirection.getOrientation(i); + if (!isElectromagnet(worldObj, position, dir)) { + return false; + } + } + + return true; + } + } + + public static boolean isElectromagnet(World worldObj, Vector3 position, + ForgeDirection dir) { + Vector3 checkPos = position.clone(); + checkPos.modifyPositionFromSide(dir); + Block block = checkPos.getBlock(worldObj); + return block != Blocks.air ? block instanceof IElectromagnet : false; + } + + public void applyEntityCollision(Entity par1Entity) { this.explode(); } + + public void setDead() { + ForgeChunkManager.releaseTicket(this.youPiao); + super.setDead(); + } + + protected void readEntityFromNBT(NBTTagCompound nbt) { + this.jiQi = Vector3.readFromNBT(nbt.getCompoundTag("jiqi")); + ForgeDirection.getOrientation(nbt.getByte("fangXiang")); + } + + protected void writeEntityToNBT(NBTTagCompound nbt) { + nbt.setTag("jiqi", this.jiQi.writeToNBT(new NBTTagCompound())); + nbt.setByte("fangXiang", (byte)this.fangXiang.ordinal()); + } +} diff --git a/src/main/java/atomicscience/fanwusu/FulminationEventHandler.java b/src/main/java/atomicscience/fanwusu/FulminationEventHandler.java new file mode 100644 index 0000000..0950b85 --- /dev/null +++ b/src/main/java/atomicscience/fanwusu/FulminationEventHandler.java @@ -0,0 +1,59 @@ +package atomicscience.fanwusu; + +import atomicscience.AtomicScience; +import cpw.mods.fml.common.eventhandler.SubscribeEvent; +import icbm.api.explosion.ExplosionEvent; +import java.util.ArrayList; +import java.util.List; +import net.minecraft.util.Vec3; +import universalelectricity.core.vector.Vector3; + +public class FulminationEventHandler { + public static final FulminationEventHandler INSTANCE = + new FulminationEventHandler(); + public static final List list = new ArrayList<>(); + + public void register(TFulminationGenerator tileEntity) { + if (!list.contains(tileEntity)) { + list.add(tileEntity); + } + } + + public void unregister(TFulminationGenerator tileEntity) { + list.remove(tileEntity); + } + + @SubscribeEvent + public void onPreExplosionEvent(ExplosionEvent.PreExplosionEvent event) { + if (event.explosive != null && event.explosive.getRadius() > 0.0F && + event.explosive.getEnergy() > 0.0D) { + for (TFulminationGenerator tileEntity : list) { + if (tileEntity != null && !tileEntity.isInvalid()) { + Vector3 tilePos = new Vector3(tileEntity); + tilePos.add(0.5D); + double explosionDistance = + tilePos.distanceTo(new Vector3(event.x, event.y, event.z)); + if (explosionDistance <= (double)event.explosive.getRadius() && + explosionDistance > 0.0D) { + float density = event.world.getBlockDensity( + Vec3.createVectorHelper(event.x, event.y, event.z), + AtomicScience.bFulminationGenerator + .getCollisionBoundingBoxFromPool( + event.world, tileEntity.xCoord, tileEntity.yCoord, + tileEntity.zCoord)); + if (density < 1.0F) { + double nengLiang = + Math.min(event.explosive.getEnergy(), + event.explosive.getEnergy() / + (explosionDistance / + (double)event.explosive.getRadius())); + nengLiang = + Math.max(nengLiang - (double)density * nengLiang, 0.0D); + tileEntity.dian += nengLiang; + } + } + } + } + } + } +} diff --git a/src/main/java/atomicscience/fanwusu/ItAntimatterCell.java b/src/main/java/atomicscience/fanwusu/ItAntimatterCell.java new file mode 100644 index 0000000..a1d99e4 --- /dev/null +++ b/src/main/java/atomicscience/fanwusu/ItAntimatterCell.java @@ -0,0 +1,192 @@ +package atomicscience.fanwusu; + +import atomicscience.AtomicScience; +import atomicscience.api.poison.PoisonRadiation; +import atomicscience.wujian.ItCell; +import cpw.mods.fml.common.eventhandler.SubscribeEvent; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import icbm.api.explosion.ExplosionEvent; +import icbm.api.explosion.IExplosive; +import java.util.Iterator; +import java.util.List; +import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.entity.EntityLiving; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.util.AxisAlignedBB; +import net.minecraft.util.IIcon; +import net.minecraft.world.World; +import net.minecraftforge.common.MinecraftForge; +import net.minecraftforge.event.entity.item.ItemExpireEvent; +import universalelectricity.core.vector.Vector3; + +public class ItAntimatterCell extends ItCell { + + private IIcon iconGram; + + public ItAntimatterCell() { + super("antimatter"); + this.setMaxDamage(0); + this.setHasSubtypes(true); + } + + @Override + public void addInformation(ItemStack par1ItemStack, + EntityPlayer par2EntityPlayer, List list, + boolean par4) { + if (par1ItemStack.getItemDamage() >= 1) { + list.add("1 Gram"); + } else { + list.add("125 Milligrams"); + } + } + + @Override + @SideOnly(Side.CLIENT) + public void registerIcons(IIconRegister iconRegister) { + this.itemIcon = iconRegister.registerIcon( + this.getUnlocalizedName().replace("item.", "") + "_milligram"); + this.iconGram = iconRegister.registerIcon( + this.getUnlocalizedName().replace("item.", "") + "_gram"); + } + + @Override + public IIcon getIconFromDamage(int metadata) { + return metadata >= 1 ? this.iconGram : this.itemIcon; + } + + @Override + public void getSubItems(Item item, CreativeTabs par2CreativeTabs, + List par3List) { + par3List.add(new ItemStack(item, 1, 0)); + par3List.add(new ItemStack(item, 1, 1)); + } + + @Override + public int getEntityLifespan(ItemStack itemStack, World world) { + return 160; + } + + @SubscribeEvent + public void onItemExpireEvent(ItemExpireEvent event) { + if (event.entityItem != null) { + ItemStack itemStack = event.entityItem.getEntityItem(); + if (itemStack != null && itemStack.getItem() == this) { + event.entityItem.worldObj.playSoundEffect( + event.entityItem.posX, event.entityItem.posY, event.entityItem.posZ, + "atomicscience.antimatter", 3.0F, + 1.0F - event.entityItem.worldObj.rand.nextFloat() * 0.3F); + if (!event.entityItem.worldObj.isRemote + // && + // ! FlagRegistry.getModFlag("ModFlags") + // .containsValue(event.entityItem.worldObj, + // ZhuYao.QIZI_FAN_WU_SU_BAO_ZHA, "true", + // new Vector3(event.entityItem)) + ) { + IExplosive explosive = new IExplosive() { + public int getID() { + return -1; + } + + public String getUnlocalizedName() { + return "Antimatter"; + } + + public String getExplosiveName() { + return this.getUnlocalizedName(); + } + + public String getGrenadeName() { + return this.getUnlocalizedName(); + } + + public String getMissileName() { + return this.getUnlocalizedName(); + } + + public String getMinecartName() { + return this.getUnlocalizedName(); + } + + public float getRadius() { + return 4.0F; + } + + public int getTier() { + return 4; + } + + public double getEnergy() { + return 400000.0D; + } + }; + if (itemStack.getItemDamage() == 1) { + explosive = new IExplosive() { + public int getID() { + return -1; + } + + public String getUnlocalizedName() { + return "antimatter"; + } + + public String getExplosiveName() { + return this.getUnlocalizedName(); + } + + public String getGrenadeName() { + return this.getUnlocalizedName(); + } + + public String getMissileName() { + return this.getUnlocalizedName(); + } + + public String getMinecartName() { + return this.getUnlocalizedName(); + } + + public float getRadius() { + return 6.0F; + } + + public int getTier() { + return 4; + } + + public double getEnergy() { + return 2000000.0D; + } + }; + } + + MinecraftForge.EVENT_BUS.post(new ExplosionEvent.PreExplosionEvent( + event.entity.worldObj, event.entityItem.posX, + event.entityItem.posY, event.entityItem.posZ, explosive)); + event.entityItem.worldObj.createExplosion( + event.entityItem, event.entityItem.posX, event.entityItem.posY, + event.entityItem.posZ, explosive.getRadius(), true); + AtomicScience.LOGGER.fine( + "Antimatter cell detonated at: " + event.entityItem.posX + ", " + + event.entityItem.posY + ", " + event.entityItem.posZ); + boolean radius = true; + AxisAlignedBB bounds = AxisAlignedBB.getBoundingBox( + event.entityItem.posX - 20.0D, event.entityItem.posY - 20.0D, + event.entityItem.posZ - 20.0D, event.entityItem.posX + 20.0D, + event.entityItem.posY + 20.0D, event.entityItem.posZ + 20.0D); + List entitiesNearby = event.entityItem.worldObj.getEntitiesWithinAABB( + EntityLiving.class, bounds); + Iterator i$ = entitiesNearby.iterator(); + + while (i$.hasNext()) { + EntityLiving entity = (EntityLiving) i$.next(); + PoisonRadiation.INSTANCE.poisonEntity(new Vector3(entity), entity); + } + } + } + } + } +} diff --git a/src/main/java/atomicscience/fanwusu/TAccelerator.java b/src/main/java/atomicscience/fanwusu/TAccelerator.java new file mode 100644 index 0000000..4481bd0 --- /dev/null +++ b/src/main/java/atomicscience/fanwusu/TAccelerator.java @@ -0,0 +1,242 @@ +package atomicscience.fanwusu; + +import atomicscience.AtomicScience; +import atomicscience.jiqi.TInventory; +import net.minecraft.inventory.ISidedInventory; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.network.NetworkManager; +import net.minecraft.network.Packet; +import net.minecraft.network.play.server.S35PacketUpdateTileEntity; +import net.minecraftforge.common.util.ForgeDirection; +import universalelectricity.core.UniversalElectricity; +import universalelectricity.core.electricity.ElectricityPack; +import universalelectricity.core.vector.Vector3; +import universalelectricity.prefab.implement.IRotatable; + +public class TAccelerator + extends TInventory implements IRotatable, ISidedInventory { + + public final int DIAN = 10000; + public double yongDianLiang = 0.0D; + public int antimatter; + public EMatter wuSu; + public static final float SU_DU = 1.0F; + public float suDu; + + @Override + public boolean canConnect(ForgeDirection direction) { + return true; + } + + @Override + public ElectricityPack getRequest() { + return this.getStackInSlot(0) != null && + (this.worldObj.isBlockIndirectlyGettingPowered( + this.xCoord, this.yCoord, this.zCoord) || + this.worldObj.getBlockPowerInput(this.xCoord, this.yCoord, + this.zCoord) > 0) + ? new ElectricityPack(10000.0D / this.getVoltage(), this.getVoltage()) + : new ElectricityPack(); + } + + @Override + public void onReceive(ElectricityPack electricityPack) { + super.onReceive(electricityPack); + this.yongDianLiang += electricityPack.getWatts(); + } + + @Override + public void updateEntity() { + super.updateEntity(); + if (!this.worldObj.isRemote) { + this.suDu = 0.0F; + if (this.wuSu != null) { + this.suDu = (float)this.wuSu.getSuDu(); + } + + if (AtomicScience.isCell(this.getStackInSlot(1)) && + this.getStackInSlot(1).stackSize > 0 && this.antimatter >= 125) { + if (this.getStackInSlot(2) != null) { + if (this.getStackInSlot(2).getItem() == AtomicScience.itCellAntimatter) { + ItemStack i$ = this.getStackInSlot(2).copy(); + if (i$.stackSize < i$.getMaxStackSize()) { + this.decrStackSize(1, 1); + this.antimatter -= 125; + ++i$.stackSize; + this.setInventorySlotContents(2, i$); + } + } + } else { + this.antimatter -= 125; + this.decrStackSize(1, 1); + this.setInventorySlotContents(2, new ItemStack(AtomicScience.itCellAntimatter)); + } + } + + if (!this.isDisabled()) { + if (this.worldObj.isBlockIndirectlyGettingPowered( + this.xCoord, this.yCoord, this.zCoord)) { + double var10000 = super.wattsReceived; + this.getClass(); + if (var10000 >= 10000.0D) { + if (this.wuSu == null) { + if (this.getStackInSlot(0) != null && super.ticks % 20L == 0L) { + Vector3 i$1 = new Vector3(this); + i$1.modifyPositionFromSide( + this.getDirection(this.worldObj, this.xCoord, this.yCoord, + this.zCoord) + .getOpposite()); + i$1.add(0.5D); + if (EMatter.canCunZai( + this.worldObj, i$1, + this.getDirection(this.worldObj, this.xCoord, + this.yCoord, this.zCoord) + .getOpposite())) { + this.yongDianLiang = 0.0D; + this.wuSu = + new EMatter(this.worldObj, i$1, new Vector3(this), + this.getDirection(this.worldObj, this.xCoord, + this.yCoord, this.zCoord) + .getOpposite()); + this.worldObj.spawnEntityInWorld(this.wuSu); + this.decrStackSize(0, 1); + } + } + } else if (this.wuSu.isDead) { + this.wuSu = null; + } else if (this.suDu > 1.0F) { + this.worldObj.playSoundEffect( + (double)this.xCoord, (double)this.yCoord, (double)this.zCoord, + "atomicscience.antimatter", 2.0F, + 1.0F - this.worldObj.rand.nextFloat() * 0.3F); + this.antimatter += 5 + this.worldObj.rand.nextInt(5); + this.yongDianLiang = 0.0D; + this.wuSu.setDead(); + this.wuSu = null; + } + + double var10001 = super.wattsReceived; + this.getClass(); + super.wattsReceived = Math.max(var10001 - 10000.0D / 10.0D, 0.0D); + } else { + if (this.wuSu != null) { + this.wuSu.setDead(); + } + + this.wuSu = null; + } + } else { + if (this.wuSu != null) { + this.wuSu.setDead(); + } + + this.wuSu = null; + } + } + + if (super.ticks % 5L == 0L) { + worldObj.markBlockForUpdate(this.xCoord, this.yCoord, this.zCoord); + } + } + } + + @Override + public void onDataPacket(NetworkManager nm, + S35PacketUpdateTileEntity packet) { + if (!this.worldObj.isRemote) + return; + + NBTTagCompound nbt = packet.func_148857_g(); + super.disabledTicks = nbt.getInteger("disabledTicks"); + this.suDu = nbt.getFloat("suDu"); + this.yongDianLiang = nbt.getDouble("yongDianLiang"); + this.antimatter = nbt.getInteger("antimatter"); + } + + // public void handlePacketData(INetworkManager network, int packetType, + // Packet250CustomPayload packet, + // EntityPlayer player, + // ByteArrayDataInput dataStream) { + // try { + // super.disabledTicks = dataStream.readInt(); + // this.suDu = dataStream.readFloat(); + // this.yongDianLiang = dataStream.readDouble(); + // this.fanWuSu = dataStream.readInt(); + // } catch (Exception var7) { + // var7.printStackTrace(); + // } + // } + + @Override + public Packet getDescriptionPacket() { + NBTTagCompound nbt = new NBTTagCompound(); + nbt.setInteger("disabledTicks", super.disabledTicks); + nbt.setFloat("suDu", this.suDu); + nbt.setDouble("yongDianLiang", this.yongDianLiang); + nbt.setInteger("antimatter", this.antimatter); + + return new S35PacketUpdateTileEntity(this.xCoord, this.yCoord, this.zCoord, + this.getBlockMetadata(), nbt); + } + + @Override + public void openInventory() { + if (!this.worldObj.isRemote) { + this.worldObj.markBlockForUpdate(this.xCoord, this.yCoord, this.zCoord); + } + } + + @Override + public void readFromNBT(NBTTagCompound nbt) { + super.readFromNBT(nbt); + super.wattsReceived = nbt.getDouble("wattsReceived"); + this.yongDianLiang = nbt.getDouble("yongDianLiang"); + this.antimatter = nbt.getInteger("antimatter"); + } + + @Override + public void writeToNBT(NBTTagCompound nbt) { + super.writeToNBT(nbt); + nbt.setDouble("wattsReceived", super.wattsReceived); + nbt.setDouble("yongDianLiang", this.yongDianLiang); + nbt.setInteger("antimatter", this.antimatter); + } + + @Override + public int getSizeInventory() { return 3; } + + @Override + public double getVoltage() { + return UniversalElectricity.isVoltageSensitive ? 480.0D : 120.0D; + } + + @Override + public int[] getAccessibleSlotsFromSide(int side) { + return new int[] {0, 1, 2}; + } + + @Override + public boolean canInsertItem(int slotID, ItemStack itemStack, int j) { + return this.isItemValidForSlot(slotID, itemStack); + } + + @Override + public boolean canExtractItem(int slotID, ItemStack itemstack, int j) { + return slotID == 2; + } + + @Override + public boolean isItemValidForSlot(int i, ItemStack itemStack) { + switch (i) { + case 0: + return true; + case 1: + return AtomicScience.isCell(itemStack); + case 2: + return itemStack.getItem() instanceof ItAntimatterCell; + default: + return false; + } + } +} diff --git a/src/main/java/atomicscience/fanwusu/TFulminationGenerator.java b/src/main/java/atomicscience/fanwusu/TFulminationGenerator.java new file mode 100644 index 0000000..db31447 --- /dev/null +++ b/src/main/java/atomicscience/fanwusu/TFulminationGenerator.java @@ -0,0 +1,35 @@ +package atomicscience.fanwusu; + +import atomicscience.fanwusu.FulminationEventHandler; +import calclavia.lib.TileEntityUniversalProducer; +import universalelectricity.core.UniversalElectricity; + +public class TFulminationGenerator extends TileEntityUniversalProducer { + + public final int DIAN = 5000; + public double dian; + + + public TFulminationGenerator() { + FulminationEventHandler.INSTANCE.register(this); + } + + @Override + public void updateEntity() { + super.updateEntity(); + if(!this.isDisabled()) { + this.produce(Math.min(this.dian, 5000.0D)); + } + + this.dian = Math.max(this.dian - 5000.0D, 0.0D); + } + + public void invalidate() { + FulminationEventHandler.INSTANCE.unregister(this); + super.initiate(); + } + + public double getVoltage() { + return UniversalElectricity.isVoltageSensitive?480.0D:120.0D; + } +} diff --git a/src/main/java/atomicscience/fenlie/BCentrifuge.java b/src/main/java/atomicscience/fenlie/BCentrifuge.java new file mode 100644 index 0000000..a4cb46a --- /dev/null +++ b/src/main/java/atomicscience/fenlie/BCentrifuge.java @@ -0,0 +1,52 @@ +package atomicscience.fenlie; + +import atomicscience.AtomicScience; +import atomicscience.CommonProxy; +import atomicscience.jiqi.BBaseRotatable; +import atomicscience.render.RH; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; +import universalelectricity.core.UniversalElectricity; + +public class BCentrifuge extends BBaseRotatable { + public BCentrifuge() { super("centrifuge", UniversalElectricity.machine); } + + @Override + public boolean onMachineActivated(World par1World, int x, int y, int z, + EntityPlayer par5EntityPlayer, int side, + float hitX, float hitY, float hitZ) { + par1World.getBlockMetadata(x, y, z); + if (!par1World.isRemote) { + par5EntityPlayer.openGui(AtomicScience.instance, + CommonProxy.GuiType.CENTRIFUGE.ordinal(), + par1World, x, y, z); + return true; + } else { + return true; + } + } + + @Override + public TileEntity createNewTileEntity(World world, int meta) { + return new TCentrifuge(); + } + + @Override + public boolean renderAsNormalBlock() { + return false; + } + + @Override + public boolean isOpaqueCube() { + return false; + } + + @Override + @SideOnly(Side.CLIENT) + public int getRenderType() { + return RH.BLOCK_RENDER_ID; + } +} diff --git a/src/main/java/atomicscience/fenlie/BControlRod.java b/src/main/java/atomicscience/fenlie/BControlRod.java new file mode 100644 index 0000000..2c2126b --- /dev/null +++ b/src/main/java/atomicscience/fenlie/BControlRod.java @@ -0,0 +1,32 @@ +package atomicscience.fenlie; + +import atomicscience.jiqi.BBase; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import net.minecraft.block.Block; +import net.minecraft.block.material.Material; +import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.init.Blocks; + +public class BControlRod extends BBase { + public BControlRod() { + super("controlRod", Material.iron); + this.setBlockBounds(0.3F, 0.0F, 0.3F, 0.7F, 1.0F, 0.7F); + } + + @Override + @SideOnly(Side.CLIENT) + public void registerBlockIcons(IIconRegister iconRegister) { + this.blockIcon = iconRegister.registerIcon( + Blocks.iron_block.getUnlocalizedName().replace("tile.", "")); + } + + @Override + public boolean renderAsNormalBlock() { return false; } + + @Override + public boolean isOpaqueCube() { return false; } + + @Override + public boolean hasTileEntity(int metadata) { return false; } +} diff --git a/src/main/java/atomicscience/fenlie/BFissionReactor.java b/src/main/java/atomicscience/fenlie/BFissionReactor.java new file mode 100644 index 0000000..8e019db --- /dev/null +++ b/src/main/java/atomicscience/fenlie/BFissionReactor.java @@ -0,0 +1,98 @@ +package atomicscience.fenlie; + +import atomicscience.AtomicScience; +import atomicscience.api.IFissileMaterial; +import atomicscience.fenlie.TFissionReactor; +import atomicscience.jiqi.BBase; +import atomicscience.render.RH; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import java.util.Random; +import net.minecraft.block.Block; +import net.minecraft.entity.item.EntityItem; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; + +public class BFissionReactor extends BBase { + + public BFissionReactor() { super("fissionReactor"); } + + @Override + public void onBlockAdded(World par1World, int x, int y, int z) { + super.onBlockAdded(par1World, x, y, z); + TFissionReactor tileEntity = + (TFissionReactor)par1World.getTileEntity(x, y, z); + tileEntity.updatePositionStatus(); + } + + @Override + public void onNeighborBlockChange(World par1World, int x, int y, int z, + Block block) { + TFissionReactor tileEntity = + (TFissionReactor)par1World.getTileEntity(x, y, z); + tileEntity.updatePositionStatus(); + } + + @Override + public boolean onMachineActivated(World world, int x, int y, int z, + EntityPlayer entityPlayer, int side, + float hitX, float hitY, float hitZ) { + if (!world.isRemote) { + TFissionReactor tileEntity = + (TFissionReactor)world.getTileEntity(x, y, z); + tileEntity = tileEntity.zhaoZuiDi(); + if (!entityPlayer.isSneaking()) { + if (entityPlayer.inventory.getCurrentItem() != null && + entityPlayer.inventory.getCurrentItem().getItem() == + AtomicScience.itWenDuBiao) { + return false; + } + + if (tileEntity.getStackInSlot(0) != null) { + EntityItem itemStack1 = + new EntityItem(world, entityPlayer.posX, entityPlayer.posY, + entityPlayer.posZ, tileEntity.getStackInSlot(0)); + Random random = new Random(); + float var13 = 0.05F; + itemStack1.motionX = (double)((float)random.nextGaussian() * var13); + itemStack1.motionY = + (double)((float)random.nextGaussian() * var13 + 0.2F); + itemStack1.motionZ = (double)((float)random.nextGaussian() * var13); + itemStack1.delayBeforeCanPickup = 0; + world.spawnEntityInWorld(itemStack1); + tileEntity.setInventorySlotContents(0, (ItemStack)null); + return true; + } + + if (entityPlayer.inventory.getCurrentItem() != null && + entityPlayer.inventory.getCurrentItem().getItem() instanceof + IFissileMaterial) { + ItemStack itemStack = entityPlayer.inventory.getCurrentItem().copy(); + itemStack.stackSize = 1; + tileEntity.setInventorySlotContents(0, itemStack); + entityPlayer.inventory.decrStackSize( + entityPlayer.inventory.currentItem, 1); + return true; + } + } + + entityPlayer.openGui(AtomicScience.instance, 0, world, tileEntity.xCoord, + tileEntity.yCoord, tileEntity.zCoord); + } + + return true; + } + + @SideOnly(Side.CLIENT) + public int getRenderType() { + return RH.BLOCK_RENDER_ID; + } + + public TileEntity createNewTileEntity(World var1) { return new TFissionReactor(); } + + public boolean renderAsNormalBlock() { return false; } + + public boolean isOpaqueCube() { return false; } +} diff --git a/src/main/java/atomicscience/fenlie/BNuclearBoiler.java b/src/main/java/atomicscience/fenlie/BNuclearBoiler.java new file mode 100644 index 0000000..b356b70 --- /dev/null +++ b/src/main/java/atomicscience/fenlie/BNuclearBoiler.java @@ -0,0 +1,51 @@ +package atomicscience.fenlie; + +import atomicscience.CommonProxy; +import atomicscience.AtomicScience; +import atomicscience.jiqi.BBaseRotatable; +import atomicscience.render.RH; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; +import universalelectricity.core.UniversalElectricity; + +public class BNuclearBoiler extends BBaseRotatable { + + public BNuclearBoiler() { + super("nuclearBoiler", UniversalElectricity.machine); + } + + @Override + public boolean onMachineActivated(World par1World, int x, int y, int z, EntityPlayer par5EntityPlayer, int side, float hitX, float hitY, float hitZ) { + par1World.getBlockMetadata(x, y, z); + if(!par1World.isRemote) { + par5EntityPlayer.openGui(AtomicScience.instance, CommonProxy.GuiType.HE_QI.ordinal(), par1World, x, y, z); + return true; + } else { + return true; + } + } + + @Override + @SideOnly(Side.CLIENT) + public int getRenderType() { + return RH.BLOCK_RENDER_ID; + } + + @Override + public TileEntity createNewTileEntity(World world, int meta) { + return new TNuclearBoiler(); + } + + @Override + public boolean renderAsNormalBlock() { + return false; + } + + @Override + public boolean isOpaqueCube() { + return false; + } +} diff --git a/src/main/java/atomicscience/fenlie/BReactorTap.java b/src/main/java/atomicscience/fenlie/BReactorTap.java new file mode 100644 index 0000000..80b0d77 --- /dev/null +++ b/src/main/java/atomicscience/fenlie/BReactorTap.java @@ -0,0 +1,56 @@ +package atomicscience.fenlie; + +import atomicscience.fenlie.TReactorTap; +import atomicscience.jiqi.BBaseRotatable; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.entity.EntityLiving; +import net.minecraft.entity.EntityLivingBase; +import net.minecraft.item.ItemStack; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.IIcon; +import net.minecraft.util.MathHelper; +import net.minecraft.world.World; +import net.minecraftforge.common.util.ForgeDirection; + +public class BReactorTap extends BBaseRotatable { + private IIcon frontIcon; + + public BReactorTap() { super("reactorTap"); } + + @Override + public void onBlockPlacedBy(World world, int x, int y, int z, + EntityLivingBase entityLiving, + ItemStack itemStack) { + if (MathHelper.abs((float)entityLiving.posX - (float)x) < 2.0F && + MathHelper.abs((float)entityLiving.posZ - (float)z) < 2.0F) { + double d0 = entityLiving.posY + 1.82D - (double)entityLiving.yOffset; + if (d0 - (double)y > 2.0D) { + this.setDirection(world, x, y, z, ForgeDirection.getOrientation(1)); + return; + } + + if ((double)y - d0 > 0.0D) { + this.setDirection(world, x, y, z, ForgeDirection.getOrientation(0)); + return; + } + } + + super.onBlockPlacedBy(world, x, y, z, entityLiving, itemStack); + } + + public IIcon getIcon(int side, int metadata) { + return side == metadata ? this.frontIcon : this.blockIcon; + } + + @Override + @SideOnly(Side.CLIENT) + public void registerBlockIcons(IIconRegister iconRegister) { + super.registerBlockIcons(iconRegister); + this.frontIcon = iconRegister.registerIcon( + this.getUnlocalizedName().replace("tile.", "") + "_front"); + } + + public TileEntity createNewTileEntity(World world, int meta) { return new TReactorTap(); } +} diff --git a/src/main/java/atomicscience/fenlie/BSiren.java b/src/main/java/atomicscience/fenlie/BSiren.java new file mode 100644 index 0000000..9ed6958 --- /dev/null +++ b/src/main/java/atomicscience/fenlie/BSiren.java @@ -0,0 +1,75 @@ +package atomicscience.fenlie; + +import atomicscience.jiqi.BBase; +import java.util.Random; + +import net.minecraft.block.Block; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.world.World; +import net.minecraftforge.common.util.ForgeDirection; +import universalelectricity.core.vector.Vector3; + +public class BSiren extends BBase { + + public BSiren() { + super("siren"); + } + + @Override + public void onBlockAdded(World par1World, int x, int y, int z) { + par1World.scheduleBlockUpdate(x, y, z, this, 1); + } + + @Override + public void onNeighborBlockChange(World par1World, int x, int y, int z, Block block) { + par1World.scheduleBlockUpdate(x, y, z, this, 1); + } + + @Override + public void updateTick(World worldObj, int x, int y, int z, Random par5Random) { + int metadata = worldObj.getBlockMetadata(x, y, z); + if(worldObj.getBlockPowerInput(x, y, z) > 0) { + float volume = 0.5F; + + for(int i = 0; i < 6; ++i) { + Vector3 pos = new Vector3((double)x, (double)y, (double)z); + pos.modifyPositionFromSide(ForgeDirection.getOrientation(i)); + Block block = pos.getBlock(worldObj); + if(block == this) { + volume *= 1.5F; + } + } + + worldObj.playSoundEffect((double)x, (double)y, (double)z, "atomicscience.alarm", volume, 1.0F - 0.18F * ((float)metadata / 15.0F)); + worldObj.scheduleBlockUpdate(x, y, z, this, 30); + } + + } + + @Override + public boolean onUseWrench(World par1World, int x, int y, int z, EntityPlayer par5EntityPlayer, int side, float hitX, float hitY, float hitZ) { + int metadata = par1World.getBlockMetadata(x, y, z) + 1; + if(metadata < 0) { + metadata = 15; + } + + par1World.setBlockMetadataWithNotify(x, y, z, metadata, 2); + return true; + } + + @Override + public boolean onSneakUseWrench(World par1World, int x, int y, int z, EntityPlayer par5EntityPlayer, int side, float hitX, float hitY, float hitZ) { + int metadata = par1World.getBlockMetadata(x, y, z) - 1; + if(metadata > 15) { + metadata = 0; + } + + par1World.setBlockMetadataWithNotify(x, y, z, metadata, 2); + return true; + } + + @Override + public int tickRate(World world) { + return 20; + } +} diff --git a/src/main/java/atomicscience/fenlie/BUraniumOre.java b/src/main/java/atomicscience/fenlie/BUraniumOre.java new file mode 100644 index 0000000..dd1c644 --- /dev/null +++ b/src/main/java/atomicscience/fenlie/BUraniumOre.java @@ -0,0 +1,47 @@ +package atomicscience.fenlie; + +import atomicscience.TabAS; +import atomicscience.AtomicScience; +import atomicscience.api.BlockRadioactive; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import java.util.Random; + +import net.minecraft.block.Block; +import net.minecraft.block.material.Material; +import net.minecraft.util.IIcon; +import net.minecraft.world.World; + +public class BUraniumOre extends BlockRadioactive { + + public BUraniumOre() { + super(Material.rock); + this.setBlockName("atomicscience:oreUranium"); + this.setStepSound(Block.soundTypeStone); + this.setCreativeTab(TabAS.INSTANCE); + this.setHardness(2.0F); + super.isRandomlyRadioactive = AtomicScience.ALLOW_RADIOACTIVE_ORES; + super.canWalkPoison = AtomicScience.ALLOW_RADIOACTIVE_ORES; + super.canSpread = false; + super.radius = 1.0F; + super.amplifier = 0; + } + + @Override + @SideOnly(Side.CLIENT) + public void randomDisplayTick(World world, int x, int y, int z, Random par5Random) { + if(AtomicScience.ALLOW_RADIOACTIVE_ORES) { + super.randomDisplayTick(world, x, y, z, par5Random); + } + } + + @Override + public IIcon getIcon(int side, int metadata) { + return this.blockIcon; + } + + @Override + public int quantityDropped(Random rand) { + return 1; + } +} diff --git a/src/main/java/atomicscience/fenlie/CCentrifuge.java b/src/main/java/atomicscience/fenlie/CCentrifuge.java new file mode 100644 index 0000000..13716ac --- /dev/null +++ b/src/main/java/atomicscience/fenlie/CCentrifuge.java @@ -0,0 +1,98 @@ +package atomicscience.fenlie; + +import atomicscience.AtomicScience; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.entity.player.InventoryPlayer; +import net.minecraft.inventory.Container; +import net.minecraft.inventory.Slot; +import net.minecraft.inventory.SlotFurnace; +import net.minecraft.item.ItemStack; +import universalelectricity.core.item.IItemElectric; +import universalelectricity.prefab.SlotSpecific; + +public class CCentrifuge extends Container { + + //private static final int slotCount = 4; + private TCentrifuge tileEntity; + + + public CCentrifuge(InventoryPlayer par1InventoryPlayer, TCentrifuge tileEntity) { + this.tileEntity = tileEntity; + this.addSlotToContainer(new SlotSpecific(tileEntity, 0, 131, 26, IItemElectric.class)); + this.addSlotToContainer(new Slot(tileEntity, 1, 25, 50)); + this.addSlotToContainer(new SlotFurnace(par1InventoryPlayer.player, tileEntity, 2, 81, 26)); + this.addSlotToContainer(new SlotFurnace(par1InventoryPlayer.player, tileEntity, 3, 101, 26)); + + int var3; + for(var3 = 0; var3 < 3; ++var3) { + for(int var4 = 0; var4 < 9; ++var4) { + this.addSlotToContainer(new Slot(par1InventoryPlayer, var4 + var3 * 9 + 9, 8 + var4 * 18, 84 + var3 * 18)); + } + } + + for(var3 = 0; var3 < 9; ++var3) { + this.addSlotToContainer(new Slot(par1InventoryPlayer, var3, 8 + var3 * 18, 142)); + } + + this.tileEntity.players.add(par1InventoryPlayer.player); + tileEntity.openInventory(); + } + + @Override + public void onContainerClosed(EntityPlayer entityplayer) { + super.onContainerClosed(entityplayer); + this.tileEntity.players.remove(entityplayer); + } + + @Override + public boolean canInteractWith(EntityPlayer par1EntityPlayer) { + return this.tileEntity.isUseableByPlayer(par1EntityPlayer); + } + + @Override + public ItemStack transferStackInSlot(EntityPlayer par1EntityPlayer, int par1) { + ItemStack var2 = null; + Slot var3 = (Slot)super.inventorySlots.get(par1); + if(var3 != null && var3.getHasStack()) { + ItemStack itemStack = var3.getStack(); + var2 = itemStack.copy(); + if(par1 >= 4) { + if(this.getSlot(0).isItemValid(itemStack)) { + if(!this.mergeItemStack(itemStack, 0, 1, false)) { + return null; + } + } else if(AtomicScience.isUraniumOre(itemStack)) { + if(!this.mergeItemStack(itemStack, 1, 2, false)) { + return null; + } + } else if(AtomicScience.isCell(itemStack)) { + if(!this.mergeItemStack(itemStack, 3, 4, false)) { + return null; + } + } else if(par1 < 31) { + if(!this.mergeItemStack(itemStack, 31, 40, false)) { + return null; + } + } else if(par1 >= 31 && par1 < 40 && !this.mergeItemStack(itemStack, 4, 30, false)) { + return null; + } + } else if(!this.mergeItemStack(itemStack, 4, 40, false)) { + return null; + } + + if(itemStack.stackSize == 0) { + var3.putStack((ItemStack)null); + } else { + var3.onSlotChanged(); + } + + if(itemStack.stackSize == var2.stackSize) { + return null; + } + + var3.onPickupFromSlot(par1EntityPlayer, itemStack); + } + + return var2; + } +} diff --git a/src/main/java/atomicscience/fenlie/ItRadioactive.java b/src/main/java/atomicscience/fenlie/ItRadioactive.java new file mode 100644 index 0000000..a4ea0af --- /dev/null +++ b/src/main/java/atomicscience/fenlie/ItRadioactive.java @@ -0,0 +1,21 @@ +package atomicscience.fenlie; + +import atomicscience.api.poison.PoisonRadiation; +import atomicscience.wujian.ItAS; +import net.minecraft.entity.Entity; +import net.minecraft.entity.EntityLiving; +import net.minecraft.item.ItemStack; +import net.minecraft.world.World; +import universalelectricity.core.vector.Vector3; + +public class ItRadioactive extends ItAS { + public ItRadioactive(String name) { + super(name); + } + + public void onUpdate(ItemStack par1ItemStack, World par2World, Entity entity, int par4, boolean par5) { + if(entity instanceof EntityLiving) { + PoisonRadiation.INSTANCE.poisonEntity(new Vector3(entity), (EntityLiving)entity, 1); + } + } +} diff --git a/src/main/java/atomicscience/fenlie/ItStrangeMatter.java b/src/main/java/atomicscience/fenlie/ItStrangeMatter.java new file mode 100644 index 0000000..8df4341 --- /dev/null +++ b/src/main/java/atomicscience/fenlie/ItStrangeMatter.java @@ -0,0 +1,15 @@ +package atomicscience.fenlie; + +import atomicscience.TabAS; +import atomicscience.wujian.ItCell; + +public class ItStrangeMatter extends ItCell { + public static final int YONG_LIANG = 64; + + public ItStrangeMatter() { + super("strangeMatter"); + this.setMaxStackSize(1); + this.setMaxDamage(64); + this.setCreativeTab(TabAS.INSTANCE); + } +} diff --git a/src/main/java/atomicscience/fenlie/ItUranium.java b/src/main/java/atomicscience/fenlie/ItUranium.java new file mode 100644 index 0000000..a4a4a18 --- /dev/null +++ b/src/main/java/atomicscience/fenlie/ItUranium.java @@ -0,0 +1,37 @@ +package atomicscience.fenlie; + +import java.util.List; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; + +public class ItUranium extends ItRadioactive { + + public ItUranium(int icon) { + super("uranium"); + this.setHasSubtypes(true); + this.setMaxDamage(0); + } + + @Override + public void addInformation(ItemStack itemStack, EntityPlayer par2EntityPlayer, List list, boolean par4) { + if(itemStack.getItemDamage() > 0) { + list.add("Breeding Uranium"); + } else { + list.add("Enriched Uranium"); + } + + } + + @Override + public String getUnlocalizedName(ItemStack itemStack) { + return this.getUnlocalizedName() + "." + itemStack.getItemDamage(); + } + + @Override + public void getSubItems(Item par1, CreativeTabs par2CreativeTabs, List list) { + list.add(new ItemStack(this, 1, 0)); + list.add(new ItemStack(this, 1, 1)); + } +} diff --git a/src/main/java/atomicscience/fenlie/TCentrifuge.java b/src/main/java/atomicscience/fenlie/TCentrifuge.java new file mode 100644 index 0000000..b6ef0b7 --- /dev/null +++ b/src/main/java/atomicscience/fenlie/TCentrifuge.java @@ -0,0 +1,236 @@ +package atomicscience.fenlie; + +import atomicscience.AtomicScience; +import atomicscience.jiqi.TInventory; +import net.minecraft.inventory.ISidedInventory; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.network.NetworkManager; +import net.minecraft.network.Packet; +import net.minecraft.network.play.server.S35PacketUpdateTileEntity; +import net.minecraft.tileentity.TileEntity; +import net.minecraftforge.common.util.ForgeDirection; +import net.minecraftforge.fluids.Fluid; +import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.fluids.FluidTank; +import net.minecraftforge.fluids.FluidTankInfo; +import net.minecraftforge.fluids.IFluidHandler; +import universalelectricity.core.electricity.ElectricityPack; +import universalelectricity.core.item.ElectricItemHelper; +import universalelectricity.core.item.IItemElectric; +import universalelectricity.core.vector.Vector3; +import universalelectricity.core.vector.VectorHelper; +import universalelectricity.prefab.implement.IRotatable; + +public class TCentrifuge + extends TInventory implements ISidedInventory, IFluidHandler, IRotatable { + + public static final int SHI_JIAN = 2400; + public static final float DIAN = 500.0F; + public int smeltingTicks = 0; + public float xuanZhuan = 0.0F; + public final FluidTank gasTank; + + public TCentrifuge() { + this.gasTank = + new FluidTank(AtomicScience.FLUID_URANIUM_HEXAFLOURIDE, 0, 5000); + } + + @Override + public ElectricityPack getRequest() { + return this.canWork() + ? new ElectricityPack(500.0D / this.getVoltage(), this.getVoltage()) + : new ElectricityPack(); + } + + @Override + public void updateEntity() { + super.updateEntity(); + if (!this.worldObj.isRemote && !this.isDisabled()) { + if (super.ticks % 20L == 0L) { + for (int i$ = 0; i$ < 6; ++i$) { + ForgeDirection direction = ForgeDirection.getOrientation(i$); + TileEntity tileEntity = VectorHelper.getTileEntityFromSide( + this.worldObj, new Vector3(this), direction); + if (tileEntity instanceof IFluidHandler && + tileEntity.getClass() != this.getClass()) { + int requiredLiquid = + this.gasTank.getCapacity() - this.gasTank.getFluidAmount(); + FluidStack drained = + ((IFluidHandler)tileEntity) + .drain( + direction.getOpposite(), + new FluidStack(AtomicScience.FLUID_URANIUM_HEXAFLOURIDE, + requiredLiquid), + true); + this.gasTank.fill(drained, true); + } + } + } + + if (this.canWork()) { + super.wattsReceived += ElectricItemHelper.dechargeItem( + super.containingItems[0], 500.0D, this.getVoltage()); + if (super.wattsReceived >= 500.0D) { + if (this.smeltingTicks == 0) { + this.smeltingTicks = 2400; + } + + if (this.smeltingTicks > 0) { + --this.smeltingTicks; + if (this.smeltingTicks < 1) { + this.work(); + this.smeltingTicks = 0; + } + } else { + this.smeltingTicks = 0; + } + + super.wattsReceived = 0.0D; + } + } else { + this.smeltingTicks = 0; + } + + if (super.ticks % 10L == 0L) { + this.worldObj.markBlockForUpdate(this.xCoord, this.yCoord, this.zCoord); + } + } + } + + @Override + public void onDataPacket(NetworkManager nm, + S35PacketUpdateTileEntity packet) { + NBTTagCompound nbt = packet.func_148857_g(); + this.smeltingTicks = nbt.getInteger("shiJian"); + this.gasTank.setFluid( + new FluidStack(AtomicScience.FLUID_URANIUM_HEXAFLOURIDE, + nbt.getInteger("fluidAmount"))); + super.disabledTicks = nbt.getInteger("disabledTicks"); + } + + public Packet getDescriptionPacket() { + NBTTagCompound nbt = new NBTTagCompound(); + + nbt.setInteger("shiJian", this.smeltingTicks); + nbt.setInteger("fluidAmount", this.gasTank.getFluidAmount()); + nbt.setInteger("disabledTicks", super.disabledTicks); + + return new S35PacketUpdateTileEntity(this.xCoord, this.yCoord, this.zCoord, + this.getBlockMetadata(), nbt); + } + + @Override + public void openInventory() { + if (!this.worldObj.isRemote) { + this.worldObj.markBlockForUpdate(this.xCoord, this.yCoord, this.zCoord); + } + } + + @Override + public void closeInventory() {} + + public boolean canWork() { + return !this.isDisabled() && this.gasTank.getFluidAmount() != 0 && + this.gasTank.getFluidAmount() >= + AtomicScience.URANIUM_HEXAFLOURIDE_RATIO && + this.isItemValidForSlot(2, new ItemStack(AtomicScience.itUranium)) && + this.isItemValidForSlot(3, + new ItemStack(AtomicScience.itUranium, 1, 1)); + } + + public void work() { + if (this.canWork()) { + this.gasTank.drain(AtomicScience.URANIUM_HEXAFLOURIDE_RATIO, true); + if ((double)this.worldObj.rand.nextFloat() > 0.7D) { + this.incrStackSize(2, new ItemStack(AtomicScience.itUranium)); + } else { + this.incrStackSize(3, new ItemStack(AtomicScience.itUranium, 1, 1)); + } + } + } + + @Override + public void readFromNBT(NBTTagCompound nbt) { + super.readFromNBT(nbt); + this.smeltingTicks = nbt.getInteger("smeltingTicks"); + NBTTagCompound gasNbt = nbt.getCompoundTag("gas"); + this.gasTank.setFluid(FluidStack.loadFluidStackFromNBT(gasNbt)); + } + + @Override + public void writeToNBT(NBTTagCompound nbt) { + super.writeToNBT(nbt); + nbt.setInteger("smeltingTicks", this.smeltingTicks); + NBTTagCompound gasNbt = new NBTTagCompound(); + if (this.gasTank.getFluid() != null) + this.gasTank.getFluid().writeToNBT(gasNbt); + nbt.setTag("gas", gasNbt); + } + + public int getSizeInventory() { return 4; } + + @Override + public boolean canFill(ForgeDirection arg0, Fluid fluid) { + return AtomicScience.FLUID_URANIUM_HEXAFLOURIDE == fluid && + this.gasTank.getCapacity() != this.gasTank.getFluidAmount(); + } + + @Override + public int fill(ForgeDirection from, FluidStack resource, boolean doFill) { + return AtomicScience.FLUID_URANIUM_HEXAFLOURIDE == resource.getFluid() + ? this.gasTank.fill(resource, doFill) + : 0; + } + + @Override + public FluidStack drain(ForgeDirection from, int maxDrain, boolean doDrain) { + return null; + } + + @Override + public FluidStack drain(ForgeDirection arg0, FluidStack arg1, boolean arg2) { + return null; + } + + @Override + public boolean canDrain(ForgeDirection arg0, Fluid arg1) { + return false; + } + + @Override + public FluidTankInfo[] getTankInfo(ForgeDirection arg0) { + return new FluidTankInfo[] {new FluidTankInfo(this.gasTank)}; + } + + @Override + public int[] getAccessibleSlotsFromSide(int side) { + return side == 0 ? new int[] {2, 3} : new int[] {0, 1}; + } + + @Override + public boolean canInsertItem(int slotID, ItemStack itemStack, int side) { + return slotID == 1 && this.isItemValidForSlot(slotID, itemStack); + } + + @Override + public boolean canExtractItem(int slotID, ItemStack itemstack, int j) { + return slotID == 2 || slotID == 3; + } + + @Override + public boolean isItemValidForSlot(int i, ItemStack itemStack) { + switch (i) { + case 0: + return itemStack.getItem() instanceof IItemElectric; + case 1: + return true; + case 2: + return itemStack.getItem() == AtomicScience.itUranium; + case 3: + return itemStack.getItem() == AtomicScience.itUranium; + default: + return false; + } + } +} diff --git a/src/main/java/atomicscience/fenlie/TFissionReactor.java b/src/main/java/atomicscience/fenlie/TFissionReactor.java new file mode 100644 index 0000000..e35d6c4 --- /dev/null +++ b/src/main/java/atomicscience/fenlie/TFissionReactor.java @@ -0,0 +1,430 @@ +package atomicscience.fenlie; + +import atomicscience.AtomicScience; +import atomicscience.MegaTNTExplusion; +import atomicscience.api.IFissileMaterial; +import atomicscience.api.IReactor; +import atomicscience.api.ITemperature; +import atomicscience.api.poison.PoisonRadiation; +import atomicscience.wujian.ItBreederFuel; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import java.util.List; +import net.minecraft.block.Block; +import net.minecraft.entity.Entity; +import net.minecraft.entity.EntityLivingBase; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.init.Blocks; +import net.minecraft.inventory.IInventory; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.nbt.NBTTagList; +import net.minecraft.network.NetworkManager; +import net.minecraft.network.Packet; +import net.minecraft.network.play.server.S35PacketUpdateTileEntity; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.AxisAlignedBB; +import net.minecraftforge.common.util.ForgeDirection; +import net.minecraftforge.fluids.Fluid; +import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.fluids.FluidTank; +import net.minecraftforge.fluids.FluidTankInfo; +import net.minecraftforge.fluids.IFluidHandler; +import universalelectricity.core.vector.Vector3; +import universalelectricity.prefab.tile.TileEntityDisableable; + +public class TFissionReactor extends TileEntityDisableable + implements IInventory, ITemperature, IReactor, IFluidHandler { + + public static final int BAN_JING = 2; + public static final int WEN_DU = 2000; + public float wenDu = 0.0F; + private ItemStack[] containingItems = new ItemStack[1]; + public float rotation = 0.0F; + private TFissionReactor cachedZhuYao = null; + public FluidTank wasteTank; + + public TFissionReactor() { + this.wasteTank = new FluidTank(AtomicScience.FLUID_TOXIC_WASTE, 0, 800000); + } + + @Override + public void updateEntity() { + super.updateEntity(); + if (this.cachedZhuYao == null || super.ticks % 20L == 0L) { + this.zhaoZuiDi(); + } + + if (!this.isDisabled()) { + if (this.cachedZhuYao != this && this.getStackInSlot(0) != null && + this.cachedZhuYao.getStackInSlot(0) == null) { + this.cachedZhuYao.setInventorySlotContents(0, this.getStackInSlot(0)); + this.setInventorySlotContents(0, (ItemStack) null); + } + + ItemStack fissileFuel = this.cachedZhuYao.getStackInSlot(0); + int i; + if (fissileFuel != null && fissileFuel.getItem() instanceof IFissileMaterial) { + i = ((IFissileMaterial) fissileFuel.getItem()).onFissile(this); + if (!this.worldObj.isRemote) { + if (i == 0) { + fissileFuel.setItemDamage(Math.min(fissileFuel.getItemDamage() + 1, + fissileFuel.getMaxDamage())); + if (fissileFuel.getItemDamage() >= fissileFuel.getMaxDamage()) { + this.cachedZhuYao.setInventorySlotContents(0, (ItemStack) null); + } + } else if (i == 2) { + fissileFuel.setItemDamage( + Math.max(fissileFuel.getItemDamage() - 1, 0)); + } + } + + if (super.ticks % 20L == 0L && + (double) this.worldObj.rand.nextFloat() > 0.65D) { + List entitiesInRange = this.worldObj.getEntitiesWithinAABB( + EntityLivingBase.class, + AxisAlignedBB.getBoundingBox( + (double) (this.xCoord - 4), (double) (this.yCoord - 4), + (double) (this.xCoord - 4), (double) (this.xCoord + 4), + (double) (this.yCoord + 4), (double) (this.xCoord + 4))); + + for (EntityLivingBase entity : entitiesInRange) { + PoisonRadiation.INSTANCE.poisonEntity(new Vector3(this), entity); + } + } + + if ((double) this.worldObj.rand.nextFloat() > 0.5D) { + this.wasteTank.fill( + new FluidStack(AtomicScience.FLUID_TOXIC_WASTE, 1), true); + } + } + + if (this.wenDu > 2000.0F) { + this.meltDown(); + } else if (this.wenDu > 100.0F && + (fissileFuel == null || + !(fissileFuel.getItem() instanceof ItBreederFuel))) { + for (int x = -2; x <= 2; ++x) { + for (int z = -2; z <= 2; ++z) { + Vector3 offsetPos = new Vector3(this); + offsetPos.add(new Vector3((double) x, 0.0D, (double) z)); + Block offsetBlock = this.worldObj.getBlock( + offsetPos.intX(), offsetPos.intY(), offsetPos.intZ()); + if (offsetBlock != Blocks.water) { + if (this.isOverToxic() && !this.worldObj.isRemote && + (double) this.worldObj.rand.nextFloat() > 0.999D) { + if (offsetBlock == Blocks.grass) { + offsetPos.setBlock(this.worldObj, + AtomicScience.blockRadioactive); + } else if (offsetBlock != Blocks.air) { + offsetPos.setBlock( + this.worldObj, + this.wasteTank.getFluid().getFluid().getBlock()); + } + + this.wasteTank.drain(1000, true); + } + } else if (super.ticks % + (long) ((int) Math.max( + 40.0F - this.wenDu / 2000.0F * 40.0F, 2.0F)) == 0L) { + AtomicScience.boilWater(this.worldObj, offsetPos, 3, 8); + this.wenDu = (float) ((double) this.wenDu - 0.2D); + } + } + } + } + + for (int direction = 2; direction < 6; ++direction) { + Vector3 neighborPos = new Vector3(this); + neighborPos.modifyPositionFromSide( + ForgeDirection.getOrientation(direction)); + if (neighborPos.getBlock(this.worldObj) == AtomicScience.bControlRod) { + this.setTemperature(this.getTemperature() - 0.5F); + } + } + + if (!this.worldObj.isRemote) { + this.setTemperature(this.getTemperature() - 1.1F); + } + } + + if (!this.worldObj.isRemote && super.ticks % 60L == 0L) { + this.worldObj.markBlockForUpdate(this.xCoord, this.yCoord, this.zCoord); + } + } + + public boolean isOverToxic() { + return AtomicScience.ALLOW_TOXIC_WASTE && + // TODO >=? + this.wasteTank.getFluidAmount() > this.wasteTank.getCapacity(); + } + + public void updatePositionStatus() { + boolean top = (new Vector3(this)) + .add(new Vector3(0.0D, 1.0D, 0.0D)) + .getTileEntity(this.worldObj) instanceof TFissionReactor; + boolean bottom = (new Vector3(this)) + .add(new Vector3(0.0D, -1.0D, 0.0D)) + .getTileEntity(this.worldObj) instanceof TFissionReactor; + if (top && bottom) { + this.worldObj.setBlockMetadataWithNotify(this.xCoord, this.yCoord, + this.zCoord, 1, 3); + } else if (top) { + this.worldObj.setBlockMetadataWithNotify(this.xCoord, this.yCoord, + this.zCoord, 0, 3); + } else { + this.worldObj.setBlockMetadataWithNotify(this.xCoord, this.yCoord, + this.zCoord, 2, 3); + } + } + + public TFissionReactor zhaoZuiDi() { + Vector3 checkPosition = new Vector3(this); + TFissionReactor tile = null; + + do { + TileEntity newTile = checkPosition.getTileEntity(this.worldObj); + if (!(newTile instanceof TFissionReactor)) { + this.cachedZhuYao = tile; + return tile; + } + + tile = (TFissionReactor) newTile; + --checkPosition.y; + } while (tile != null); + + this.cachedZhuYao = this; + return this; + } + + public int getHeight() { + int height = 0; + Vector3 checkPosition = new Vector3(this); + + for (Object tile = this; tile instanceof TFissionReactor; tile = checkPosition.getTileEntity(this.worldObj)) { + ++checkPosition.y; + ++height; + } + + return height; + } + + @Override + public Packet getDescriptionPacket() { + NBTTagCompound nbt = new NBTTagCompound(); + this.writeToNBT(nbt); + return new S35PacketUpdateTileEntity(this.xCoord, this.yCoord, this.zCoord, + this.getBlockMetadata(), nbt); + } + + private void meltDown() { + if (!this.worldObj.isRemote) { + this.setInventorySlotContents(0, (ItemStack) null); + MegaTNTExplusion baoZha = new MegaTNTExplusion(this.worldObj, (Entity) null, (double) this.xCoord, + (double) this.yCoord, (double) this.zCoord, 9.0F); + baoZha.doExplosionA(); + baoZha.doExplosionB(true); + this.worldObj.setBlock(this.xCoord, this.yCoord, this.zCoord, + Blocks.lava); + } + } + + @Override + public void onDataPacket(NetworkManager arg0, + S35PacketUpdateTileEntity packet) { + this.readFromNBT(packet.func_148857_g()); + } + + public void readFromNBT(NBTTagCompound nbt) { + super.readFromNBT(nbt); + this.wenDu = nbt.getFloat("temperature"); + this.wasteTank.readFromNBT(nbt.getCompoundTag("tank")); + NBTTagList items = nbt.getTagList("Items", 10); // 10 = magic number for compound + this.containingItems = new ItemStack[this.getSizeInventory()]; + + for (int i = 0; i < items.tagCount(); ++i) { + NBTTagCompound item = items.getCompoundTagAt(i); + byte var5 = item.getByte("Slot"); + if (var5 >= 0 && var5 < this.containingItems.length) { + this.containingItems[var5] = ItemStack.loadItemStackFromNBT(item); + this.containingItems[var5].setItemDamage(item.getInteger("damage")); + } + } + } + + @Override + public void writeToNBT(NBTTagCompound par1NBTTagCompound) { + super.writeToNBT(par1NBTTagCompound); + par1NBTTagCompound.setFloat("temperature", this.wenDu); + NBTTagCompound tankNBT = new NBTTagCompound(); + this.wasteTank.writeToNBT(tankNBT); + par1NBTTagCompound.setTag("tank", tankNBT); + NBTTagList var2 = new NBTTagList(); + + for (int var3 = 0; var3 < this.containingItems.length; ++var3) { + if (this.containingItems[var3] != null) { + NBTTagCompound var4 = new NBTTagCompound(); + var4.setByte("Slot", (byte) var3); + this.containingItems[var3].writeToNBT(var4); + var4.setInteger("damage", this.containingItems[var3].getItemDamage()); + var2.appendTag(var4); + } + } + + par1NBTTagCompound.setTag("Items", var2); + } + + @Override + public int getSizeInventory() { + return this.containingItems.length; + } + + @Override + public ItemStack getStackInSlot(int par1) { + return this.containingItems[par1]; + } + + @Override + public ItemStack decrStackSize(int par1, int par2) { + if (this.containingItems[par1] != null) { + ItemStack var3; + if (this.containingItems[par1].stackSize <= par2) { + var3 = this.containingItems[par1]; + this.containingItems[par1] = null; + return var3; + } else { + var3 = this.containingItems[par1].splitStack(par2); + if (this.containingItems[par1].stackSize == 0) { + this.containingItems[par1] = null; + } + + return var3; + } + } else { + return null; + } + } + + @Override + public ItemStack getStackInSlotOnClosing(int par1) { + if (this.containingItems[par1] != null) { + ItemStack var2 = this.containingItems[par1]; + this.containingItems[par1] = null; + return var2; + } else { + return null; + } + } + + @Override + public void setInventorySlotContents(int par1, ItemStack par2ItemStack) { + this.containingItems[par1] = par2ItemStack; + if (par2ItemStack != null && + par2ItemStack.stackSize > this.getInventoryStackLimit()) { + par2ItemStack.stackSize = this.getInventoryStackLimit(); + } + + this.markDirty(); + } + + @Override + public int getInventoryStackLimit() { + return 1; + } + + @Override + public boolean isUseableByPlayer(EntityPlayer par1EntityPlayer) { + return this.worldObj.getTileEntity(this.xCoord, this.yCoord, this.zCoord) != this + ? false + : par1EntityPlayer.getDistanceSq((double) this.xCoord + 0.5D, + (double) this.yCoord + 0.5D, + (double) this.zCoord + 0.5D) <= 64.0D; + } + + @Override + public void openInventory() { + } + + @Override + public void closeInventory() { + } + + @Override + public void onDisable(int duration) { + super.disabledTicks = duration; + } + + @Override + public boolean isDisabled() { + return super.disabledTicks > 0; + } + + @Override + public float getTemperature() { + return this.wenDu; + } + + @Override + public void setTemperature(float celsius) { + this.wenDu = Math.max(celsius, 0.0F); + } + + @Override + public boolean isItemValidForSlot(int slotID, ItemStack itemStack) { + return this.cachedZhuYao != null && + this.cachedZhuYao.getStackInSlot(0) == null + ? itemStack.getItem() instanceof IFissileMaterial + : false; + } + + @Override + public boolean canFill(ForgeDirection arg0, Fluid arg1) { + return false; + } + + @Override + public int fill(ForgeDirection from, FluidStack resource, boolean doFill) { + return 0; + } + + @Override + public boolean canDrain(ForgeDirection arg0, Fluid arg1) { + return arg1 == AtomicScience.FLUID_TOXIC_WASTE && + this.wasteTank.getFluidAmount() > 0; + } + + @Override + public FluidStack drain(ForgeDirection from, int maxDrain, boolean doDrain) { + return this.wasteTank.drain(maxDrain, doDrain); + } + + @Override + public FluidStack drain(ForgeDirection from, FluidStack fluid, + boolean doDrain) { + return fluid.getFluid() == AtomicScience.FLUID_TOXIC_WASTE + ? this.drain(from, fluid.amount, doDrain) + : null; + } + + @Override + public FluidTankInfo[] getTankInfo(ForgeDirection arg0) { + return new FluidTankInfo[] { new FluidTankInfo(this.wasteTank) }; + } + + @Override + @SideOnly(Side.CLIENT) + public AxisAlignedBB getRenderBoundingBox() { + return this.cachedZhuYao == this ? TileEntity.INFINITE_EXTENT_AABB + : super.getRenderBoundingBox(); + } + + @Override + public String getInventoryName() { + return this.getBlockType().getLocalizedName(); + } + + @Override + public boolean hasCustomInventoryName() { + return false; + } +} diff --git a/src/main/java/atomicscience/fenlie/TNuclearBoiler.java b/src/main/java/atomicscience/fenlie/TNuclearBoiler.java new file mode 100644 index 0000000..07a86dc --- /dev/null +++ b/src/main/java/atomicscience/fenlie/TNuclearBoiler.java @@ -0,0 +1,260 @@ +package atomicscience.fenlie; + +import atomicscience.AtomicScience; +import atomicscience.jiqi.TInventory; +import net.minecraft.inventory.ISidedInventory; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.network.NetworkManager; +import net.minecraft.network.Packet; +import net.minecraft.network.play.server.S35PacketUpdateTileEntity; +import net.minecraftforge.common.util.ForgeDirection; +import net.minecraftforge.fluids.Fluid; +import net.minecraftforge.fluids.FluidContainerRegistry; +import net.minecraftforge.fluids.FluidRegistry; +import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.fluids.FluidTank; +import net.minecraftforge.fluids.FluidTankInfo; +import net.minecraftforge.fluids.IFluidHandler; +import universalelectricity.core.electricity.ElectricityPack; +import universalelectricity.core.item.ElectricItemHelper; +import universalelectricity.prefab.implement.IRotatable; + +public class TNuclearBoiler + extends TInventory implements ISidedInventory, IFluidHandler, IRotatable { + + public final int SHI_JIAN = 300; + public final float DIAN = 800.0F; + public int smeltingTicks = 0; + public float rotation = 0.0F; + public final FluidTank waterTank; + public final FluidTank gasTank; + + public TNuclearBoiler() { + this.waterTank = new FluidTank(FluidRegistry.WATER, 0, 5000); + this.gasTank = new FluidTank(AtomicScience.FLUID_URANIUM_HEXAFLOURIDE, 0, 5000); + // TODO: WTF + // this.waterTank.setTankPressure(-10); + // this.gasTank.setTankPressure(10); + } + + @Override + public ElectricityPack getRequest() { + return this.canWork() + ? new ElectricityPack(800.0D / this.getVoltage(), this.getVoltage()) + : new ElectricityPack(); + } + + @Override + public void updateEntity() { + super.updateEntity(); + if (!this.worldObj.isRemote && !this.isDisabled()) { + if (super.containingItems[1] != null && + FluidContainerRegistry.isFilledContainer(super.containingItems[1])) { + if (FluidContainerRegistry + .getFluidForFilledItem(super.containingItems[1]) + .getFluid() == FluidRegistry.WATER && + this.fill(ForgeDirection.UNKNOWN, + FluidContainerRegistry.getFluidForFilledItem( + super.containingItems[1]), + false) > 0) { + ItemStack player = super.containingItems[1].getItem().getContainerItem( + super.containingItems[1]); + if (player == null && super.containingItems[1].stackSize > 1) { + --super.containingItems[1].stackSize; + } else { + super.containingItems[1] = player; + } + + this.waterTank.fill(FluidContainerRegistry.getFluidForFilledItem( + super.containingItems[1]), + true); + } + } + + if (this.canWork()) { + super.wattsReceived += ElectricItemHelper.dechargeItem( + super.containingItems[0], 800.0D, this.getVoltage()); + double var10000 = super.wattsReceived; + this.getClass(); + if (var10000 >= (double) (800.0F / 2.0F)) { + if (this.smeltingTicks == 0) { + this.smeltingTicks = 300; + } + + if (this.smeltingTicks > 0) { + --this.smeltingTicks; + if (this.smeltingTicks < 1) { + this.work(); + this.smeltingTicks = 0; + } + } else { + this.smeltingTicks = 0; + } + + super.wattsReceived = 0.0D; + } + } else { + this.smeltingTicks = 0; + } + + if (super.ticks % 10L == 0L) { + this.worldObj.markBlockForUpdate(this.xCoord, this.yCoord, this.zCoord); + } + } + } + + @Override + public void onDataPacket(NetworkManager arg0, + S35PacketUpdateTileEntity arg1) { + NBTTagCompound nbt = arg1.func_148857_g(); + this.smeltingTicks = nbt.getInteger("smeltingTicks"); + this.waterTank.setFluid( + new FluidStack(FluidRegistry.WATER, nbt.getInteger("waterAmount"))); + this.gasTank.setFluid( + new FluidStack(AtomicScience.FLUID_URANIUM_HEXAFLOURIDE, + nbt.getInteger("uraniumHexaflourideAmount"))); + super.disabledTicks = nbt.getInteger("disabledTicks"); + } + + @Override + public Packet getDescriptionPacket() { + NBTTagCompound nbt = new NBTTagCompound(); + nbt.setInteger("smeltingTicks", this.smeltingTicks); + nbt.setInteger("waterAmount", this.waterTank.getFluidAmount()); + nbt.setInteger("uraniumHexaflourideAmount", this.gasTank.getFluidAmount()); + nbt.setInteger("disabledTicks", super.disabledTicks); + + return new S35PacketUpdateTileEntity(this.xCoord, this.yCoord, this.zCoord, + this.getBlockMetadata(), nbt); + } + + @Override + public void openInventory() { + if (!this.worldObj.isRemote) { + this.worldObj.markBlockForUpdate(this.xCoord, this.yCoord, this.zCoord); + } + } + + public boolean canWork() { + return !this.isDisabled() && this.waterTank.getFluid().getFluid() != null && + this.waterTank.getFluidAmount() >= 1000 && + super.containingItems[3] != null && + (AtomicScience.itYellowcake == super.containingItems[3].getItem() || + AtomicScience.isUraniumOre(super.containingItems[3])) + && + this.gasTank.getFluidAmount() < this.gasTank.getCapacity(); + } + + public void work() { + if (this.canWork()) { + this.waterTank.drain(1000, true); + // FluidStack liquid = AtomicScience.FLUID_URANIUM_HEXAFLOURIDE.copy(); + // liquid.amount = AtomicScience.URANIUM_HEXAFLOURIDE_RATIO * 2; + this.gasTank.fill( + new FluidStack(AtomicScience.FLUID_URANIUM_HEXAFLOURIDE, + AtomicScience.URANIUM_HEXAFLOURIDE_RATIO * 2), + true); + this.decrStackSize(3, 1); + } + } + + public void readFromNBT(NBTTagCompound nbt) { + super.readFromNBT(nbt); + this.smeltingTicks = nbt.getInteger("smeltingTicks"); + NBTTagCompound waterCompound = nbt.getCompoundTag("water"); + this.waterTank.setFluid(FluidStack.loadFluidStackFromNBT(waterCompound)); + NBTTagCompound gasCompound = nbt.getCompoundTag("gas"); + this.gasTank.setFluid(FluidStack.loadFluidStackFromNBT(gasCompound)); + } + + @Override + public void writeToNBT(NBTTagCompound nbt) { + super.writeToNBT(nbt); + nbt.setInteger("smeltingTicks", this.smeltingTicks); + NBTTagCompound compound; + if (this.waterTank.getFluid() != null) { + compound = new NBTTagCompound(); + this.waterTank.getFluid().writeToNBT(compound); + nbt.setTag("water", compound); + } + + if (this.gasTank.getFluid() != null) { + compound = new NBTTagCompound(); + this.gasTank.getFluid().writeToNBT(compound); + nbt.setTag("gas", compound); + } + } + + @Override + public boolean canFill(ForgeDirection arg0, Fluid arg1) { + if (arg1 == FluidRegistry.WATER) { + return this.waterTank.getFluidAmount() < this.waterTank.getCapacity(); + } else if (arg1 == AtomicScience.FLUID_URANIUM_HEXAFLOURIDE) { + return this.gasTank.getFluidAmount() < this.waterTank.getCapacity(); + } + + return false; + } + + @Override + public int fill(ForgeDirection from, FluidStack resource, boolean doFill) { + return FluidRegistry.WATER == resource.getFluid() + ? this.waterTank.fill(resource, doFill) + : (AtomicScience.FLUID_URANIUM_HEXAFLOURIDE == resource.getFluid() + ? this.gasTank.fill(resource, doFill) + : 0); + } + + @Override + public FluidStack drain(ForgeDirection from, int maxDrain, boolean doDrain) { + return this.gasTank.drain(maxDrain, doDrain); + } + + @Override + public FluidStack drain(ForgeDirection arg0, FluidStack arg1, boolean arg2) { + return arg1.getFluid() == AtomicScience.FLUID_URANIUM_HEXAFLOURIDE + ? this.gasTank.drain(arg1.amount, true) + : null; + } + + @Override + public boolean canDrain(ForgeDirection arg0, Fluid arg1) { + return arg1 == AtomicScience.FLUID_URANIUM_HEXAFLOURIDE && + this.gasTank.getFluidAmount() > 0; + } + + @Override + public FluidTankInfo[] getTankInfo(ForgeDirection arg0) { + return new FluidTankInfo[] { new FluidTankInfo(this.waterTank), + new FluidTankInfo(this.gasTank) }; + } + + @Override + public int getSizeInventory() { + return 4; + } + + @Override + public boolean isItemValidForSlot(int slotID, ItemStack itemStack) { + return slotID == 1 + ? AtomicScience.isCellWater(itemStack) + : (slotID == 3 ? itemStack.getItem() == AtomicScience.itYellowcake + : false); + } + + @Override + public int[] getAccessibleSlotsFromSide(int side) { + return side == 0 ? new int[] { 2 } : new int[] { 1, 3 }; + } + + @Override + public boolean canInsertItem(int slotID, ItemStack itemStack, int side) { + return this.isItemValidForSlot(slotID, itemStack); + } + + @Override + public boolean canExtractItem(int slotID, ItemStack itemstack, int j) { + return slotID == 2; + } +} diff --git a/src/main/java/atomicscience/fenlie/TReactorTap.java b/src/main/java/atomicscience/fenlie/TReactorTap.java new file mode 100644 index 0000000..f8e267d --- /dev/null +++ b/src/main/java/atomicscience/fenlie/TReactorTap.java @@ -0,0 +1,142 @@ +package atomicscience.fenlie; + +import java.util.HashSet; +import java.util.Set; +import net.minecraft.block.Block; +import net.minecraft.block.BlockLiquid; +import net.minecraft.init.Blocks; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; +import net.minecraftforge.common.util.ForgeDirection; +import net.minecraftforge.fluids.Fluid; +import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.fluids.FluidTank; +import net.minecraftforge.fluids.FluidTankInfo; +import net.minecraftforge.fluids.IFluidHandler; +import universalelectricity.core.path.IPathCallBack; +import universalelectricity.core.path.Pathfinder; +import universalelectricity.core.vector.Vector3; +import universalelectricity.prefab.tile.TileEntityAdvanced; + +public class TReactorTap extends TileEntityAdvanced implements IFluidHandler { + + private final Set tanks = new HashSet<>(); + private long lastFindTime = -1L; + + public void find() { + this.tanks.clear(); + final World world = this.worldObj; + final Vector3 position = new Vector3(this); + Pathfinder finder = (new Pathfinder(new IPathCallBack() { + public Set getConnectedNodes(Pathfinder finder, Vector3 currentNode) { + HashSet neighbors = new HashSet<>(); + + for (int i = 0; i < 6; ++i) { + ForgeDirection direction = ForgeDirection.getOrientation(i); + Vector3 positionx = currentNode.clone().modifyPositionFromSide(direction); + Block connectedBlockID = positionx.getBlock(world); + if (connectedBlockID == Blocks.air || + connectedBlockID instanceof BlockLiquid || + connectedBlockID instanceof BFissionReactor) { + neighbors.add(positionx); + } + } + + return neighbors; + } + + public boolean onSearch(Pathfinder finder, Vector3 node) { + if (node.getTileEntity(world) instanceof TFissionReactor) { + finder.results.add(node); + } + + return node.distanceTo(position) > 6.0D; + } + })) + .init((new Vector3(this)) + .modifyPositionFromSide( + ForgeDirection.getOrientation(this.getBlockMetadata()) + .getOpposite())); + for (Vector3 node : (Set) finder.results) { + TileEntity tileEntity = node.getTileEntity(this.worldObj); + if (tileEntity instanceof TFissionReactor) { + this.tanks.add(((TFissionReactor) tileEntity).wasteTank); + } + } + + this.lastFindTime = this.worldObj.getWorldTime(); + } + + public FluidTank getOptimalTank() { + if (this.lastFindTime == -1L || + this.worldObj.getWorldTime() - this.lastFindTime > 20L) { + this.find(); + } + + if (this.tanks.size() <= 0) { + return null; + } + + FluidTank optimalTank = null; + for (FluidTank tank : this.tanks) { + if (this.getLiquidSafe(tank.getFluid()) > this.getLiquidSafe(optimalTank.getFluid())) { + optimalTank = tank; + } + } + + return optimalTank; + } + + public int getLiquidSafe(FluidStack stack) { + return stack != null ? stack.amount : 0; + } + + public boolean canUpdate() { + return false; + } + + public int fill(ForgeDirection from, FluidStack resource, boolean doFill) { + return 0; + } + + public int fill(int tankIndex, FluidStack resource, boolean doFill) { + return 0; + } + + public FluidStack drain(ForgeDirection from, int maxDrain, boolean doDrain) { + return this.getOptimalTank() != null + ? this.getOptimalTank().drain(maxDrain, doDrain) + : null; + } + + @Override + public FluidStack drain(ForgeDirection arg0, FluidStack arg1, boolean arg2) { + return this.getOptimalTank() != null && + arg1.getFluid() == this.getOptimalTank().getFluid().getFluid() + ? this.drain(arg0, arg1.amount, arg2) + : null; + } + + @Override + public boolean canDrain(ForgeDirection arg0, Fluid arg1) { + return this.getOptimalTank() != null && + this.getOptimalTank().getFluid().getFluid() == arg1 && + this.getOptimalTank().getFluidAmount() != 0; + } + + @Override + public FluidTankInfo[] getTankInfo(ForgeDirection arg0) { + if (arg0.ordinal() != this.getBlockMetadata()) + return null; + + this.find(); + return (FluidTankInfo[]) this.tanks.stream() + .map(FluidTankInfo::new) + .toArray(); + } + + @Override + public boolean canFill(ForgeDirection arg0, Fluid arg1) { + return false; + } +} diff --git a/src/main/java/atomicscience/hecheng/BElectromagnet.java b/src/main/java/atomicscience/hecheng/BElectromagnet.java new file mode 100644 index 0000000..6212cc8 --- /dev/null +++ b/src/main/java/atomicscience/hecheng/BElectromagnet.java @@ -0,0 +1,42 @@ +package atomicscience.hecheng; + +import atomicscience.api.IElectromagnet; +import atomicscience.hecheng.TElectromagnet; +import atomicscience.jiqi.BBase; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.IIcon; +import net.minecraft.world.World; + +public class BElectromagnet extends BBase implements IElectromagnet { + private IIcon iconTop; + + public BElectromagnet() { + super("electromagnet"); + } + + @Override + public IIcon getIcon(int side, int metadata) { + return side != 0 && side != 1 ? this.blockIcon : this.iconTop; + } + + @Override + @SideOnly(Side.CLIENT) + public void registerBlockIcons(IIconRegister iconRegister) { + super.registerBlockIcons(iconRegister); + this.iconTop = iconRegister.registerIcon( + this.getUnlocalizedName().replace("tile.", "") + "_top"); + } + + @Override + public TileEntity createNewTileEntity(World var1, int meta) { + return new TElectromagnet(); + } + + @Override + public boolean isRunning(World world, int x, int y, int z) { + return true; + } +} diff --git a/src/main/java/atomicscience/hecheng/BElectromagnetGlass.java b/src/main/java/atomicscience/hecheng/BElectromagnetGlass.java new file mode 100644 index 0000000..a386409 --- /dev/null +++ b/src/main/java/atomicscience/hecheng/BElectromagnetGlass.java @@ -0,0 +1,56 @@ +package atomicscience.hecheng; + +import atomicscience.api.IElectromagnet; +import atomicscience.jiqi.BBase; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import net.minecraft.block.Block; +import net.minecraft.block.material.Material; +import net.minecraft.world.IBlockAccess; +import net.minecraft.world.World; + +public class BElectromagnetGlass extends BBase implements IElectromagnet { + public BElectromagnetGlass() { + super("electromagnetGlass", Material.glass); + } + + @Override + @SideOnly(Side.CLIENT) + public boolean shouldSideBeRendered(IBlockAccess par1IBlockAccess, int par2, + int par3, int par4, int par5) { + Block i1 = par1IBlockAccess.getBlock(par2, par3, par4); + return i1 == this + ? false + : super.shouldSideBeRendered(par1IBlockAccess, par2, par3, par4, par5); + } + + @Override + public int getRenderBlockPass() { + return 0; + } + + @Override + public boolean isOpaqueCube() { + return false; + } + + @Override + public boolean renderAsNormalBlock() { + return false; + } + + @Override + protected boolean canSilkHarvest() { + return true; + } + + @Override + public boolean isRunning(World world, int x, int y, int z) { + return true; + } + + @Override + public boolean hasTileEntity(int metadata) { + return false; + } +} diff --git a/src/main/java/atomicscience/hecheng/BFusionReactor.java b/src/main/java/atomicscience/hecheng/BFusionReactor.java new file mode 100644 index 0000000..5e7d001 --- /dev/null +++ b/src/main/java/atomicscience/hecheng/BFusionReactor.java @@ -0,0 +1,63 @@ +package atomicscience.hecheng; + +import atomicscience.AtomicScience; +import atomicscience.jiqi.BBase; +import atomicscience.render.RH; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; + +public class BFusionReactor extends BBase { + + public BFusionReactor() { + super("fusionReactor"); + } + + @Override + public boolean onMachineActivated(World world, int x, int y, int z, + EntityPlayer entityPlayer, int side, + float hitX, float hitY, float hitZ) { + TileEntity tileEntity = world.getTileEntity(x, y, z); + if (entityPlayer.inventory.getCurrentItem() != null && + AtomicScience.isFusionFuel(entityPlayer.inventory.getCurrentItem())) { + if (((TFusionReactor) tileEntity).getStackInSlot(0) != null) { + ItemStack var10000 = ((TFusionReactor) tileEntity).getStackInSlot(0); + var10000.stackSize += entityPlayer.inventory.getCurrentItem().stackSize; + } else { + ((TFusionReactor) tileEntity) + .setInventorySlotContents(0, + entityPlayer.inventory.getCurrentItem()); + } + + entityPlayer.inventory.setInventorySlotContents( + entityPlayer.inventory.currentItem, (ItemStack) null); + return true; + } else { + return false; + } + } + + @Override + @SideOnly(Side.CLIENT) + public int getRenderType() { + return RH.BLOCK_RENDER_ID; + } + + @Override + public TileEntity createNewTileEntity(World var1, int meta) { + return new TFusionReactor(); + } + + @Override + public boolean renderAsNormalBlock() { + return false; + } + + @Override + public boolean isOpaqueCube() { + return false; + } +} diff --git a/src/main/java/atomicscience/hecheng/BPlasma.java b/src/main/java/atomicscience/hecheng/BPlasma.java new file mode 100644 index 0000000..6e9a465 --- /dev/null +++ b/src/main/java/atomicscience/hecheng/BPlasma.java @@ -0,0 +1,161 @@ +package atomicscience.hecheng; + +import atomicscience.api.IElectromagnet; +import atomicscience.api.Plasma; +import atomicscience.hecheng.TElectromagnet; +import atomicscience.jiqi.BBase; +import java.util.Random; +import net.minecraft.block.Block; +import net.minecraft.block.material.Material; +import net.minecraft.entity.Entity; +import net.minecraft.entity.EntityLiving; +import net.minecraft.entity.EntityLivingBase; +import net.minecraft.init.Blocks; +import net.minecraft.item.ItemStack; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.AxisAlignedBB; +import net.minecraft.util.DamageSource; +import net.minecraft.util.MovingObjectPosition; +import net.minecraft.world.IBlockAccess; +import net.minecraft.world.World; +import net.minecraftforge.common.util.ForgeDirection; +import universalelectricity.core.vector.Vector3; + +public class BPlasma extends BBase implements Plasma.IPlasma { + public BPlasma() { + super("plasma", Material.lava); + this.setLightLevel(0.5F); + super.textureName = "portal"; + } + + @Override + public void onBlockAdded(World worldObj, int x, int y, int z) { + if (!worldObj.isRemote) { + Vector3 diDian = new Vector3((double) x, (double) y, (double) z); + int xinMeta = Math.max(diDian.getBlockMetadata(worldObj) - 1, 0); + if (xinMeta <= 0) { + diDian.setBlock(worldObj, Blocks.fire); + return; + } + + for (int i = 0; i < 6; ++i) { + if ((double) worldObj.rand.nextFloat() <= 0.8D) { + Vector3 zhaoDiDian = diDian.clone(); + zhaoDiDian.modifyPositionFromSide(ForgeDirection.getOrientation(i)); + if (this.canPlace(worldObj, zhaoDiDian.intX(), zhaoDiDian.intY(), + zhaoDiDian.intZ())) { + Block tileEntity = zhaoDiDian.getBlock(worldObj); + if (tileEntity != this) { + zhaoDiDian.setBlock(worldObj, this, xinMeta); + } + } else { + TileEntity var10 = zhaoDiDian.getTileEntity(worldObj); + if (var10 instanceof TElectromagnet) { + ((TElectromagnet) var10) + .setTemperature(((TElectromagnet) var10).getTemperature() + 100.0F); + } + } + } + } + + worldObj.scheduleBlockUpdate( + x, y, z, this, + (new Vector3((double) x, (double) y, (double) z)) + .getBlockMetadata(worldObj) * + 5); + } + } + + @Override + public void updateTick(World worldObj, int x, int y, int z, + Random par5Random) { + Vector3 diDian = new Vector3((double) x, (double) y, (double) z); + diDian.setBlock(worldObj, Blocks.fire); + } + + @Override + public void onNeighborBlockChange(World worldObj, int x, int y, int z, + Block neighborID) { + if (neighborID != this && neighborID != Blocks.fire) { + worldObj.scheduleBlockUpdate( + x, y, z, this, + (new Vector3((double) x, (double) y, (double) z)) + .getBlockMetadata(worldObj) * + 5); + } + } + + @Override + public void spawn(World world, int x, int y, int z, byte strength) { + if (this.canPlace(world, x, y, z)) { + world.setBlock(x, y, z, this, strength, 3); + } + } + + @Override + public boolean canPlace(World world, int x, int y, int z) { + Vector3 position = new Vector3((double) x, (double) y, (double) z); + Block block = position.getBlock(world); + return block == null || block != Blocks.bedrock && + !(block instanceof IElectromagnet) && + block != Blocks.iron_block; + } + + @Override + public boolean renderAsNormalBlock() { + return false; + } + + @Override + public boolean isOpaqueCube() { + return false; + } + + @Override + public boolean isBlockSolid(IBlockAccess par1IBlockAccess, int par2, int par3, + int par4, int par5) { + return false; + } + + @Override + public AxisAlignedBB getCollisionBoundingBoxFromPool(World par1World, + int par2, int par3, + int par4) { + return null; + } + + @Override + public int quantityDropped(Random par1Random) { + return 0; + } + + @Override + public int tickRate(World par1World) { + return 8; + } + + @Override + public int getRenderBlockPass() { + return 1; + } + + @Override + public void onEntityCollidedWithBlock(World par1World, int par2, int par3, int par4, + Entity par5Entity) { + if (par5Entity instanceof EntityLivingBase) { + if (par5Entity.isImmuneToFire()) { + par5Entity.attackEntityFrom(DamageSource.magic, 1073741823); + } else { + par5Entity.attackEntityFrom(DamageSource.inFire, 1073741823); + } + } else { + par5Entity.setDead(); + } + } + + @Override + public ItemStack getPickBlock(MovingObjectPosition target, World world, int x, + int y, int z) { + return null; + } +} diff --git a/src/main/java/atomicscience/hecheng/CChemicalExtractor.java b/src/main/java/atomicscience/hecheng/CChemicalExtractor.java new file mode 100644 index 0000000..0f62fad --- /dev/null +++ b/src/main/java/atomicscience/hecheng/CChemicalExtractor.java @@ -0,0 +1,109 @@ +package atomicscience.hecheng; + +import atomicscience.AtomicScience; +import atomicscience.jiqi.TChemicalExtractor; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.entity.player.InventoryPlayer; +import net.minecraft.inventory.Container; +import net.minecraft.inventory.Slot; +import net.minecraft.inventory.SlotFurnace; +import net.minecraft.item.ItemStack; +import net.minecraftforge.fluids.FluidContainerRegistry; +import net.minecraftforge.fluids.FluidRegistry; +import universalelectricity.core.item.IItemElectric; +import universalelectricity.prefab.SlotSpecific; + +public class CChemicalExtractor extends Container { + // private static final int slotCount = 4; + private TChemicalExtractor tileEntity; + + public CChemicalExtractor(InventoryPlayer par1InventoryPlayer, + TChemicalExtractor tileEntity) { + this.tileEntity = tileEntity; + this.addSlotToContainer( + new SlotSpecific(tileEntity, 0, 65, 49, IItemElectric.class)); + this.addSlotToContainer(new Slot(tileEntity, 1, 25, 50)); + this.addSlotToContainer( + new SlotFurnace(par1InventoryPlayer.player, tileEntity, 2, 118, 25)); + this.addSlotToContainer(new Slot(tileEntity, 3, 65, 25)); + + int var3; + for (var3 = 0; var3 < 3; ++var3) { + for (int var4 = 0; var4 < 9; ++var4) { + this.addSlotToContainer(new Slot(par1InventoryPlayer, + var4 + var3 * 9 + 9, 8 + var4 * 18, + 84 + var3 * 18)); + } + } + + for (var3 = 0; var3 < 9; ++var3) { + this.addSlotToContainer( + new Slot(par1InventoryPlayer, var3, 8 + var3 * 18, 142)); + } + + tileEntity.openInventory(); + this.tileEntity.players.add(par1InventoryPlayer.player); + } + + @Override + public void onContainerClosed(EntityPlayer entityplayer) { + super.onContainerClosed(entityplayer); + this.tileEntity.players.remove(entityplayer); + } + + @Override + public boolean canInteractWith(EntityPlayer par1EntityPlayer) { + return this.tileEntity.isUseableByPlayer(par1EntityPlayer); + } + + @Override + public ItemStack transferStackInSlot(EntityPlayer par1EntityPlayer, + int par1) { + ItemStack var2 = null; + Slot var3 = (Slot) super.inventorySlots.get(par1); + if (var3 != null && var3.getHasStack()) { + ItemStack itemStack = var3.getStack(); + var2 = itemStack.copy(); + if (par1 >= 4) { + if (itemStack.getItem() instanceof IItemElectric) { + if (!this.mergeItemStack(itemStack, 0, 1, false)) { + return null; + } + } else if (FluidRegistry.WATER == FluidContainerRegistry.getFluidForFilledItem(itemStack) + .getFluid()) { + if (!this.mergeItemStack(itemStack, 1, 2, false)) { + return null; + } + } else if (!AtomicScience.isCell(itemStack) && + !AtomicScience.isUraniumOre(itemStack)) { + if (par1 < 31) { + if (!this.mergeItemStack(itemStack, 31, 40, false)) { + return null; + } + } else if (par1 >= 31 && par1 < 40 && + !this.mergeItemStack(itemStack, 4, 30, false)) { + return null; + } + } else if (!this.mergeItemStack(itemStack, 3, 4, false)) { + return null; + } + } else if (!this.mergeItemStack(itemStack, 4, 40, false)) { + return null; + } + + if (itemStack.stackSize == 0) { + var3.putStack((ItemStack) null); + } else { + var3.onSlotChanged(); + } + + if (itemStack.stackSize == var2.stackSize) { + return null; + } + + var3.onPickupFromSlot(par1EntityPlayer, itemStack); + } + + return var2; + } +} diff --git a/src/main/java/atomicscience/hecheng/CNuclearBoiler.java b/src/main/java/atomicscience/hecheng/CNuclearBoiler.java new file mode 100644 index 0000000..cd1b830 --- /dev/null +++ b/src/main/java/atomicscience/hecheng/CNuclearBoiler.java @@ -0,0 +1,108 @@ +package atomicscience.hecheng; + +import atomicscience.AtomicScience; +import atomicscience.fenlie.TNuclearBoiler; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.entity.player.InventoryPlayer; +import net.minecraft.inventory.Container; +import net.minecraft.inventory.Slot; +import net.minecraft.item.ItemStack; +import net.minecraftforge.fluids.FluidContainerRegistry; +import net.minecraftforge.fluids.FluidRegistry; +import universalelectricity.core.item.IItemElectric; +import universalelectricity.prefab.SlotSpecific; + +public class CNuclearBoiler extends Container { + // private static final int slotCount = 4; + private TNuclearBoiler tileEntity; + + public CNuclearBoiler(InventoryPlayer par1InventoryPlayer, + TNuclearBoiler tileEntity) { + this.tileEntity = tileEntity; + this.addSlotToContainer( + new SlotSpecific(tileEntity, 0, 56, 26, IItemElectric.class)); + this.addSlotToContainer(new Slot(tileEntity, 1, 25, 50)); + this.addSlotToContainer(new Slot(tileEntity, 2, 136, 50)); + this.addSlotToContainer(new SlotSpecific( + tileEntity, 3, 81, 26, + new ItemStack[] { new ItemStack(AtomicScience.itYellowcake), + new ItemStack(AtomicScience.bUraniumOre) })); + + int var3; + for (var3 = 0; var3 < 3; ++var3) { + for (int var4 = 0; var4 < 9; ++var4) { + this.addSlotToContainer(new Slot(par1InventoryPlayer, + var4 + var3 * 9 + 9, 8 + var4 * 18, + 84 + var3 * 18)); + } + } + + for (var3 = 0; var3 < 9; ++var3) { + this.addSlotToContainer( + new Slot(par1InventoryPlayer, var3, 8 + var3 * 18, 142)); + } + + this.tileEntity.players.add(par1InventoryPlayer.player); + tileEntity.openInventory(); + } + + @Override + public void onContainerClosed(EntityPlayer entityplayer) { + super.onContainerClosed(entityplayer); + this.tileEntity.players.remove(entityplayer); + } + + @Override + public boolean canInteractWith(EntityPlayer par1EntityPlayer) { + return this.tileEntity.isUseableByPlayer(par1EntityPlayer); + } + + @Override + public ItemStack transferStackInSlot(EntityPlayer par1EntityPlayer, + int slotID) { + ItemStack var2 = null; + Slot slot = (Slot) super.inventorySlots.get(slotID); + if (slot != null && slot.getHasStack()) { + ItemStack itemStack = slot.getStack(); + var2 = itemStack.copy(); + if (slotID >= 4) { + if (itemStack.getItem() instanceof IItemElectric) { + if (!this.mergeItemStack(itemStack, 0, 1, false)) { + return null; + } + } else if (FluidRegistry.WATER == FluidContainerRegistry.getFluidForFilledItem(itemStack).getFluid()) { + if (!this.mergeItemStack(itemStack, 1, 2, false)) { + return null; + } + } else if (this.getSlot(3).isItemValid(itemStack)) { + if (!this.mergeItemStack(itemStack, 3, 4, false)) { + return null; + } + } else if (slotID < 31) { + if (!this.mergeItemStack(itemStack, 31, 40, false)) { + return null; + } + } else if (slotID >= 31 && slotID < 40 && + !this.mergeItemStack(itemStack, 4, 30, false)) { + return null; + } + } else if (!this.mergeItemStack(itemStack, 4, 40, false)) { + return null; + } + + if (itemStack.stackSize == 0) { + slot.putStack((ItemStack) null); + } else { + slot.onSlotChanged(); + } + + if (itemStack.stackSize == var2.stackSize) { + return null; + } + + slot.onPickupFromSlot(par1EntityPlayer, itemStack); + } + + return var2; + } +} diff --git a/src/main/java/atomicscience/hecheng/IBAccelerator.java b/src/main/java/atomicscience/hecheng/IBAccelerator.java new file mode 100644 index 0000000..9ce31b7 --- /dev/null +++ b/src/main/java/atomicscience/hecheng/IBAccelerator.java @@ -0,0 +1,16 @@ +package atomicscience.hecheng; + +import net.minecraft.block.Block; +import net.minecraft.item.ItemBlock; + +public class IBAccelerator extends ItemBlock { + public IBAccelerator(Block b) { + super(b); + this.setHasSubtypes(true); + } + + @Override + public int getMetadata(int damage) { + return damage; + } +} diff --git a/src/main/java/atomicscience/hecheng/IBPlasma.java b/src/main/java/atomicscience/hecheng/IBPlasma.java new file mode 100644 index 0000000..1feb3cd --- /dev/null +++ b/src/main/java/atomicscience/hecheng/IBPlasma.java @@ -0,0 +1,16 @@ +package atomicscience.hecheng; + +import net.minecraft.block.Block; +import net.minecraft.item.ItemBlock; + +public class IBPlasma extends ItemBlock { + public IBPlasma(Block b) { + super(b); + this.setHasSubtypes(true); + } + + @Override + public int getMetadata(int damage) { + return damage; + } +} diff --git a/src/main/java/atomicscience/hecheng/IBSiren.java b/src/main/java/atomicscience/hecheng/IBSiren.java new file mode 100644 index 0000000..c95229f --- /dev/null +++ b/src/main/java/atomicscience/hecheng/IBSiren.java @@ -0,0 +1,16 @@ +package atomicscience.hecheng; + +import net.minecraft.block.Block; +import net.minecraft.item.ItemBlock; + +public class IBSiren extends ItemBlock { + public IBSiren(Block b) { + super(b); + this.setHasSubtypes(true); + } + + @Override + public int getMetadata(int damage) { + return damage; + } +} diff --git a/src/main/java/atomicscience/hecheng/TElectromagnet.java b/src/main/java/atomicscience/hecheng/TElectromagnet.java new file mode 100644 index 0000000..01debd4 --- /dev/null +++ b/src/main/java/atomicscience/hecheng/TElectromagnet.java @@ -0,0 +1,61 @@ +package atomicscience.hecheng; + +import atomicscience.AtomicScience; +import atomicscience.api.ITemperature; +import net.minecraft.block.Block; +import net.minecraft.init.Blocks; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraftforge.common.util.ForgeDirection; +import universalelectricity.core.vector.Vector3; +import universalelectricity.prefab.tile.TileEntityAdvanced; + +public class TElectromagnet extends TileEntityAdvanced implements ITemperature { + public static final int MAX_TEMP = 5000; + private float temperature = 0.0F; + + @Override + public void updateEntity() { + super.updateEntity(); + if(!this.worldObj.isRemote && this.temperature > 0.0F) { + if(this.temperature > 100.0F) { + for(int i = 0; i < 6; ++i) { + Vector3 offsetPos = new Vector3(this); + offsetPos.modifyPositionFromSide(ForgeDirection.getOrientation(i)); + Block blockID = this.worldObj.getBlock(offsetPos.intX(), offsetPos.intY(), offsetPos.intZ()); + if(blockID != Blocks.water && blockID != Blocks.flowing_water) { + if(blockID == Blocks.grass) { + offsetPos.setBlock(this.worldObj, AtomicScience.blockRadioactive); + } + } else if(super.ticks % (long)((int)Math.max(40.0F - this.temperature / 5000.0F * 40.0F, 2.0F)) == 0L) { + AtomicScience.boilWater(this.worldObj, offsetPos, 2, 20); + } + } + } + + this.temperature = Math.max(Math.min(this.temperature - 0.8F, 5000.0F), 0.0F); + } + + } + + @Override + public void readFromNBT(NBTTagCompound nbt) { + super.readFromNBT(nbt); + this.temperature = nbt.getFloat("temperature"); + } + + @Override + public void writeToNBT(NBTTagCompound par1NBTTagCompound) { + super.writeToNBT(par1NBTTagCompound); + par1NBTTagCompound.setFloat("temperature", this.temperature); + } + + @Override + public float getTemperature() { + return this.temperature; + } + + @Override + public void setTemperature(float celsius) { + this.temperature = celsius; + } +} diff --git a/src/main/java/atomicscience/hecheng/TFusionReactor.java b/src/main/java/atomicscience/hecheng/TFusionReactor.java new file mode 100644 index 0000000..8c03c4b --- /dev/null +++ b/src/main/java/atomicscience/hecheng/TFusionReactor.java @@ -0,0 +1,209 @@ +package atomicscience.hecheng; + +import atomicscience.AtomicScience; +import atomicscience.jiqi.TInventory; +import calclavia.lib.render.ITagRender; +import com.google.common.io.ByteArrayDataInput; +import java.util.HashMap; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.inventory.ISidedInventory; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.network.NetworkManager; +import net.minecraft.network.Packet; +import net.minecraft.network.play.server.S35PacketUpdateTileEntity; +import net.minecraftforge.common.util.ForgeDirection; +import universalelectricity.core.block.IElectricityStorage; +import universalelectricity.core.electricity.ElectricityPack; +import universalelectricity.core.vector.Vector3; + +public class TFusionReactor extends TInventory + implements ISidedInventory, IElectricityStorage, ITagRender { + + public static final int YAO_DAO = 1000; + public static final int YONG_DIAN = 20000; + private ItemStack deuteriumStack = null; + public float rotation = 0.0F; + + @Override + public ElectricityPack getRequest() { + return this.deuteriumStack != null + ? new ElectricityPack(20000.0D / this.getVoltage(), this.getVoltage()) + : new ElectricityPack(); + } + + @Override + public void updateEntity() { + super.updateEntity(); + if (!this.worldObj.isRemote) { + if (!this.isDisabled() && super.wattsReceived >= 20000.0D && + this.deuteriumStack != null && super.ticks % 20L == 0L) { + for (int i = 2; i < 6; ++i) { + Vector3 diDian = new Vector3(this); + diDian.modifyPositionFromSide(ForgeDirection.getOrientation(i), 2.0D); + AtomicScience.bPlasma.spawn(this.worldObj, diDian.intX(), + diDian.intY(), diDian.intZ(), + (byte) 7); + } + + this.setJoules(Math.max(super.wattsReceived - 20000.0D, 0.0D)); + if (this.worldObj.rand.nextInt(10) == 0) { + this.decrStackSize(0, 1); + } + } + + if (super.ticks % 80L == 0L) { + this.worldObj.markBlockForUpdate(this.xCoord, this.yCoord, this.zCoord); + } + } + } + + @Override + public Packet getDescriptionPacket() { + NBTTagCompound nbt = new NBTTagCompound(); + nbt.setDouble("wattsReceived", super.wattsReceived); + nbt.setInteger("stackSize", this.deuteriumStack != null + ? this.deuteriumStack.stackSize + : 0); + + return new S35PacketUpdateTileEntity(this.xCoord, this.yCoord, this.zCoord, + this.getBlockMetadata(), nbt); + } + + // @Override + // public void handlePacketData(INetworkManager network, int packetType, + // Packet250CustomPayload packet, + // EntityPlayer player, + // ByteArrayDataInput dataStream) { + // try { + // super.wattsReceived = dataStream.readDouble(); + // this.setInventorySlotContents( + // 0, new ItemStack(AtomicScience.itCellDao, + // dataStream.readInt())); + // } catch (Exception var7) { + // var7.printStackTrace(); + // } + // } + + @Override + public void onDataPacket(NetworkManager arg0, + S35PacketUpdateTileEntity arg1) { + NBTTagCompound nbt = arg1.func_148857_g(); + super.wattsReceived = nbt.getDouble("wattsReceived"); + this.setInventorySlotContents(0, + new ItemStack(AtomicScience.itCellDeuterium, + nbt.getInteger("stackSize"))); + } + + @Override + public void readFromNBT(NBTTagCompound nbt) { + super.readFromNBT(nbt); + super.wattsReceived = nbt.getDouble("wattsReceived"); + this.deuteriumStack = new ItemStack(AtomicScience.itCellDeuterium, + nbt.getInteger("stackSize")); + } + + @Override + public void writeToNBT(NBTTagCompound nbt) { + super.writeToNBT(nbt); + nbt.setDouble("wattsReceived", super.wattsReceived); + nbt.setInteger("stackSize", this.deuteriumStack != null + ? this.deuteriumStack.stackSize + : 0); + } + + @Override + public double getJoules() { + return super.wattsReceived; + } + + @Override + public void setJoules(double joules) { + super.wattsReceived = Math.max(Math.min(joules, this.getMaxJoules()), 0.0D); + } + + @Override + public double getMaxJoules() { + return 20000.0D; + } + + @Override + public int getSizeInventory() { + return 1; + } + + @Override + public ItemStack getStackInSlot(int var1) { + return this.deuteriumStack != null && this.deuteriumStack.stackSize <= 0 + ? null + : this.deuteriumStack; + } + + @Override + public ItemStack decrStackSize(int i, int amount) { + if (this.deuteriumStack != null) { + ItemStack itemstack; + if (this.deuteriumStack.stackSize <= amount) { + itemstack = this.deuteriumStack; + this.deuteriumStack = null; + return itemstack; + } else { + itemstack = this.deuteriumStack.splitStack(amount); + if (this.deuteriumStack.stackSize == 0) { + this.deuteriumStack = null; + } + + return itemstack; + } + } else { + return null; + } + } + + @Override + public ItemStack getStackInSlotOnClosing(int var1) { + return this.deuteriumStack; + } + + @Override + public void setInventorySlotContents(int i, ItemStack itemStack) { + this.deuteriumStack = itemStack; + } + + @Override + public int getInventoryStackLimit() { + return 1000; + } + + @Override + public float addInformation(HashMap map, EntityPlayer player) { + if (this.deuteriumStack != null) { + map.put("Deuterium: " + this.deuteriumStack.stackSize, + Integer.valueOf(16777215)); + } else { + map.put("No Deuterium", Integer.valueOf(16777215)); + } + + return 1.0F; + } + + @Override + public int[] getAccessibleSlotsFromSide(int var1) { + return new int[] { 0 }; + } + + @Override + public boolean isItemValidForSlot(int slotID, ItemStack itemStack) { + return itemStack.getItem() == AtomicScience.itCellDeuterium; + } + + @Override + public boolean canInsertItem(int i, ItemStack itemstack, int j) { + return this.isItemValidForSlot(i, itemstack); + } + + @Override + public boolean canExtractItem(int i, ItemStack itemstack, int j) { + return this.isItemValidForSlot(i, itemstack); + } +} diff --git a/src/main/java/atomicscience/jiqi/BBase.java b/src/main/java/atomicscience/jiqi/BBase.java new file mode 100644 index 0000000..155efd5 --- /dev/null +++ b/src/main/java/atomicscience/jiqi/BBase.java @@ -0,0 +1,40 @@ +package atomicscience.jiqi; + +import atomicscience.TabAS; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import net.minecraft.block.material.Material; +import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; +import universalelectricity.core.UniversalElectricity; +import universalelectricity.prefab.block.BlockAdvanced; + +public class BBase extends BlockAdvanced { + protected String textureName; + + public BBase(String name, Material material) { + super(material); + this.textureName = "atomicscience:machine"; + this.setBlockName("atomicscience:" + name); + this.setCreativeTab(TabAS.INSTANCE); + } + + public BBase(String name) { this(name, UniversalElectricity.machine); } + + @Override + @SideOnly(Side.CLIENT) + public void registerBlockIcons(IIconRegister iconRegister) { + if (this.getRenderType() == 0 && + this.textureName.equals("atomicscience:machine")) { + super.registerBlockIcons(iconRegister); + } else { + this.blockIcon = iconRegister.registerIcon(this.textureName); + } + } + + @Override + public TileEntity createNewTileEntity(World arg0, int arg1) { + return null; + } +} diff --git a/src/main/java/atomicscience/jiqi/BBaseRotatable.java b/src/main/java/atomicscience/jiqi/BBaseRotatable.java new file mode 100644 index 0000000..66eb5d3 --- /dev/null +++ b/src/main/java/atomicscience/jiqi/BBaseRotatable.java @@ -0,0 +1,35 @@ +package atomicscience.jiqi; + +import atomicscience.TabAS; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import net.minecraft.block.material.Material; +import net.minecraft.client.renderer.texture.IIconRegister; +import universalelectricity.core.UniversalElectricity; +import universalelectricity.prefab.block.BlockRotatable; + +public abstract class BBaseRotatable extends BlockRotatable { + protected String textureName; + + public BBaseRotatable(String name, Material material) { + super(material); + this.textureName = "atomicscience:machine"; + this.setBlockName("atomicscience:" + name); + this.setCreativeTab(TabAS.INSTANCE); + } + + public BBaseRotatable(String name) { + this(name, UniversalElectricity.machine); + } + + @Override + @SideOnly(Side.CLIENT) + public void registerBlockIcons(IIconRegister iconRegister) { + if(this.getRenderType() == 0) { + super.registerBlockIcons(iconRegister); + } else { + this.blockIcon = iconRegister.registerIcon(this.textureName); + } + + } +} diff --git a/src/main/java/atomicscience/jiqi/BChemicalExtractor.java b/src/main/java/atomicscience/jiqi/BChemicalExtractor.java new file mode 100644 index 0000000..b49f539 --- /dev/null +++ b/src/main/java/atomicscience/jiqi/BChemicalExtractor.java @@ -0,0 +1,49 @@ +package atomicscience.jiqi; + +import atomicscience.CommonProxy; +import atomicscience.AtomicScience; +import atomicscience.render.RH; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; + +public class BChemicalExtractor extends BBaseRotatable { + + public BChemicalExtractor() { + super("chemicalExtractor"); + } + + @Override + public boolean onMachineActivated(World par1World, int x, int y, int z, EntityPlayer par5EntityPlayer, int side, float hitX, float hitY, float hitZ) { + par1World.getBlockMetadata(x, y, z); + if(!par1World.isRemote) { + par5EntityPlayer.openGui(AtomicScience.instance, CommonProxy.GuiType.DAO_CHOU_QI.ordinal(), par1World, x, y, z); + return true; + } else { + return true; + } + } + + @Override + public TileEntity createNewTileEntity(World var1, int meta) { + return new TChemicalExtractor(); + } + + @Override + public boolean renderAsNormalBlock() { + return false; + } + + @Override + public boolean isOpaqueCube() { + return false; + } + + @Override + @SideOnly(Side.CLIENT) + public int getRenderType() { + return RH.BLOCK_RENDER_ID; + } +} diff --git a/src/main/java/atomicscience/jiqi/BFunnel.java b/src/main/java/atomicscience/jiqi/BFunnel.java new file mode 100644 index 0000000..85fc52b --- /dev/null +++ b/src/main/java/atomicscience/jiqi/BFunnel.java @@ -0,0 +1,44 @@ +package atomicscience.jiqi; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.IIcon; +import net.minecraft.world.World; + +public class BFunnel extends BBase { + private IIcon iconTop; + + public BFunnel() { + super("funnel"); + } + + @Override + public IIcon getIcon(int side, int metadata) { + return side != 1 && side != 0 ? this.blockIcon : this.iconTop; + } + + @Override + @SideOnly(Side.CLIENT) + public void registerBlockIcons(IIconRegister iconRegister) { + super.registerBlockIcons(iconRegister); + this.iconTop = iconRegister.registerIcon( + this.getUnlocalizedName().replace("tile.", "") + "_top"); + } + + @Override + public TileEntity createNewTileEntity(World var1, int meta) { + return new TFunnel(); + } + + @Override + public boolean renderAsNormalBlock() { + return false; + } + + @Override + public boolean isOpaqueCube() { + return false; + } +} diff --git a/src/main/java/atomicscience/jiqi/BThermometer.java b/src/main/java/atomicscience/jiqi/BThermometer.java new file mode 100644 index 0000000..99a0cd7 --- /dev/null +++ b/src/main/java/atomicscience/jiqi/BThermometer.java @@ -0,0 +1,111 @@ +package atomicscience.jiqi; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.ChatComponentText; +import net.minecraft.util.IIcon; +import net.minecraft.world.IBlockAccess; +import net.minecraft.world.World; +import universalelectricity.core.vector.Vector3; + +public class BThermometer extends BBase { + private IIcon iconSide; + + public BThermometer() { + super("thermometer"); + } + + @Override + public IIcon getIcon(int side, int metadata) { + return side != 1 && side != 0 ? this.iconSide : this.blockIcon; + } + + @Override + @SideOnly(Side.CLIENT) + public void registerBlockIcons(IIconRegister iconRegister) { + super.registerBlockIcons(iconRegister); + this.iconSide = iconRegister.registerIcon("atomicscience:machine"); + } + + @Override + public boolean onMachineActivated(World world, int x, int y, int z, + EntityPlayer entityPlayer, int side, + float hitX, float hitY, float hitZ) { + TThermometer tileEntity = (TThermometer) world.getTileEntity(x, y, z); + if (entityPlayer.getCurrentEquippedItem() != null && + entityPlayer.getCurrentEquippedItem().getItem() instanceof ItThermometer) { + Vector3 savedCoords = ((ItThermometer) entityPlayer.getCurrentEquippedItem().getItem()) + .getSavedCoord(entityPlayer.getCurrentEquippedItem()); + if (tileEntity.setLinkTile(savedCoords)) { + if (world.isRemote) { + entityPlayer.addChatMessage( + new ChatComponentText("Linked thermal data.")); + } + + return true; + } + } + + tileEntity.setWarningTemp(tileEntity.getWarningTemp() - 100); + return true; + } + + @Override + public boolean onSneakMachineActivated(World par1World, int x, int y, int z, + EntityPlayer par5EntityPlayer, + int side, float hitX, float hitY, + float hitZ) { + TThermometer tileEntity = (TThermometer) par1World.getTileEntity(x, y, z); + tileEntity.setWarningTemp(tileEntity.getWarningTemp() - 10); + return true; + } + + @Override + public boolean onUseWrench(World par1World, int x, int y, int z, + EntityPlayer par5EntityPlayer, int side, + float hitX, float hitY, float hitZ) { + TThermometer tileEntity = (TThermometer) par1World.getTileEntity(x, y, z); + tileEntity.setWarningTemp(tileEntity.getWarningTemp() + 100); + return true; + } + + @Override + public boolean onSneakUseWrench(World par1World, int x, int y, int z, + EntityPlayer par5EntityPlayer, int side, + float hitX, float hitY, float hitZ) { + TThermometer tileEntity = (TThermometer) par1World.getTileEntity(x, y, z); + tileEntity.setWarningTemp(tileEntity.getWarningTemp() + 10); + return true; + } + + @Override + public boolean canProvidePower() { + return true; + } + + @Override + public int isProvidingWeakPower(IBlockAccess par1IBlockAccess, int x, int y, int z, + int par5) { + return this.isProvidingStrongPower(par1IBlockAccess, x, y, z, par5); + } + + @Override + public int isProvidingStrongPower(IBlockAccess par1IBlockAccess, int x, int y, int z, + int par5) { + TThermometer tileEntity = (TThermometer) par1IBlockAccess.getTileEntity(x, y, z); + return tileEntity.shouldEmitRedstone() ? 15 : 0; + } + + @Override + public boolean renderAsNormalBlock() { + return false; + } + + @Override + public TileEntity createNewTileEntity(World var1, int meta) { + return new TThermometer(); + } +} diff --git a/src/main/java/atomicscience/jiqi/BTurbine.java b/src/main/java/atomicscience/jiqi/BTurbine.java new file mode 100644 index 0000000..b3f7df9 --- /dev/null +++ b/src/main/java/atomicscience/jiqi/BTurbine.java @@ -0,0 +1,60 @@ +package atomicscience.jiqi; + +import atomicscience.render.RH; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import net.minecraft.block.Block; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; + +public class BTurbine extends BBase { + + public BTurbine() { + super("turbine"); + } + + @Override + public boolean onUseWrench(World world, int x, int y, int z, EntityPlayer par5EntityPlayer, int side, float hitX, float hitY, float hitZ) { + TileEntity tileEntity = world.getTileEntity(x, y, z); + return tileEntity instanceof TTurbine?((TTurbine)tileEntity).checkMultiblock():false; + } + + @Override + public void breakBlock(World world, int x, int y, int z, Block par5, int par6) { + TileEntity tileEntity = world.getTileEntity(x, y, z); + if(tileEntity instanceof TTurbine) { + if(((TTurbine)tileEntity).isMultiblock) { + ((TTurbine)tileEntity).checkMultiblock(); + } else if(((TTurbine)tileEntity).masterTurbine != null) { + TileEntity t = ((TTurbine)tileEntity).masterTurbine.getTileEntity(world); + if(t instanceof TTurbine) { + ((TTurbine)t).setMaster((TTurbine)null); + } + } + } + + super.breakBlock(world, x, y, z, par5, par6); + } + + @Override + @SideOnly(Side.CLIENT) + public int getRenderType() { + return RH.BLOCK_RENDER_ID; + } + + @Override + public TileEntity createNewTileEntity(World var1, int meta) { + return new TTurbine(); + } + + @Override + public boolean renderAsNormalBlock() { + return false; + } + + @Override + public boolean isOpaqueCube() { + return false; + } +} diff --git a/src/main/java/atomicscience/jiqi/CAssembler.java b/src/main/java/atomicscience/jiqi/CAssembler.java new file mode 100644 index 0000000..174d2b8 --- /dev/null +++ b/src/main/java/atomicscience/jiqi/CAssembler.java @@ -0,0 +1,87 @@ +package atomicscience.jiqi; + +import atomicscience.AtomicScience; +import atomicscience.TAtomicAssembler; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.entity.player.InventoryPlayer; +import net.minecraft.inventory.Container; +import net.minecraft.inventory.Slot; +import net.minecraft.item.ItemStack; + +public class CAssembler extends Container { + private TAtomicAssembler tileEntity; + + public CAssembler(InventoryPlayer par1InventoryPlayer, + TAtomicAssembler tileEntity) { + this.tileEntity = tileEntity; + this.addSlotToContainer(new Slot(tileEntity, 0, 80, 40)); + this.addSlotToContainer(new Slot(tileEntity, 1, 53, 56)); + this.addSlotToContainer(new Slot(tileEntity, 2, 107, 56)); + this.addSlotToContainer(new Slot(tileEntity, 3, 53, 88)); + this.addSlotToContainer(new Slot(tileEntity, 4, 107, 88)); + this.addSlotToContainer(new Slot(tileEntity, 5, 80, 103)); + this.addSlotToContainer(new Slot(tileEntity, 6, 80, 72)); + + int var3; + for (var3 = 0; var3 < 3; ++var3) { + for (int var4 = 0; var4 < 9; ++var4) { + this.addSlotToContainer(new Slot(par1InventoryPlayer, + var4 + var3 * 9 + 9, 8 + var4 * 18, + 148 + var3 * 18)); + } + } + + for (var3 = 0; var3 < 9; ++var3) { + this.addSlotToContainer( + new Slot(par1InventoryPlayer, var3, 8 + var3 * 18, 206)); + } + + this.tileEntity.players.add(par1InventoryPlayer.player); + tileEntity.openInventory(); + } + + public void onContainerClosed(EntityPlayer entityplayer) { + super.onContainerClosed(entityplayer); + this.tileEntity.players.remove(entityplayer); + } + + public boolean canInteractWith(EntityPlayer par1EntityPlayer) { + return this.tileEntity.isUseableByPlayer(par1EntityPlayer); + } + + public ItemStack transferStackInSlot(EntityPlayer par1EntityPlayer, + int par1) { + ItemStack var2 = null; + Slot var3 = (Slot) super.inventorySlots.get(par1); + if (var3 != null && var3.getHasStack()) { + ItemStack itemStack = var3.getStack(); + var2 = itemStack.copy(); + if (par1 > 6) { + if (itemStack.getItem() == AtomicScience.itCellStrangeMatter) { + if (!this.mergeItemStack(itemStack, 0, 6, false)) { + return null; + } + } else if (!this.getSlot(6).getHasStack() && + !this.mergeItemStack(itemStack, 6, 7, false)) { + return null; + } + } else if (!this.mergeItemStack(itemStack, 7, 43, false)) { + return null; + } + + if (itemStack.stackSize == 0) { + var3.putStack((ItemStack) null); + } else { + var3.onSlotChanged(); + } + + if (itemStack.stackSize == var2.stackSize) { + return null; + } + + var3.onPickupFromSlot(par1EntityPlayer, itemStack); + } + + return var2; + } +} diff --git a/src/main/java/atomicscience/jiqi/ItHazmatSuite.java b/src/main/java/atomicscience/jiqi/ItHazmatSuite.java new file mode 100644 index 0000000..c99891c --- /dev/null +++ b/src/main/java/atomicscience/jiqi/ItHazmatSuite.java @@ -0,0 +1,45 @@ +package atomicscience.jiqi; + +import atomicscience.TabAS; +import atomicscience.api.IAntiPoisonArmor; +import atomicscience.api.poison.Poison; +import atomicscience.api.poison.PoisonRadiation; +import net.minecraft.entity.Entity; +import net.minecraft.entity.EntityLivingBase; +import net.minecraft.item.ItemArmor; +import net.minecraft.item.ItemStack; + +public class ItHazmatSuite extends ItemArmor implements IAntiPoisonArmor { + + public ItHazmatSuite(ArmorMaterial par2EnumArmorMaterial, int par3, + int par4) { + super(par2EnumArmorMaterial, par3, par4); + this.setCreativeTab(TabAS.INSTANCE); + this.setMaxDamage(200000); + } + + @Override + public String getArmorTexture(ItemStack stack, Entity entity, int slot, + String layer) { + return "/assets/atomicscience/textures/models/hazmat.png"; + } + + @Override + public boolean isProtectedFromPoison(ItemStack itemStack, + EntityLivingBase entityLiving, Poison type) { + return type == PoisonRadiation.INSTANCE || + type.getName().equalsIgnoreCase("chemical") || + type.getName().equalsIgnoreCase("contagious"); + } + + @Override + public void onProtectFromPoison(ItemStack itemStack, + EntityLivingBase entityLiving, Poison type) { + itemStack.damageItem(1, entityLiving); + } + + @Override + public Poison.ArmorType getArmorType() { + return Poison.ArmorType.values()[super.armorType]; + } +} diff --git a/src/main/java/atomicscience/jiqi/ItThermometer.java b/src/main/java/atomicscience/jiqi/ItThermometer.java new file mode 100644 index 0000000..a7ed39b --- /dev/null +++ b/src/main/java/atomicscience/jiqi/ItThermometer.java @@ -0,0 +1,98 @@ +package atomicscience.jiqi; + +import atomicscience.api.ITemperature; +import atomicscience.wujian.ItElectricAS; +import java.util.List; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.ChatComponentText; +import net.minecraft.world.World; +import universalelectricity.core.electricity.ElectricityPack; +import universalelectricity.core.vector.Vector3; + +public class ItThermometer extends ItElectricAS { + public static final int JOULES_CONSUMPTION = 1000; + + public ItThermometer(int texture) { + super("thermometer"); + } + + @Override + public void addInformation(ItemStack itemStack, EntityPlayer player, + List par3List, boolean par4) { + super.addInformation(itemStack, player, par3List, par4); + Vector3 coord = this.getSavedCoord(itemStack); + TileEntity tileEntity = coord.getTileEntity(player.worldObj); + if (tileEntity instanceof ITemperature) { + par3List.add("Tracking Thermal Device:"); + par3List.add("X: " + coord.intX() + ", Y: " + coord.intY() + + ", Z: " + coord.intZ()); + par3List.add(Math.round(((ITemperature) tileEntity).getTemperature()) + + " Celsius"); + } else { + par3List.add("§4Invalid Thermal Device."); + } + } + + public void setSavedCoords(ItemStack itemStack, Vector3 position) { + if (itemStack.stackTagCompound == null) { + itemStack.setTagCompound(new NBTTagCompound()); + } + + itemStack.stackTagCompound.setInteger("x", position.intX()); + itemStack.stackTagCompound.setInteger("y", position.intY()); + itemStack.stackTagCompound.setInteger("z", position.intZ()); + } + + public Vector3 getSavedCoord(ItemStack par1ItemStack) { + return par1ItemStack.stackTagCompound == null + ? new Vector3() + : new Vector3((double) par1ItemStack.stackTagCompound.getInteger("x"), + (double) par1ItemStack.stackTagCompound.getInteger("y"), + (double) par1ItemStack.stackTagCompound.getInteger("z")); + } + + @Override + public boolean onItemUse(ItemStack itemStack, EntityPlayer par2EntityPlayer, + World par3World, int x, int y, int z, int par7, + float par8, float par9, float par10) { + if (!par3World.isRemote) { + if (this.getJoules(itemStack) > 0.0D) { + TileEntity tileEntity = par3World.getTileEntity(x, y, z); + if (tileEntity instanceof ITemperature) { + if (par2EntityPlayer.isSneaking()) { + this.setSavedCoords(itemStack, new Vector3(tileEntity)); + par2EntityPlayer.addChatComponentMessage( + new ChatComponentText("Tracking Thermal Device.")); + } else { + par2EntityPlayer.addChatComponentMessage(new ChatComponentText( + "Heat: " + + Math.round(((ITemperature) tileEntity).getTemperature()) + + " C")); + } + + this.onProvide( + ElectricityPack.getFromWatts(1000.0D, this.getVoltage(itemStack)), + itemStack); + } + } else { + par2EntityPlayer.addChatComponentMessage( + new ChatComponentText("No Electricity!")); + } + } + + return false; + } + + @Override + public double getMaxJoules(ItemStack itemStack) { + return 50000.0D; + } + + @Override + public double getVoltage(ItemStack itemStack) { + return 20.0D; + } +} diff --git a/src/main/java/atomicscience/jiqi/TChemicalExtractor.java b/src/main/java/atomicscience/jiqi/TChemicalExtractor.java new file mode 100644 index 0000000..ab8e3a4 --- /dev/null +++ b/src/main/java/atomicscience/jiqi/TChemicalExtractor.java @@ -0,0 +1,245 @@ +package atomicscience.jiqi; + +import atomicscience.AtomicScience; +import net.minecraft.inventory.ISidedInventory; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.network.NetworkManager; +import net.minecraft.network.Packet; +import net.minecraft.network.play.server.S35PacketUpdateTileEntity; +import net.minecraftforge.common.util.ForgeDirection; +import net.minecraftforge.fluids.Fluid; +import net.minecraftforge.fluids.FluidContainerRegistry; +import net.minecraftforge.fluids.FluidRegistry; +import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.fluids.FluidTank; +import net.minecraftforge.fluids.FluidTankInfo; +import net.minecraftforge.fluids.IFluidHandler; +import universalelectricity.core.electricity.ElectricityPack; +import universalelectricity.core.item.ElectricItemHelper; +import universalelectricity.prefab.implement.IRotatable; + +public class TChemicalExtractor + extends TInventory implements ISidedInventory, IFluidHandler, IRotatable { + + public final int SMELTING_TICKS = 280; + // public final float DIAN = 500.0F; + public int smeltingTicks = 0; + public float rotation = 0.0F; + public final FluidTank waterTank; + private int playersUsing; + + public TChemicalExtractor() { + this.waterTank = new FluidTank(FluidRegistry.WATER, 0, 5000); + this.playersUsing = 0; + // TODO: WTF + // this.waterTank.setTankPressure(-10); + } + + @Override + public ElectricityPack getRequest() { + return this.canWork() + ? new ElectricityPack(500.0D / this.getVoltage(), this.getVoltage()) + : new ElectricityPack(); + } + + @Override + public void updateEntity() { + super.updateEntity(); + if (!this.worldObj.isRemote && !this.isDisabled()) { + if (super.containingItems[1] != null && + FluidContainerRegistry.isFilledContainer(super.containingItems[1])) { + FluidStack liquid = FluidContainerRegistry.getFluidForFilledItem( + super.containingItems[1]); + if (liquid.getFluid() == FluidRegistry.WATER && + this.fill(ForgeDirection.UNKNOWN, liquid, false) > 0) { + ItemStack resultingContainer = super.containingItems[1].getItem().getContainerItem( + super.containingItems[1]); + if (resultingContainer == null && + super.containingItems[1].stackSize > 1) { + --super.containingItems[1].stackSize; + } else { + super.containingItems[1] = resultingContainer; + } + + this.waterTank.fill(liquid, true); + } + } + + if (this.canWork()) { + super.wattsReceived += ElectricItemHelper.dechargeItem( + super.containingItems[0], 500.0D, this.getVoltage()); + double var10000 = super.wattsReceived; + this.getClass(); + if (var10000 >= (double) (500.0F / 2.0F)) { + if (this.smeltingTicks == 0) { + this.smeltingTicks = 280; + } + + if (this.smeltingTicks > 0) { + --this.smeltingTicks; + if (this.smeltingTicks < 1) { + this.work(); + this.smeltingTicks = 0; + } + } else { + this.smeltingTicks = 0; + } + + super.wattsReceived = 0.0D; + } + } else { + this.smeltingTicks = 0; + } + + if (super.ticks % 10L == 0L && this.playersUsing > 0) { + this.worldObj.markBlockForUpdate(this.xCoord, this.yCoord, this.zCoord); + } + } + } + + @Override + public void onDataPacket(NetworkManager arg0, + S35PacketUpdateTileEntity arg1) { + NBTTagCompound nbt = arg1.func_148857_g(); + + this.smeltingTicks = nbt.getInteger("smeltingTicks"); + this.waterTank.setFluid( + new FluidStack(FluidRegistry.WATER, nbt.getInteger("waterAmount"))); + super.disabledTicks = nbt.getInteger("disabledTicks"); + } + + @Override + public Packet getDescriptionPacket() { + NBTTagCompound nbt = new NBTTagCompound(); + nbt.setInteger("smeltingTicks", this.smeltingTicks); + nbt.setInteger("waterAmount", this.waterTank.getFluidAmount()); + nbt.setInteger("disabledTicks", super.disabledTicks); + + return new S35PacketUpdateTileEntity(this.xCoord, this.yCoord, this.zCoord, + this.getBlockMetadata(), nbt); + } + + @Override + public void openInventory() { + if (!this.worldObj.isRemote) { + this.worldObj.markBlockForUpdate(this.xCoord, this.yCoord, this.zCoord); + } + + ++this.playersUsing; + } + + @Override + public void closeInventory() { + --this.playersUsing; + } + + public boolean canWork() { + if (!this.isDisabled() && this.waterTank.getFluid() != null && + this.waterTank.getFluidAmount() >= 1000) { + if (AtomicScience.isUraniumOre(super.containingItems[3]) && + this.isItemValidForSlot( + 2, new ItemStack(AtomicScience.itYellowcake))) { + return true; + } + + if (AtomicScience.isCell(super.containingItems[3]) && + this.isItemValidForSlot( + 2, new ItemStack(AtomicScience.itCellDeuterium))) { + return true; + } + } + + return false; + } + + public void work() { + if (this.canWork()) { + this.waterTank.drain(1000, true); + if (AtomicScience.isUraniumOre(super.containingItems[3])) { + this.incrStackSize(2, new ItemStack(AtomicScience.itYellowcake, 3)); + } else { + this.incrStackSize(2, new ItemStack(AtomicScience.itCellDeuterium)); + } + + this.decrStackSize(3, 1); + } + } + + @Override + public void readFromNBT(NBTTagCompound nbt) { + super.readFromNBT(nbt); + this.smeltingTicks = nbt.getInteger("shiJian"); + NBTTagCompound compound = nbt.getCompoundTag("water"); + this.waterTank.setFluid(FluidStack.loadFluidStackFromNBT(compound)); + } + + @Override + public void writeToNBT(NBTTagCompound nbt) { + super.writeToNBT(nbt); + nbt.setInteger("shiJian", this.smeltingTicks); + if (this.waterTank.getFluid() != null) { + NBTTagCompound compound = new NBTTagCompound(); + this.waterTank.getFluid().writeToNBT(compound); + nbt.setTag("water", compound); + } + } + + @Override + public int fill(ForgeDirection from, FluidStack resource, boolean doFill) { + return FluidRegistry.WATER == resource.getFluid() + ? this.waterTank.fill(resource, doFill) + : 0; + } + + @Override + public FluidStack drain(ForgeDirection from, int maxDrain, boolean doDrain) { + return null; + } + + @Override + public FluidTankInfo[] getTankInfo(ForgeDirection arg0) { + return new FluidTankInfo[] { new FluidTankInfo(this.waterTank) }; + } + + @Override + public int getSizeInventory() { + return 4; + } + + public boolean isItemValidForSlot(int slotID, ItemStack itemStack) { + return slotID == 1 + ? AtomicScience.isCellWater(itemStack) + : (slotID != 3 ? false + : AtomicScience.isCell(itemStack) || + AtomicScience.isUraniumOre(itemStack)); + } + + public int[] getAccessibleSlotsFromSide(int side) { + return new int[] { 1, 2, 3 }; + } + + public boolean canInsertItem(int slotID, ItemStack itemStack, int side) { + return this.isItemValidForSlot(slotID, itemStack); + } + + public boolean canExtractItem(int slotID, ItemStack itemstack, int side) { + return slotID == 2; + } + + @Override + public boolean canDrain(ForgeDirection arg0, Fluid arg1) { + return false; + } + + @Override + public boolean canFill(ForgeDirection arg0, Fluid arg1) { + return arg1 == FluidRegistry.WATER && + this.waterTank.getFluidAmount() < this.waterTank.getCapacity(); + } + + @Override + public FluidStack drain(ForgeDirection arg0, FluidStack arg1, boolean arg2) { + return null; + } +} diff --git a/src/main/java/atomicscience/jiqi/TFunnel.java b/src/main/java/atomicscience/jiqi/TFunnel.java new file mode 100644 index 0000000..cadaa61 --- /dev/null +++ b/src/main/java/atomicscience/jiqi/TFunnel.java @@ -0,0 +1,102 @@ +package atomicscience.jiqi; + +import atomicscience.AtomicScience; +import atomicscience.api.ISteamReceptor; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.tileentity.TileEntity; +import net.minecraftforge.common.util.ForgeDirection; +import net.minecraftforge.fluids.Fluid; +import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.fluids.FluidTank; +import net.minecraftforge.fluids.FluidTankInfo; +import net.minecraftforge.fluids.IFluidHandler; +import universalelectricity.core.block.IConductor; +import universalelectricity.prefab.tile.TileEntityAdvanced; + +public class TFunnel + extends TileEntityAdvanced implements ISteamReceptor, IFluidHandler { + + public IConductor connectedWire = null; + public final FluidTank gasTank; + + public TFunnel() { + this.gasTank = new FluidTank(AtomicScience.FLUID_STEAM, 0, 20000); + + // TODO: WTF + // this.gasTank.setTankPressure(10); + } + + @Override + public void updateEntity() { + super.updateEntity(); + if (super.ticks % 20L == 0L) { + TileEntity tileEntity = this.worldObj.getTileEntity( + this.xCoord, this.yCoord + 1, this.zCoord); + if (tileEntity != null && tileEntity instanceof ISteamReceptor) { + FluidStack drainStack = this.gasTank.drain(AtomicScience.STEAM_RATIO, true); + if (drainStack != null) { + int nengLiang = drainStack.amount; + ((ISteamReceptor) tileEntity) + .onReceiveSteam(nengLiang - nengLiang / 4); + } + } + } + } + + @Override + public void readFromNBT(NBTTagCompound nbt) { + super.readFromNBT(nbt); + NBTTagCompound gasCompound = nbt.getCompoundTag("gas"); + this.gasTank.setFluid(FluidStack.loadFluidStackFromNBT(gasCompound)); + } + + @Override + public void writeToNBT(NBTTagCompound nbt) { + super.writeToNBT(nbt); + if (this.gasTank.getFluid() != null) { + NBTTagCompound compound = new NBTTagCompound(); + this.gasTank.getFluid().writeToNBT(compound); + nbt.setTag("gas", compound); + } + } + + @Override + public void onReceiveSteam(int amount) { + this.gasTank.fill(new FluidStack(AtomicScience.FLUID_STEAM, + amount * AtomicScience.STEAM_RATIO), + true); + } + + @Override + public int fill(ForgeDirection from, FluidStack resource, boolean doFill) { + return 0; + } + + @Override + public FluidStack drain(ForgeDirection from, int maxDrain, boolean doDrain) { + return this.gasTank.drain(maxDrain, doDrain); + } + + @Override + public boolean canDrain(ForgeDirection arg0, Fluid arg1) { + return arg1 == AtomicScience.FLUID_STEAM && + this.gasTank.getFluidAmount() > 0; + } + + @Override + public boolean canFill(ForgeDirection arg0, Fluid arg1) { + return false; + } + + @Override + public FluidStack drain(ForgeDirection arg0, FluidStack arg1, boolean arg2) { + return arg1.getFluid() == AtomicScience.FLUID_STEAM + ? this.gasTank.drain(arg1.amount, arg2) + : null; + } + + @Override + public FluidTankInfo[] getTankInfo(ForgeDirection arg0) { + return new FluidTankInfo[] { new FluidTankInfo(this.gasTank) }; + } +} diff --git a/src/main/java/atomicscience/jiqi/TInventory.java b/src/main/java/atomicscience/jiqi/TInventory.java new file mode 100644 index 0000000..eb63572 --- /dev/null +++ b/src/main/java/atomicscience/jiqi/TInventory.java @@ -0,0 +1,143 @@ +package atomicscience.jiqi; + +import calclavia.lib.TileEntityUniversalRunnable; +import java.util.HashSet; +import java.util.Set; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.inventory.IInventory; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.nbt.NBTTagList; + +public abstract class TInventory + extends TileEntityUniversalRunnable implements IInventory { + public final Set players = new HashSet<>(); + protected ItemStack[] containingItems = new ItemStack[this.getSizeInventory()]; + + @Override + public boolean isUseableByPlayer(EntityPlayer par1EntityPlayer) { + return this.worldObj.getTileEntity(this.xCoord, this.yCoord, this.zCoord) != this + ? false + : par1EntityPlayer.getDistanceSq((double) this.xCoord + 0.5D, + (double) this.yCoord + 0.5D, + (double) this.zCoord + 0.5D) <= 64.0D; + } + + @Override + public ItemStack getStackInSlot(int par1) { + return this.containingItems[par1]; + } + + @Override + public ItemStack decrStackSize(int par1, int par2) { + if (this.containingItems[par1] != null) { + ItemStack var3; + if (this.containingItems[par1].stackSize <= par2) { + var3 = this.containingItems[par1]; + this.containingItems[par1] = null; + return var3; + } else { + var3 = this.containingItems[par1].splitStack(par2); + if (this.containingItems[par1].stackSize == 0) { + this.containingItems[par1] = null; + } + + return var3; + } + } else { + return null; + } + } + + @Override + public ItemStack getStackInSlotOnClosing(int par1) { + if (this.containingItems[par1] != null) { + ItemStack var2 = this.containingItems[par1]; + this.containingItems[par1] = null; + return var2; + } else { + return null; + } + } + + @Override + public void setInventorySlotContents(int par1, ItemStack par2ItemStack) { + this.containingItems[par1] = par2ItemStack; + if (par2ItemStack != null && + par2ItemStack.stackSize > this.getInventoryStackLimit()) { + par2ItemStack.stackSize = this.getInventoryStackLimit(); + } + } + + @Override + public int getInventoryStackLimit() { + return 64; + } + + @Override + public void openInventory() { + } + + @Override + public void closeInventory() { + } + + @Override + public boolean hasCustomInventoryName() { + return true; + } + + @Override + public String getInventoryName() { + return this.getBlockType().getLocalizedName(); + } + + @Override + public boolean isItemValidForSlot(int slot, ItemStack itemStack) { + return this.getStackInSlot(slot) == null + ? true + : (this.getStackInSlot(slot).stackSize + 1 <= 64 + ? this.getStackInSlot(slot).isItemEqual(itemStack) + : false); + } + + public void incrStackSize(int slot, ItemStack itemStack) { + if (this.getStackInSlot(slot) == null) { + this.setInventorySlotContents(slot, itemStack.copy()); + } else if (this.getStackInSlot(slot).isItemEqual(itemStack)) { + ++this.getStackInSlot(slot).stackSize; + } + } + + @Override + public void readFromNBT(NBTTagCompound nbt) { + super.readFromNBT(nbt); + NBTTagList var2 = nbt.getTagList("Items", 10); + this.containingItems = new ItemStack[this.getSizeInventory()]; + + for (int var3 = 0; var3 < var2.tagCount(); ++var3) { + NBTTagCompound var4 = (NBTTagCompound) var2.getCompoundTagAt(var3); + byte var5 = var4.getByte("Slot"); + if (var5 >= 0 && var5 < this.containingItems.length) { + this.containingItems[var5] = ItemStack.loadItemStackFromNBT(var4); + } + } + } + + @Override + public void writeToNBT(NBTTagCompound nbt) { + super.writeToNBT(nbt); + NBTTagList var2 = new NBTTagList(); + + for (int var3 = 0; var3 < this.containingItems.length; ++var3) { + if (this.containingItems[var3] != null) { + NBTTagCompound var4 = new NBTTagCompound(); + var4.setByte("Slot", (byte) var3); + this.containingItems[var3].writeToNBT(var4); + var2.appendTag(var4); + } + } + + nbt.setTag("Items", var2); + } +} diff --git a/src/main/java/atomicscience/jiqi/TThermometer.java b/src/main/java/atomicscience/jiqi/TThermometer.java new file mode 100644 index 0000000..2eb0e82 --- /dev/null +++ b/src/main/java/atomicscience/jiqi/TThermometer.java @@ -0,0 +1,117 @@ +package atomicscience.jiqi; + +import atomicscience.AtomicScience; +import atomicscience.api.ITemperature; +import net.minecraft.block.Block; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.network.NetworkManager; +import net.minecraft.network.Packet; +import net.minecraft.network.play.server.S35PacketUpdateTileEntity; +import net.minecraft.tileentity.TileEntity; +import net.minecraftforge.common.util.ForgeDirection; +import universalelectricity.core.vector.Vector3; +import universalelectricity.prefab.tile.TileEntityDisableable; + +public class TThermometer extends TileEntityDisableable { + public static final int MAX_TEMP = 5000; + private int warningTemp = 2000; + private float prevTemp; + public float temp = 0.0F; + public Vector3 linkedTileCoords; + + public void updateEntity() { + super.updateEntity(); + if (!this.worldObj.isRemote) { + this.prevTemp = this.temp; + if (super.ticks % 10L == 0L) { + this.temp = 0.0F; + if (this.linkedTileCoords != null && + this.linkedTileCoords.getTileEntity(this.worldObj) instanceof ITemperature) { + this.temp = ((ITemperature) this.linkedTileCoords.getTileEntity(this.worldObj)) + .getTemperature(); + } else { + for (int i = 0; i < 6; ++i) { + Vector3 offsetPos = new Vector3(this); + offsetPos.modifyPositionFromSide(ForgeDirection.getOrientation(i)); + Block fangGe = offsetPos.getBlock(this.worldObj); + if (fangGe instanceof ITemperature) { + this.temp += ((ITemperature) fangGe).getTemperature(); + } else { + TileEntity tileEntity = offsetPos.getTileEntity(this.worldObj); + if (tileEntity != null && tileEntity instanceof ITemperature) { + this.temp += ((ITemperature) tileEntity).getTemperature(); + } + } + } + } + + this.worldObj.notifyBlocksOfNeighborChange( + this.xCoord, this.yCoord, this.zCoord, AtomicScience.bThermometer); + if (this.prevTemp != this.temp) { + this.worldObj.markBlockForUpdate(this.xCoord, this.yCoord, + this.zCoord); + } + } + } + } + + @Override + public Packet getDescriptionPacket() { + NBTTagCompound nbt = new NBTTagCompound(); + nbt.setFloat("temp", this.temp); + nbt.setInteger("warningTemp", this.warningTemp); + + return new S35PacketUpdateTileEntity(this.xCoord, this.yCoord, this.zCoord, + this.getBlockMetadata(), nbt); + } + + @Override + public void onDataPacket(NetworkManager arg0, + S35PacketUpdateTileEntity arg1) { + NBTTagCompound nbt = arg1.func_148857_g(); + this.temp = nbt.getFloat("temp"); + this.warningTemp = nbt.getInteger("warningTemp"); + } + + public boolean setLinkTile(Vector3 linkedTileCoords) { + TileEntity thermalTile = linkedTileCoords.getTileEntity(this.worldObj); + if (thermalTile instanceof ITemperature) { + this.linkedTileCoords = linkedTileCoords; + return true; + } else { + return false; + } + } + + public void readFromNBT(NBTTagCompound nbt) { + super.readFromNBT(nbt); + this.warningTemp = nbt.getInteger("warningTemp"); + this.linkedTileCoords = Vector3.readFromNBT(nbt.getCompoundTag("linkedTileCoords")); + } + + public void writeToNBT(NBTTagCompound nbt) { + super.writeToNBT(nbt); + nbt.setInteger("warningTemp", this.warningTemp); + if (this.linkedTileCoords != null) { + nbt.setTag("linkedTileCoords", + this.linkedTileCoords.writeToNBT(new NBTTagCompound())); + } + } + + public int getWarningTemp() { + return this.warningTemp; + } + + public void setWarningTemp(int warningTemp) { + this.warningTemp = warningTemp; + if (this.warningTemp <= 0) { + this.warningTemp = 5000; + } + + this.worldObj.markBlockForUpdate(this.xCoord, this.yCoord, this.zCoord); + } + + public boolean shouldEmitRedstone() { + return !this.isDisabled() && this.temp >= (float) this.getWarningTemp(); + } +} diff --git a/src/main/java/atomicscience/jiqi/TTurbine.java b/src/main/java/atomicscience/jiqi/TTurbine.java new file mode 100644 index 0000000..5d2bb74 --- /dev/null +++ b/src/main/java/atomicscience/jiqi/TTurbine.java @@ -0,0 +1,275 @@ +package atomicscience.jiqi; + +import atomicscience.AtomicScience; +import atomicscience.api.ISteamReceptor; +import calclavia.lib.TileEntityUniversalProducer; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import java.util.ArrayList; +import java.util.Iterator; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.network.NetworkManager; +import net.minecraft.network.Packet; +import net.minecraft.network.play.server.S35PacketUpdateTileEntity; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.AxisAlignedBB; +import net.minecraftforge.common.util.ForgeDirection; +import net.minecraftforge.fluids.Fluid; +import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.fluids.FluidTank; +import net.minecraftforge.fluids.FluidTankInfo; +import net.minecraftforge.fluids.IFluidHandler; +import universalelectricity.core.vector.Vector3; + +public class TTurbine extends TileEntityUniversalProducer + implements ISteamReceptor, IFluidHandler { + public float rotation = 0.0F; + public float speed = 0.0F; + public boolean isMultiblock = false; + public Vector3 masterTurbine = null; + public static final int BAN_JING = 1; + // private static final double MAX_XUAN_ZHUAN = 50.0D; + // private static final float ZHUAN_MAN = 0.5F; + public final FluidTank tank; + + public TTurbine() { + this.tank = new FluidTank(AtomicScience.FLUID_STEAM, 0, 20000); + } + + @Override + public boolean canConnect(ForgeDirection direction) { + return this.masterTurbine != null ? false : direction == ForgeDirection.UP; + } + + @Override + public void updateEntity() { + super.updateEntity(); + if (this.tank.getFluid() != null && + this.tank.getFluidAmount() > AtomicScience.STEAM_RATIO) { + this.onReceiveSteam(AtomicScience.STEAM_RATIO); + this.tank.drain(AtomicScience.STEAM_RATIO, true); + } + + if (this.masterTurbine != null) { + TileEntity tileEntity = this.masterTurbine.getTileEntity(this.worldObj); + if (tileEntity == null) { + this.masterTurbine = null; + } else if (!tileEntity.isInvalid() && tileEntity instanceof TTurbine) { + if (!((TTurbine)tileEntity).isMultiblock) { + this.masterTurbine = null; + } + } else { + this.masterTurbine = null; + } + } else { + if (this.speed > 0.0F && !this.isDisabled()) { + if (super.ticks % 18L == 0L) { + if (this.isMultiblock) { + this.worldObj.playSoundEffect( + (double)this.xCoord, (double)this.yCoord, (double)this.zCoord, + "atomicscience.turbine", 0.6F, + (float)(0.699999988079071D + + 0.2D * ((double)this.speed / 450.0D))); + } else { + this.worldObj.playSoundEffect( + (double)this.xCoord, (double)this.yCoord, (double)this.zCoord, + "atomicscience.turbine", 0.15F, + (float)(0.699999988079071D + + 0.2D * ((double)this.speed / 50.0D))); + } + } + + // If turbine doesn't spin, check packet handler + // Original packet handler added to rotation on packet received. + // - LordMZTE + if (this.isMultiblock) { + this.rotation += this.speed / 18.0F / 3.0F; + } else { + this.rotation += this.speed / 3.0F; + } + + if (!this.worldObj.isRemote && super.ticks % 3L == 0L) { + this.worldObj.markBlockForUpdate(this.xCoord, this.yCoord, + this.zCoord); + } + + if (this.rotation > 360.0F) { + this.rotation = 0.0F; + } + } + + this.produce( + (double)(this.speed * AtomicScience.WOLUN_MULTIPLIER_OUTPUT)); + if (this.isMultiblock) { + this.speed = (float)Math.max( + Math.min((double)(this.speed - 4.5F), 450.0D), 0.0D); + } else { + this.speed = + (float)Math.max(Math.min((double)(this.speed - 0.5F), 50.0D), 0.0D); + } + } + } + + public void onReceiveSteam(int amount) { + if (this.masterTurbine != null) { + TileEntity tileEntity = this.masterTurbine.getTileEntity(this.worldObj); + if (tileEntity != null && tileEntity instanceof TTurbine) { + ((TTurbine)tileEntity).onReceiveSteam(amount); + } + } else if (this.isMultiblock) { + this.speed = + (float)Math.min((double)(this.speed + (float)amount), 450.0D); + } else { + this.speed = (float)Math.min((double)(this.speed + (float)amount), 50.0D); + } + } + + @Override + public void onDataPacket(NetworkManager arg0, + S35PacketUpdateTileEntity arg1) { + NBTTagCompound nbt = arg1.func_148857_g(); + this.isMultiblock = nbt.getBoolean("isMultiblock"); + this.masterTurbine = Vector3.readFromNBT(new NBTTagCompound()); + this.speed = nbt.getFloat("speed"); + } + + @Override + public Packet getDescriptionPacket() { + NBTTagCompound nbt = new NBTTagCompound(); + nbt.setBoolean("isMultiblock", this.isMultiblock); + nbt.setTag("masterTurbine", + this.masterTurbine.writeToNBT(new NBTTagCompound())); + nbt.setFloat("speed", this.speed); + + return new S35PacketUpdateTileEntity(this.xCoord, this.yCoord, this.zCoord, + this.getBlockMetadata(), nbt); + } + + public void setMaster(TTurbine newMasterTurbine) { + if (newMasterTurbine != null) { + this.masterTurbine = new Vector3(newMasterTurbine); + } else { + this.masterTurbine = null; + this.isMultiblock = false; + } + + this.worldObj.notifyBlocksOfNeighborChange( + this.xCoord, this.yCoord, this.zCoord, this.getBlockType()); + if (!this.worldObj.isRemote) { + this.worldObj.markBlockForUpdate(this.xCoord, this.yCoord, this.zCoord); + } + } + + public boolean hasMaster() { return this.masterTurbine != null; } + + public boolean checkMultiblock() { + if (!this.worldObj.isRemote) { + ArrayList xiaoWoLun = new ArrayList<>(); + ArrayList lianJie = new ArrayList<>(); + + for (int i$ = -1; i$ <= 1; ++i$) { + for (int woLun = -1; woLun <= 1; ++woLun) { + TileEntity tileEntity = this.worldObj.getTileEntity( + this.xCoord + i$, this.yCoord, this.zCoord + woLun); + if (tileEntity != null && tileEntity instanceof TTurbine) { + if (!((TTurbine)tileEntity).hasMaster() && + !((TTurbine)tileEntity).isMultiblock) { + xiaoWoLun.add((TTurbine)tileEntity); + } + + lianJie.add((TTurbine)tileEntity); + } + } + } + + Iterator var6; + TTurbine var7; + if (this.isMultiblock) { + var6 = lianJie.iterator(); + + while (var6.hasNext()) { + var7 = (TTurbine)var6.next(); + if (var7 != this) { + var7.setMaster((TTurbine)null); + } + } + + this.isMultiblock = false; + } else if (xiaoWoLun.size() >= 9) { + var6 = xiaoWoLun.iterator(); + + while (var6.hasNext()) { + var7 = (TTurbine)var6.next(); + if (var7 != this) { + var7.setMaster(this); + } + } + + this.masterTurbine = null; + this.isMultiblock = true; + } + + if (!this.worldObj.isRemote) { + this.worldObj.markBlockForUpdate(this.xCoord, this.yCoord, this.zCoord); + } + } + + return true; + } + + public void readFromNBT(NBTTagCompound nbt) { + super.readFromNBT(nbt); + this.speed = nbt.getFloat("speed"); + this.isMultiblock = nbt.getBoolean("isMultiblock"); + if (nbt.hasKey("masterTurbine")) { + this.masterTurbine = + Vector3.readFromNBT(nbt.getCompoundTag("masterTurbine")); + } else { + this.masterTurbine = null; + } + } + + public void writeToNBT(NBTTagCompound nbt) { + super.writeToNBT(nbt); + nbt.setFloat("speed", this.speed); + nbt.setBoolean("isMultiblock", this.isMultiblock); + if (this.masterTurbine != null) { + nbt.setTag("masterTurbine", + this.masterTurbine.writeToNBT(new NBTTagCompound())); + } + } + + public int fill(ForgeDirection from, FluidStack resource, boolean doFill) { + return this.tank.fill(resource, doFill); + } + + public FluidStack drain(ForgeDirection from, int maxDrain, boolean doDrain) { + return null; + } + + @SideOnly(Side.CLIENT) + public AxisAlignedBB getRenderBoundingBox() { + return TileEntity.INFINITE_EXTENT_AABB; + } + + @Override + public boolean canDrain(ForgeDirection arg0, Fluid arg1) { + return false; + } + + @Override + public boolean canFill(ForgeDirection arg0, Fluid arg1) { + return arg1 == AtomicScience.FLUID_STEAM && + this.tank.getFluidAmount() < this.tank.getCapacity(); + } + + @Override + public FluidStack drain(ForgeDirection arg0, FluidStack arg1, boolean arg2) { + return null; + } + + @Override + public FluidTankInfo[] getTankInfo(ForgeDirection arg0) { + return new FluidTankInfo[] {new FluidTankInfo(this.tank)}; + } +} diff --git a/src/main/java/atomicscience/muoxing/MAtomicAssembler.java b/src/main/java/atomicscience/muoxing/MAtomicAssembler.java new file mode 100644 index 0000000..f2a5c55 --- /dev/null +++ b/src/main/java/atomicscience/muoxing/MAtomicAssembler.java @@ -0,0 +1,369 @@ +package atomicscience.muoxing; + +import net.minecraft.client.model.ModelBase; +import net.minecraft.client.model.ModelRenderer; +import org.lwjgl.opengl.GL11; + +public class MAtomicAssembler extends ModelBase { + ModelRenderer Safety_Glass_Front; + ModelRenderer Safety_Glass_Right; + ModelRenderer Safety_Glass_Back; + ModelRenderer Safety_Glass_Left; + ModelRenderer Safety_Glass_Top; + ModelRenderer Circuit1; + ModelRenderer Circuit2; + ModelRenderer Circuit3; + ModelRenderer Circuit4; + ModelRenderer RAM1; + ModelRenderer Control_Pad; + ModelRenderer RAM2; + ModelRenderer Control_Pad_Ribbon_Cable; + ModelRenderer RAM3; + ModelRenderer Control_Pad_Ribbon_Connector; + ModelRenderer RAM4; + ModelRenderer Plinth_Base_Ribbon_Connector; + ModelRenderer Material_Plinth_Core; + ModelRenderer Material_Plinth_Base; + ModelRenderer Material_Plinth_Stand; + ModelRenderer Plinth_Base_Plate; + ModelRenderer Back_Arm_Upper; + ModelRenderer Back_Arm_Lower; + ModelRenderer Right_Arm_Upper; + ModelRenderer Right_Arm_Lower; + ModelRenderer Front_Arm_Upper; + ModelRenderer Front_Arm_Lower; + ModelRenderer Left_Arm_Upper; + ModelRenderer Left_Arm_Lower; + ModelRenderer Middle_Rotor_Focus_Lazer; + ModelRenderer Middle_Rotor_Uppper_Arm; + ModelRenderer Middle_Rotor_Lower_Arm; + ModelRenderer Middle_Rotor_Arm_Base; + ModelRenderer Middle_Rotor; + ModelRenderer Bottom_Rotor_Upper_Arm; + ModelRenderer Bottom_Rotor_Lower_Arm; + ModelRenderer Bottom_Rotor_Arm_Base; + ModelRenderer Bottom_Rotor; + ModelRenderer Resonance_Crystal; + ModelRenderer Resonator_Unit; + ModelRenderer Resonator_Assembly; + ModelRenderer Bottom_Rotor_Resonator_Arm; + + + public MAtomicAssembler() { + super.textureWidth = 65; + super.textureHeight = 32; + this.Safety_Glass_Front = new ModelRenderer(this, 35, 0); + this.Safety_Glass_Front.addBox(0.0F, 0.0F, 0.0F, 15, 15, 0); + this.Safety_Glass_Front.setRotationPoint(-7.5F, 8.0F, -7.5F); + this.Safety_Glass_Front.setTextureSize(65, 32); + this.Safety_Glass_Front.mirror = true; + this.setRotation(this.Safety_Glass_Front, 0.0F, 0.0F, 0.0F); + this.Safety_Glass_Right = new ModelRenderer(this, 35, -15); + this.Safety_Glass_Right.addBox(0.0F, 0.0F, 0.0F, 0, 15, 15); + this.Safety_Glass_Right.setRotationPoint(-7.5F, 8.0F, -7.5F); + this.Safety_Glass_Right.setTextureSize(65, 32); + this.Safety_Glass_Right.mirror = true; + this.setRotation(this.Safety_Glass_Right, 0.0F, 0.0F, 0.0F); + this.Safety_Glass_Back = new ModelRenderer(this, 35, 0); + this.Safety_Glass_Back.addBox(0.0F, 0.0F, 0.0F, 15, 15, 0); + this.Safety_Glass_Back.setRotationPoint(-7.5F, 8.0F, 7.5F); + this.Safety_Glass_Back.setTextureSize(65, 32); + this.Safety_Glass_Back.mirror = true; + this.setRotation(this.Safety_Glass_Back, 0.0F, 0.0F, 0.0F); + this.Safety_Glass_Left = new ModelRenderer(this, 35, -15); + this.Safety_Glass_Left.addBox(0.0F, 0.0F, 0.0F, 0, 15, 15); + this.Safety_Glass_Left.setRotationPoint(7.5F, 8.0F, -7.5F); + this.Safety_Glass_Left.setTextureSize(65, 32); + this.Safety_Glass_Left.mirror = true; + this.setRotation(this.Safety_Glass_Left, 0.0F, 0.0F, 0.0F); + this.Safety_Glass_Top = new ModelRenderer(this, 20, 0); + this.Safety_Glass_Top.addBox(0.0F, 0.0F, 0.0F, 15, 0, 15); + this.Safety_Glass_Top.setRotationPoint(-7.5F, 8.0F, -7.5F); + this.Safety_Glass_Top.setTextureSize(65, 32); + this.Safety_Glass_Top.mirror = true; + this.setRotation(this.Safety_Glass_Top, 0.0F, 0.0F, 0.0F); + this.Circuit1 = new ModelRenderer(this, 27, 11); + this.Circuit1.addBox(0.0F, 0.0F, 0.0F, 2, 1, 2); + this.Circuit1.setRotationPoint(-6.0F, 22.5F, -6.25F); + this.Circuit1.setTextureSize(65, 32); + this.Circuit1.mirror = true; + this.setRotation(this.Circuit1, 0.0F, 0.0F, 0.0F); + this.Circuit2 = new ModelRenderer(this, 27, 11); + this.Circuit2.addBox(0.0F, 0.0F, 0.0F, 2, 1, 2); + this.Circuit2.setRotationPoint(-5.0F, 22.5F, -1.0F); + this.Circuit2.setTextureSize(65, 32); + this.Circuit2.mirror = true; + this.setRotation(this.Circuit2, 0.0F, 0.0F, 0.0F); + this.Circuit3 = new ModelRenderer(this, 27, 11); + this.Circuit3.addBox(0.0F, 0.0F, 0.0F, 2, 1, 2); + this.Circuit3.setRotationPoint(3.0F, 22.5F, 0.0F); + this.Circuit3.setTextureSize(65, 32); + this.Circuit3.mirror = true; + this.setRotation(this.Circuit3, 0.0F, 0.0F, 0.0F); + this.Circuit4 = new ModelRenderer(this, 27, 11); + this.Circuit4.addBox(0.0F, 0.0F, 0.0F, 2, 1, 2); + this.Circuit4.setRotationPoint(-1.0F, 22.5F, -6.0F); + this.Circuit4.setTextureSize(65, 32); + this.Circuit4.mirror = true; + this.setRotation(this.Circuit4, 0.0F, 0.0F, 0.0F); + this.RAM1 = new ModelRenderer(this, 27, 11); + this.RAM1.addBox(0.0F, 0.0F, 0.0F, 3, 1, 0); + this.RAM1.setRotationPoint(2.0F, 22.0F, 6.0F); + this.RAM1.setTextureSize(65, 32); + this.RAM1.mirror = true; + this.setRotation(this.RAM1, 0.0F, 1.570796F, 0.0F); + this.Control_Pad = new ModelRenderer(this, 50, 25); + this.Control_Pad.addBox(-3.0F, -1.5F, -1.0F, 4, 4, 1); + this.Control_Pad.setRotationPoint(-4.0F, 10.0F, -7.0F); + this.Control_Pad.setTextureSize(65, 32); + this.Control_Pad.mirror = true; + this.setRotation(this.Control_Pad, 0.0F, 0.0F, 0.0F); + this.RAM2 = new ModelRenderer(this, 27, 11); + this.RAM2.addBox(0.0F, 0.0F, 0.0F, 3, 1, 0); + this.RAM2.setRotationPoint(2.5F, 22.0F, 6.0F); + this.RAM2.setTextureSize(65, 32); + this.RAM2.mirror = true; + this.setRotation(this.RAM2, 0.0F, 1.570796F, 0.0F); + this.Control_Pad_Ribbon_Cable = new ModelRenderer(this, 61, 18); + this.Control_Pad_Ribbon_Cable.addBox(0.0F, 0.0F, 0.0F, 2, 12, 0); + this.Control_Pad_Ribbon_Cable.setRotationPoint(-6.0F, 11.0F, -6.7F); + this.Control_Pad_Ribbon_Cable.setTextureSize(65, 32); + this.Control_Pad_Ribbon_Cable.mirror = true; + this.setRotation(this.Control_Pad_Ribbon_Cable, 0.0F, 0.0F, 0.0F); + this.RAM3 = new ModelRenderer(this, 27, 11); + this.RAM3.addBox(0.0F, 0.0F, 0.0F, 3, 1, 0); + this.RAM3.setRotationPoint(1.5F, 22.0F, 6.0F); + this.RAM3.setTextureSize(65, 32); + this.RAM3.mirror = true; + this.setRotation(this.RAM3, 0.0F, 1.570796F, 0.0F); + this.Control_Pad_Ribbon_Connector = new ModelRenderer(this, 50, 16); + this.Control_Pad_Ribbon_Connector.addBox(0.0F, 0.0F, -0.5F, 3, 1, 1); + this.Control_Pad_Ribbon_Connector.setRotationPoint(-6.5F, 11.0F, -6.7F); + this.Control_Pad_Ribbon_Connector.setTextureSize(65, 32); + this.Control_Pad_Ribbon_Connector.mirror = true; + this.setRotation(this.Control_Pad_Ribbon_Connector, 0.0F, 0.0F, 0.0F); + this.RAM4 = new ModelRenderer(this, 27, 11); + this.RAM4.addBox(0.0F, 0.0F, 0.0F, 3, 1, 0); + this.RAM4.setRotationPoint(1.0F, 22.0F, 6.0F); + this.RAM4.setTextureSize(65, 32); + this.RAM4.mirror = true; + this.setRotation(this.RAM4, 0.0F, 1.570796F, 0.0F); + this.Plinth_Base_Ribbon_Connector = new ModelRenderer(this, 50, 16); + this.Plinth_Base_Ribbon_Connector.addBox(0.0F, 0.0F, -0.5F, 3, 1, 1); + this.Plinth_Base_Ribbon_Connector.setRotationPoint(-6.5F, 22.0F, -6.7F); + this.Plinth_Base_Ribbon_Connector.setTextureSize(65, 32); + this.Plinth_Base_Ribbon_Connector.mirror = true; + this.setRotation(this.Plinth_Base_Ribbon_Connector, 0.0F, 0.0F, 0.0F); + this.Material_Plinth_Core = new ModelRenderer(this, 5, 27); + this.Material_Plinth_Core.addBox(-1.0F, -1.5F, -1.0F, 2, 1, 2); + this.Material_Plinth_Core.setRotationPoint(0.0F, 18.4F, 0.0F); + this.Material_Plinth_Core.setTextureSize(65, 32); + this.Material_Plinth_Core.mirror = true; + this.setRotation(this.Material_Plinth_Core, 0.0F, 0.7853982F, 0.0F); + this.Material_Plinth_Base = new ModelRenderer(this, 4, 6); + this.Material_Plinth_Base.addBox(-1.5F, -1.0F, -1.5F, 3, 1, 3); + this.Material_Plinth_Base.setRotationPoint(0.0F, 18.4F, 0.0F); + this.Material_Plinth_Base.setTextureSize(65, 32); + this.Material_Plinth_Base.mirror = true; + this.setRotation(this.Material_Plinth_Base, 0.0F, 0.7853982F, 0.0F); + this.Material_Plinth_Stand = new ModelRenderer(this, 0, 9); + this.Material_Plinth_Stand.addBox(-0.5F, -9.0F, -0.5F, 1, 6, 1); + this.Material_Plinth_Stand.setRotationPoint(0.0F, 26.5F, 0.0F); + this.Material_Plinth_Stand.setTextureSize(65, 32); + this.Material_Plinth_Stand.mirror = true; + this.setRotation(this.Material_Plinth_Stand, 0.0F, 0.7853982F, 0.0F); + this.Plinth_Base_Plate = new ModelRenderer(this, 1, 15); + this.Plinth_Base_Plate.addBox(-8.0F, 0.0F, -8.0F, 16, 1, 16); + this.Plinth_Base_Plate.setRotationPoint(0.0F, 23.0F, 0.0F); + this.Plinth_Base_Plate.setTextureSize(65, 32); + this.Plinth_Base_Plate.mirror = true; + this.setRotation(this.Plinth_Base_Plate, 0.0F, 0.0F, 0.0F); + this.Back_Arm_Upper = new ModelRenderer(this, 30, 1); + this.Back_Arm_Upper.addBox(-0.5F, 0.0F, 0.0F, 1, 2, 1); + this.Back_Arm_Upper.setRotationPoint(0.0F, 16.9F, 2.5F); + this.Back_Arm_Upper.setTextureSize(65, 32); + this.Back_Arm_Upper.mirror = true; + this.setRotation(this.Back_Arm_Upper, 2.281837F, 3.141593F, 0.0F); + this.Back_Arm_Lower = new ModelRenderer(this, 30, 5); + this.Back_Arm_Lower.addBox(-0.5F, 0.0F, 0.0F, 1, 2, 1); + this.Back_Arm_Lower.setRotationPoint(0.0F, 17.4F, 1.0F); + this.Back_Arm_Lower.setTextureSize(65, 32); + this.Back_Arm_Lower.mirror = true; + this.setRotation(this.Back_Arm_Lower, -2.356194F, 3.141593F, 0.0F); + this.Right_Arm_Upper = new ModelRenderer(this, 30, 1); + this.Right_Arm_Upper.addBox(-0.5F, 0.0F, 0.0F, 1, 2, 1); + this.Right_Arm_Upper.setRotationPoint(-2.5F, 16.9F, 0.0F); + this.Right_Arm_Upper.setTextureSize(65, 32); + this.Right_Arm_Upper.mirror = true; + this.setRotation(this.Right_Arm_Upper, 2.281837F, 1.570796F, 0.0F); + this.Right_Arm_Lower = new ModelRenderer(this, 30, 5); + this.Right_Arm_Lower.addBox(-0.5F, 0.0F, 0.0F, 1, 2, 1); + this.Right_Arm_Lower.setRotationPoint(-1.0F, 17.4F, 0.0F); + this.Right_Arm_Lower.setTextureSize(65, 32); + this.Right_Arm_Lower.mirror = true; + this.setRotation(this.Right_Arm_Lower, -2.356194F, 1.570796F, 0.0F); + this.Front_Arm_Upper = new ModelRenderer(this, 30, 1); + this.Front_Arm_Upper.addBox(-0.5F, 0.0F, 0.0F, 1, 2, 1); + this.Front_Arm_Upper.setRotationPoint(0.0F, 16.9F, -2.5F); + this.Front_Arm_Upper.setTextureSize(65, 32); + this.Front_Arm_Upper.mirror = true; + this.setRotation(this.Front_Arm_Upper, 2.281837F, 0.0F, 0.0F); + this.Front_Arm_Lower = new ModelRenderer(this, 30, 5); + this.Front_Arm_Lower.addBox(-0.5F, 0.0F, 0.0F, 1, 2, 1); + this.Front_Arm_Lower.setRotationPoint(0.0F, 17.4F, -1.0F); + this.Front_Arm_Lower.setTextureSize(65, 32); + this.Front_Arm_Lower.mirror = true; + this.setRotation(this.Front_Arm_Lower, -2.356194F, 0.0F, 0.0F); + this.Left_Arm_Upper = new ModelRenderer(this, 30, 1); + this.Left_Arm_Upper.addBox(-0.5F, 0.0F, 0.0F, 1, 2, 1); + this.Left_Arm_Upper.setRotationPoint(2.5F, 16.9F, 0.0F); + this.Left_Arm_Upper.setTextureSize(65, 32); + this.Left_Arm_Upper.mirror = true; + this.setRotation(this.Left_Arm_Upper, 2.281837F, -1.570796F, 0.0F); + this.Left_Arm_Lower = new ModelRenderer(this, 30, 5); + this.Left_Arm_Lower.addBox(-0.5F, 0.0F, 0.0F, 1, 2, 1); + this.Left_Arm_Lower.setRotationPoint(1.0F, 17.4F, 0.0F); + this.Left_Arm_Lower.setTextureSize(65, 32); + this.Left_Arm_Lower.mirror = true; + this.setRotation(this.Left_Arm_Lower, -2.356194F, -1.570796F, 0.0F); + this.Middle_Rotor_Focus_Lazer = new ModelRenderer(this, 11, 18); + this.Middle_Rotor_Focus_Lazer.addBox(2.5F, -0.5F, -0.5F, 2, 1, 1); + this.Middle_Rotor_Focus_Lazer.setRotationPoint(0.0F, 14.8F, 0.0F); + this.Middle_Rotor_Focus_Lazer.setTextureSize(65, 32); + this.Middle_Rotor_Focus_Lazer.mirror = true; + this.setRotation(this.Middle_Rotor_Focus_Lazer, 0.0F, -0.7853982F, -0.3316126F); + this.Middle_Rotor_Uppper_Arm = new ModelRenderer(this, 50, 19); + this.Middle_Rotor_Uppper_Arm.addBox(0.8F, -4.0F, -0.5F, 3, 1, 1); + this.Middle_Rotor_Uppper_Arm.setRotationPoint(0.0F, 14.3F, 0.0F); + this.Middle_Rotor_Uppper_Arm.setTextureSize(65, 32); + this.Middle_Rotor_Uppper_Arm.mirror = true; + this.setRotation(this.Middle_Rotor_Uppper_Arm, 0.0F, -0.7853982F, 1.082104F); + this.Middle_Rotor_Lower_Arm = new ModelRenderer(this, 17, 7); + this.Middle_Rotor_Lower_Arm.addBox(-0.5F, -0.6F, 4.5F, 1, 5, 1); + this.Middle_Rotor_Lower_Arm.setRotationPoint(0.0F, 14.3F, 0.0F); + this.Middle_Rotor_Lower_Arm.setTextureSize(65, 32); + this.Middle_Rotor_Lower_Arm.mirror = true; + this.setRotation(this.Middle_Rotor_Lower_Arm, -0.3839724F, 0.7853982F, 0.0F); + this.Middle_Rotor_Arm_Base = new ModelRenderer(this, 11, 21); + this.Middle_Rotor_Arm_Base.addBox(1.5F, -0.5F, -0.5F, 2, 1, 1); + this.Middle_Rotor_Arm_Base.setRotationPoint(0.0F, 20.6F, 0.0F); + this.Middle_Rotor_Arm_Base.setTextureSize(65, 32); + this.Middle_Rotor_Arm_Base.mirror = true; + this.setRotation(this.Middle_Rotor_Arm_Base, 0.0F, -0.7853982F, 0.0F); + this.Middle_Rotor = new ModelRenderer(this, 4, 1); + this.Middle_Rotor.addBox(-1.5F, -0.5F, -1.5F, 3, 1, 3); + this.Middle_Rotor.setRotationPoint(0.0F, 20.6F, 0.0F); + this.Middle_Rotor.setTextureSize(65, 32); + this.Middle_Rotor.mirror = true; + this.setRotation(this.Middle_Rotor, 0.0F, 0.0F, 0.0F); + this.Bottom_Rotor_Upper_Arm = new ModelRenderer(this, 17, 6); + this.Bottom_Rotor_Upper_Arm.addBox(-0.5F, -6.2F, -4.1F, 1, 1, 8); + this.Bottom_Rotor_Upper_Arm.setRotationPoint(0.0F, 15.3F, 0.0F); + this.Bottom_Rotor_Upper_Arm.setTextureSize(65, 32); + this.Bottom_Rotor_Upper_Arm.mirror = true; + this.setRotation(this.Bottom_Rotor_Upper_Arm, -1.082104F, -0.7853982F, 0.0F); + this.Bottom_Rotor_Lower_Arm = new ModelRenderer(this, 0, 0); + this.Bottom_Rotor_Lower_Arm.addBox(-0.5F, -2.2F, 6.0F, 1, 7, 1); + this.Bottom_Rotor_Lower_Arm.setRotationPoint(0.0F, 15.3F, 0.0F); + this.Bottom_Rotor_Lower_Arm.setTextureSize(65, 32); + this.Bottom_Rotor_Lower_Arm.mirror = true; + this.setRotation(this.Bottom_Rotor_Lower_Arm, -0.3839724F, -0.7853982F, 0.0F); + this.Bottom_Rotor_Arm_Base = new ModelRenderer(this, 50, 22); + this.Bottom_Rotor_Arm_Base.addBox(1.0F, -0.5F, -0.5F, 4, 1, 1); + this.Bottom_Rotor_Arm_Base.setRotationPoint(0.0F, 21.9F, 0.0F); + this.Bottom_Rotor_Arm_Base.setTextureSize(65, 32); + this.Bottom_Rotor_Arm_Base.mirror = true; + this.setRotation(this.Bottom_Rotor_Arm_Base, 0.0F, -2.356194F, 0.0F); + this.Bottom_Rotor = new ModelRenderer(this, 4, 11); + this.Bottom_Rotor.addBox(-1.5F, -0.5F, -1.5F, 3, 1, 3); + this.Bottom_Rotor.setRotationPoint(0.0F, 21.9F, 0.0F); + this.Bottom_Rotor.setTextureSize(65, 32); + this.Bottom_Rotor.mirror = true; + this.setRotation(this.Bottom_Rotor, 0.0F, -1.570796F, 0.0F); + this.Resonance_Crystal = new ModelRenderer(this, 0, 27); + this.Resonance_Crystal.addBox(-0.5F, -0.5F, -0.5F, 1, 1, 1); + this.Resonance_Crystal.setRotationPoint(0.0F, 10.7F, 0.0F); + this.Resonance_Crystal.setTextureSize(65, 32); + this.Resonance_Crystal.mirror = true; + this.setRotation(this.Resonance_Crystal, 0.7853982F, 3.141593F, 0.6108652F); + this.Resonator_Unit = new ModelRenderer(this, 17, 1); + this.Resonator_Unit.addBox(-1.0F, -8.0F, -1.0F, 2, 2, 2); + this.Resonator_Unit.setRotationPoint(0.0F, 17.0F, 0.0F); + this.Resonator_Unit.setTextureSize(65, 32); + this.Resonator_Unit.mirror = true; + this.setRotation(this.Resonator_Unit, 0.0F, -2.356194F, 0.0F); + this.Resonator_Assembly = new ModelRenderer(this, 0, 21); + this.Resonator_Assembly.addBox(-1.5F, -8.9F, -1.5F, 3, 2, 3); + this.Resonator_Assembly.setRotationPoint(0.0F, 17.0F, 0.0F); + this.Resonator_Assembly.setTextureSize(65, 32); + this.Resonator_Assembly.mirror = true; + this.setRotation(this.Resonator_Assembly, 0.0F, -1.570796F, 0.0F); + this.Bottom_Rotor_Resonator_Arm = new ModelRenderer(this, 0, 17); + this.Bottom_Rotor_Resonator_Arm.addBox(1.5F, -10.6F, -1.0F, 3, 1, 2); + this.Bottom_Rotor_Resonator_Arm.setRotationPoint(0.0F, 19.0F, 0.0F); + this.Bottom_Rotor_Resonator_Arm.setTextureSize(65, 32); + this.Bottom_Rotor_Resonator_Arm.mirror = true; + this.setRotation(this.Bottom_Rotor_Resonator_Arm, 0.0F, -2.356194F, 0.0F); + } + + public void render(float rotationYaw, float rotationYaw2, float rotationYaw3, float f5) { + this.Safety_Glass_Front.render(f5); + this.Safety_Glass_Right.render(f5); + this.Safety_Glass_Back.render(f5); + this.Safety_Glass_Left.render(f5); + this.Safety_Glass_Top.render(f5); + this.Circuit1.render(f5); + this.Circuit2.render(f5); + this.Circuit3.render(f5); + this.Circuit4.render(f5); + this.RAM1.render(f5); + this.Control_Pad.render(f5); + this.RAM2.render(f5); + this.Control_Pad_Ribbon_Cable.render(f5); + this.RAM3.render(f5); + this.Control_Pad_Ribbon_Connector.render(f5); + this.RAM4.render(f5); + this.Plinth_Base_Ribbon_Connector.render(f5); + this.Material_Plinth_Core.render(f5); + this.Material_Plinth_Base.render(f5); + this.Material_Plinth_Stand.render(f5); + this.Plinth_Base_Plate.render(f5); + GL11.glPushMatrix(); + GL11.glRotatef(-rotationYaw, 0.0F, 1.0F, 0.0F); + this.Back_Arm_Upper.render(f5); + this.Back_Arm_Lower.render(f5); + this.Right_Arm_Upper.render(f5); + this.Right_Arm_Lower.render(f5); + this.Front_Arm_Upper.render(f5); + this.Front_Arm_Lower.render(f5); + this.Left_Arm_Upper.render(f5); + this.Left_Arm_Lower.render(f5); + GL11.glPopMatrix(); + GL11.glPushMatrix(); + GL11.glRotatef(rotationYaw2, 0.0F, 1.0F, 0.0F); + this.Middle_Rotor_Focus_Lazer.render(f5); + this.Middle_Rotor_Uppper_Arm.render(f5); + this.Middle_Rotor_Lower_Arm.render(f5); + this.Middle_Rotor_Arm_Base.render(f5); + this.Middle_Rotor.render(f5); + GL11.glPopMatrix(); + GL11.glPushMatrix(); + GL11.glRotatef(-rotationYaw3, 0.0F, 1.0F, 0.0F); + this.Bottom_Rotor_Upper_Arm.render(f5); + this.Bottom_Rotor_Lower_Arm.render(f5); + this.Bottom_Rotor_Arm_Base.render(f5); + this.Bottom_Rotor.render(f5); + this.Bottom_Rotor_Resonator_Arm.render(f5); + GL11.glPopMatrix(); + this.Resonance_Crystal.rotateAngleY = (float)Math.toRadians((double)rotationYaw); + this.Resonance_Crystal.render(f5); + this.Resonator_Unit.render(f5); + this.Resonator_Assembly.render(f5); + } + + private void setRotation(ModelRenderer model, float x, float y, float z) { + model.rotateAngleX = x; + model.rotateAngleY = y; + model.rotateAngleZ = z; + } +} diff --git a/src/main/java/atomicscience/muoxing/MCentrifuge.java b/src/main/java/atomicscience/muoxing/MCentrifuge.java new file mode 100644 index 0000000..64477c0 --- /dev/null +++ b/src/main/java/atomicscience/muoxing/MCentrifuge.java @@ -0,0 +1,132 @@ +package atomicscience.muoxing; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import net.minecraft.client.model.ModelBase; +import net.minecraft.client.model.ModelRenderer; + +@SideOnly(Side.CLIENT) +public class MCentrifuge extends ModelBase { + ModelRenderer A; + ModelRenderer B; + ModelRenderer C; + ModelRenderer D; + ModelRenderer E; + ModelRenderer F; + ModelRenderer G; + ModelRenderer H; + ModelRenderer I; + ModelRenderer JROT; + ModelRenderer KROT; + ModelRenderer LROT; + ModelRenderer MROT; + + public MCentrifuge() { + super.textureWidth = 128; + super.textureHeight = 128; + this.A = new ModelRenderer(this, 0, 0); + this.A.addBox(-8.0F, 0.0F, -8.0F, 16, 1, 16); + this.A.setRotationPoint(0.0F, 23.0F, 0.0F); + this.A.setTextureSize(64, 32); + this.A.mirror = true; + this.setRotation(this.A, 0.0F, 0.0F, 0.0F); + this.B = new ModelRenderer(this, 0, 19); + this.B.addBox(-6.0F, 0.0F, -6.0F, 12, 1, 12); + this.B.setRotationPoint(0.0F, 22.0F, 0.0F); + this.B.setTextureSize(64, 32); + this.B.mirror = true; + this.setRotation(this.B, 0.0F, 0.0F, 0.0F); + this.C = new ModelRenderer(this, 0, 43); + this.C.addBox(-1.0F, 0.0F, -1.0F, 2, 12, 2); + this.C.setRotationPoint(0.0F, 10.0F, 0.0F); + this.C.setTextureSize(64, 32); + this.C.mirror = true; + this.setRotation(this.C, 0.0F, 0.0F, 0.0F); + this.D = new ModelRenderer(this, 67, 0); + this.D.addBox(-4.0F, 0.0F, -4.0F, 8, 4, 8); + this.D.setRotationPoint(0.0F, 18.0F, 0.0F); + this.D.setTextureSize(64, 32); + this.D.mirror = true; + this.setRotation(this.D, 0.0F, 0.0F, 0.0F); + this.E = new ModelRenderer(this, 0, 34); + this.E.addBox(-1.0F, 0.0F, 4.0F, 2, 6, 1); + this.E.setRotationPoint(0.0F, 16.0F, 0.0F); + this.E.setTextureSize(64, 32); + this.E.mirror = true; + this.setRotation(this.E, 0.0F, 0.7853982F, 0.0F); + this.F = new ModelRenderer(this, 0, 34); + this.F.addBox(-1.0F, 0.0F, 4.0F, 2, 6, 1); + this.F.setRotationPoint(0.0F, 16.0F, 0.0F); + this.F.setTextureSize(64, 32); + this.F.mirror = true; + this.setRotation(this.F, 0.0F, -0.7853982F, 0.0F); + this.G = new ModelRenderer(this, 67, 13); + this.G.addBox(-4.0F, 0.0F, -8.0F, 8, 12, 4); + this.G.setRotationPoint(0.0F, 12.0F, 0.0F); + this.G.setTextureSize(64, 32); + this.G.mirror = true; + this.setRotation(this.G, 0.0F, 0.0F, 0.0F); + this.H = new ModelRenderer(this, 67, 31); + this.H.addBox(-4.0F, 0.0F, -4.0F, 8, 7, 2); + this.H.setRotationPoint(0.0F, 12.0F, 0.0F); + this.H.setTextureSize(64, 32); + this.H.mirror = true; + this.setRotation(this.H, -1.064651F, 0.0F, 0.0F); + this.I = new ModelRenderer(this, 9, 43); + this.I.addBox(-2.0F, -3.0F, -2.0F, 4, 2, 4); + this.I.setRotationPoint(0.0F, 12.0F, 0.0F); + this.I.setTextureSize(64, 32); + this.I.mirror = true; + this.setRotation(this.I, 0.0F, 0.0F, 0.0F); + this.JROT = new ModelRenderer(this, 8, 34); + this.JROT.addBox(1.0F, 0.0F, 1.0F, 1, 2, 1); + this.JROT.setRotationPoint(0.0F, 16.0F, 0.0F); + this.JROT.setTextureSize(64, 32); + this.JROT.mirror = true; + this.setRotation(this.JROT, 0.0F, 0.0F, 0.0F); + this.KROT = new ModelRenderer(this, 8, 34); + this.KROT.addBox(-2.0F, 0.0F, 1.0F, 1, 2, 1); + this.KROT.setRotationPoint(0.0F, 16.0F, 0.0F); + this.KROT.setTextureSize(64, 32); + this.KROT.mirror = true; + this.setRotation(this.KROT, 0.0F, 0.0F, 0.0F); + this.LROT = new ModelRenderer(this, 8, 34); + this.LROT.addBox(1.0F, 0.0F, -2.0F, 1, 2, 1); + this.LROT.setRotationPoint(0.0F, 16.0F, 0.0F); + this.LROT.setTextureSize(64, 32); + this.LROT.mirror = true; + this.setRotation(this.LROT, 0.0F, 0.0F, 0.0F); + this.MROT = new ModelRenderer(this, 8, 34); + this.MROT.addBox(-2.0F, 0.0F, -2.0F, 1, 2, 1); + this.MROT.setRotationPoint(0.0F, 16.0F, 0.0F); + this.MROT.setTextureSize(64, 32); + this.MROT.mirror = true; + this.setRotation(this.MROT, 0.0F, 0.0F, 0.0F); + } + + public void render(float xuanZhuan, float f5) { + this.A.render(f5); + this.B.render(f5); + this.C.render(f5); + this.D.render(f5); + this.E.render(f5); + this.F.render(f5); + this.G.render(f5); + this.H.render(f5); + this.I.render(f5); + this.JROT.rotateAngleY = xuanZhuan; + this.JROT.render(f5); + this.KROT.rotateAngleY = xuanZhuan; + this.KROT.render(f5); + this.LROT.rotateAngleY = xuanZhuan; + this.LROT.render(f5); + this.MROT.rotateAngleY = xuanZhuan; + this.MROT.render(f5); + } + + private void setRotation(ModelRenderer model, float x, float y, float z) { + model.rotateAngleX = x; + model.rotateAngleY = y; + model.rotateAngleZ = z; + } +} diff --git a/src/main/java/atomicscience/muoxing/MCube.java b/src/main/java/atomicscience/muoxing/MCube.java new file mode 100644 index 0000000..5cfef14 --- /dev/null +++ b/src/main/java/atomicscience/muoxing/MCube.java @@ -0,0 +1,24 @@ +package atomicscience.muoxing; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import net.minecraft.client.model.ModelBase; +import net.minecraft.client.model.ModelRenderer; + +@SideOnly(Side.CLIENT) +public class MCube extends ModelBase { + public static final MCube INSTNACE = new MCube(); + private ModelRenderer cube = new ModelRenderer(this, 0, 0); + + public MCube() { + byte size = 16; + this.cube.addBox((float)(-size / 2), (float)(-size / 2), (float)(-size / 2), size, size, size); + this.cube.setTextureSize(112, 70); + this.cube.mirror = true; + } + + public void render() { + float f = 0.0625F; + this.cube.render(f); + } +} diff --git a/src/main/java/atomicscience/muoxing/MExtractor.java b/src/main/java/atomicscience/muoxing/MExtractor.java new file mode 100644 index 0000000..cfcc16b --- /dev/null +++ b/src/main/java/atomicscience/muoxing/MExtractor.java @@ -0,0 +1,131 @@ +package atomicscience.muoxing; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import net.minecraft.client.model.ModelBase; +import net.minecraft.client.model.ModelRenderer; + +@SideOnly(Side.CLIENT) +public class MExtractor extends ModelBase { + ModelRenderer MAIN_BASE; + ModelRenderer CORNER_SUPPORT_1; + ModelRenderer CORNER_SUPPORT_2; + ModelRenderer CORNER_SUPPORT_3; + ModelRenderer CORNER_SUPPORT_4; + ModelRenderer SUPPORT_BEAM_1; + ModelRenderer SUPPORT_BEAM_2; + ModelRenderer MAIN_CHAMBER_ROTATES; + ModelRenderer MAGNET_1_ROTATES; + ModelRenderer MAGNET_2_ROTATES; + ModelRenderer ENERGY_PLUG; + ModelRenderer KEYBOARD_SUPPORT; + ModelRenderer KEYBOARD; + + public MExtractor() { + super.textureWidth = 128; + super.textureHeight = 128; + this.MAIN_BASE = new ModelRenderer(this, 0, 0); + this.MAIN_BASE.addBox(0.0F, 0.0F, 0.0F, 14, 1, 14); + this.MAIN_BASE.setRotationPoint(-7.0F, 23.0F, -7.0F); + this.MAIN_BASE.setTextureSize(128, 128); + this.MAIN_BASE.mirror = true; + this.setRotation(this.MAIN_BASE, 0.0F, 0.0F, 0.0F); + this.CORNER_SUPPORT_1 = new ModelRenderer(this, 0, 19); + this.CORNER_SUPPORT_1.addBox(0.0F, 0.0F, 0.0F, 2, 2, 2); + this.CORNER_SUPPORT_1.setRotationPoint(6.0F, 22.0F, -8.0F); + this.CORNER_SUPPORT_1.setTextureSize(128, 128); + this.CORNER_SUPPORT_1.mirror = true; + this.setRotation(this.CORNER_SUPPORT_1, 0.0F, 0.0F, 0.0F); + this.CORNER_SUPPORT_2 = new ModelRenderer(this, 0, 19); + this.CORNER_SUPPORT_2.addBox(0.0F, 0.0F, 0.0F, 2, 2, 2); + this.CORNER_SUPPORT_2.setRotationPoint(-8.0F, 22.0F, 6.0F); + this.CORNER_SUPPORT_2.setTextureSize(128, 128); + this.CORNER_SUPPORT_2.mirror = true; + this.setRotation(this.CORNER_SUPPORT_2, 0.0F, 0.0F, 0.0F); + this.CORNER_SUPPORT_3 = new ModelRenderer(this, 0, 19); + this.CORNER_SUPPORT_3.addBox(0.0F, 0.0F, 0.0F, 2, 2, 2); + this.CORNER_SUPPORT_3.setRotationPoint(-8.0F, 22.0F, -8.0F); + this.CORNER_SUPPORT_3.setTextureSize(128, 128); + this.CORNER_SUPPORT_3.mirror = true; + this.setRotation(this.CORNER_SUPPORT_3, 0.0F, 0.0F, 0.0F); + this.CORNER_SUPPORT_4 = new ModelRenderer(this, 0, 19); + this.CORNER_SUPPORT_4.addBox(0.0F, 0.0F, 0.0F, 2, 2, 2); + this.CORNER_SUPPORT_4.setRotationPoint(6.0F, 22.0F, 6.0F); + this.CORNER_SUPPORT_4.setTextureSize(128, 128); + this.CORNER_SUPPORT_4.mirror = true; + this.setRotation(this.CORNER_SUPPORT_4, 0.0F, 0.0F, 0.0F); + this.SUPPORT_BEAM_1 = new ModelRenderer(this, 10, 19); + this.SUPPORT_BEAM_1.addBox(0.0F, 0.0F, 0.0F, 2, 8, 1); + this.SUPPORT_BEAM_1.setRotationPoint(2.0F, 16.0F, -8.0F); + this.SUPPORT_BEAM_1.setTextureSize(128, 128); + this.SUPPORT_BEAM_1.mirror = true; + this.setRotation(this.SUPPORT_BEAM_1, 0.0F, 0.0F, 0.0F); + this.SUPPORT_BEAM_2 = new ModelRenderer(this, 10, 19); + this.SUPPORT_BEAM_2.addBox(0.0F, 0.0F, 0.0F, 2, 8, 1); + this.SUPPORT_BEAM_2.setRotationPoint(2.0F, 16.0F, 7.0F); + this.SUPPORT_BEAM_2.setTextureSize(128, 128); + this.SUPPORT_BEAM_2.mirror = true; + this.setRotation(this.SUPPORT_BEAM_2, 0.0F, 0.0F, 0.0F); + this.MAIN_CHAMBER_ROTATES = new ModelRenderer(this, 0, 29); + this.MAIN_CHAMBER_ROTATES.addBox(-2.0F, -2.0F, -7.0F, 4, 4, 14); + this.MAIN_CHAMBER_ROTATES.setRotationPoint(3.0F, 17.0F, 0.0F); + this.MAIN_CHAMBER_ROTATES.setTextureSize(128, 128); + this.MAIN_CHAMBER_ROTATES.mirror = true; + this.setRotation(this.MAIN_CHAMBER_ROTATES, 0.0F, 0.0F, 0.0F); + this.MAGNET_1_ROTATES = new ModelRenderer(this, 25, 19); + this.MAGNET_1_ROTATES.addBox(-3.0F, -3.0F, -2.0F, 6, 6, 4); + this.MAGNET_1_ROTATES.setRotationPoint(3.0F, 17.0F, 3.0F); + this.MAGNET_1_ROTATES.setTextureSize(128, 128); + this.MAGNET_1_ROTATES.mirror = true; + this.setRotation(this.MAGNET_1_ROTATES, 0.0F, 0.0F, 0.0F); + this.MAGNET_2_ROTATES = new ModelRenderer(this, 25, 19); + this.MAGNET_2_ROTATES.addBox(-3.0F, -3.0F, -2.0F, 6, 6, 4); + this.MAGNET_2_ROTATES.setRotationPoint(3.0F, 17.0F, -3.0F); + this.MAGNET_2_ROTATES.setTextureSize(128, 128); + this.MAGNET_2_ROTATES.mirror = true; + this.setRotation(this.MAGNET_2_ROTATES, 0.0F, 0.0F, 0.0F); + this.ENERGY_PLUG = new ModelRenderer(this, 58, 0); + this.ENERGY_PLUG.addBox(0.0F, 0.0F, 0.0F, 4, 12, 11); + this.ENERGY_PLUG.setRotationPoint(-6.0F, 12.0F, -3.0F); + this.ENERGY_PLUG.setTextureSize(128, 128); + this.ENERGY_PLUG.mirror = true; + this.setRotation(this.ENERGY_PLUG, 0.0F, 0.0F, 0.0F); + this.KEYBOARD_SUPPORT = new ModelRenderer(this, 0, 48); + this.KEYBOARD_SUPPORT.addBox(0.0F, 0.0F, 0.0F, 1, 12, 2); + this.KEYBOARD_SUPPORT.setRotationPoint(-6.0F, 11.0F, -6.0F); + this.KEYBOARD_SUPPORT.setTextureSize(128, 128); + this.KEYBOARD_SUPPORT.mirror = true; + this.setRotation(this.KEYBOARD_SUPPORT, 0.0F, 1.570796F, 0.0F); + this.KEYBOARD = new ModelRenderer(this, 7, 48); + this.KEYBOARD.addBox(0.0F, 0.0F, 0.0F, 4, 1, 12); + this.KEYBOARD.setRotationPoint(3.0F, 11.0F, -8.0F); + this.KEYBOARD.setTextureSize(128, 128); + this.KEYBOARD.mirror = true; + this.setRotation(this.KEYBOARD, 0.0F, -1.570796F, -0.5235988F); + } + + public void render(float rotation, float f5) { + this.MAIN_BASE.render(f5); + this.CORNER_SUPPORT_1.render(f5); + this.CORNER_SUPPORT_2.render(f5); + this.CORNER_SUPPORT_3.render(f5); + this.CORNER_SUPPORT_4.render(f5); + this.SUPPORT_BEAM_1.render(f5); + this.SUPPORT_BEAM_2.render(f5); + this.MAIN_CHAMBER_ROTATES.rotateAngleZ = rotation; + this.MAIN_CHAMBER_ROTATES.render(f5); + this.MAGNET_1_ROTATES.rotateAngleZ = rotation; + this.MAGNET_1_ROTATES.render(f5); + this.MAGNET_2_ROTATES.rotateAngleZ = rotation; + this.MAGNET_2_ROTATES.render(f5); + this.ENERGY_PLUG.render(f5); + this.KEYBOARD_SUPPORT.render(f5); + this.KEYBOARD.render(f5); + } + + private void setRotation(ModelRenderer model, float x, float y, float z) { + model.rotateAngleX = x; + model.rotateAngleY = y; + model.rotateAngleZ = z; + } +} diff --git a/src/main/java/atomicscience/muoxing/MFusionReactor.java b/src/main/java/atomicscience/muoxing/MFusionReactor.java new file mode 100644 index 0000000..434a238 --- /dev/null +++ b/src/main/java/atomicscience/muoxing/MFusionReactor.java @@ -0,0 +1,227 @@ +package atomicscience.muoxing; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import net.minecraft.client.model.ModelBase; +import net.minecraft.client.model.ModelRenderer; + +@SideOnly(Side.CLIENT) +public class MFusionReactor extends ModelBase { + ModelRenderer a; + ModelRenderer b; + ModelRenderer c; + ModelRenderer d; + ModelRenderer e; + ModelRenderer f; + ModelRenderer g; + ModelRenderer h; + ModelRenderer i; + ModelRenderer j; + ModelRenderer k; + ModelRenderer l; + ModelRenderer m; + ModelRenderer n; + ModelRenderer o; + ModelRenderer p; + ModelRenderer q; + ModelRenderer rrot; + ModelRenderer srot; + ModelRenderer t; + ModelRenderer u; + ModelRenderer v; + ModelRenderer w; + ModelRenderer x; + ModelRenderer y; + + + public MFusionReactor() { + super.textureWidth = 128; + super.textureHeight = 128; + this.a = new ModelRenderer(this, 0, 0); + this.a.addBox(-8.0F, 0.0F, -8.0F, 16, 1, 16); + this.a.setRotationPoint(0.0F, 23.0F, 0.0F); + this.a.setTextureSize(128, 128); + this.a.mirror = true; + this.setRotation(this.a, 0.0F, 0.0F, 0.0F); + this.b = new ModelRenderer(this, 0, 66); + this.b.addBox(-4.0F, 0.0F, -1.0F, 8, 13, 2); + this.b.setRotationPoint(0.0F, 10.0F, 7.0F); + this.b.setTextureSize(128, 128); + this.b.mirror = true; + this.setRotation(this.b, 0.0F, 0.0F, 0.0F); + this.c = new ModelRenderer(this, 22, 82); + this.c.addBox(-4.0F, 0.0F, -2.0F, 8, 2, 2); + this.c.setRotationPoint(0.0F, 8.0F, 6.0F); + this.c.setTextureSize(128, 128); + this.c.mirror = true; + this.setRotation(this.c, 0.0F, 0.0F, 0.0F); + this.d = new ModelRenderer(this, 22, 66); + this.d.addBox(0.0F, 0.0F, 0.0F, 8, 5, 2); + this.d.setRotationPoint(-4.0F, 10.0F, 4.0F); + this.d.setTextureSize(128, 128); + this.d.mirror = true; + this.setRotation(this.d, 0.418879F, 0.0F, 0.0F); + this.e = new ModelRenderer(this, 0, 42); + this.e.addBox(0.0F, 0.0F, 0.0F, 2, 13, 6); + this.e.setRotationPoint(6.0F, 10.0F, -2.0F); + this.e.setTextureSize(128, 128); + this.e.mirror = true; + this.setRotation(this.e, 0.0F, 0.0F, 0.0F); + this.f = new ModelRenderer(this, 65, 43); + this.f.addBox(-1.0F, -1.0F, -3.0F, 2, 2, 6); + this.f.setRotationPoint(6.0F, 10.0F, 1.0F); + this.f.setTextureSize(128, 128); + this.f.mirror = true; + this.setRotation(this.f, 0.0F, 0.0F, 0.7853982F); + this.g = new ModelRenderer(this, 17, 42); + this.g.addBox(0.0F, 0.0F, 0.0F, 2, 5, 6); + this.g.setRotationPoint(4.0F, 10.0F, -2.0F); + this.g.setTextureSize(128, 128); + this.g.mirror = true; + this.setRotation(this.g, 0.0F, 0.0F, -0.4014257F); + this.h = new ModelRenderer(this, 0, 18); + this.h.addBox(0.0F, 0.0F, 0.0F, 2, 13, 6); + this.h.setRotationPoint(-8.0F, 10.0F, -2.0F); + this.h.setTextureSize(128, 128); + this.h.mirror = true; + this.setRotation(this.h, 0.0F, 0.0F, 0.0F); + this.i = new ModelRenderer(this, 0, 103); + this.i.addBox(0.0F, 0.0F, 0.0F, 12, 2, 6); + this.i.setRotationPoint(-6.0F, 8.0F, -2.0F); + this.i.setTextureSize(128, 128); + this.i.mirror = true; + this.setRotation(this.i, 0.0F, 0.0F, 0.0F); + this.j = new ModelRenderer(this, 17, 18); + this.j.addBox(-2.0F, 0.0F, 0.0F, 2, 5, 6); + this.j.setRotationPoint(-4.0F, 10.0F, -2.0F); + this.j.setTextureSize(128, 128); + this.j.mirror = true; + this.setRotation(this.j, 0.0F, 0.0F, 0.418879F); + this.k = new ModelRenderer(this, 0, 83); + this.k.addBox(-3.0F, 0.0F, -2.0F, 6, 15, 3); + this.k.setRotationPoint(5.0F, 8.0F, 5.0F); + this.k.setTextureSize(128, 128); + this.k.mirror = true; + this.setRotation(this.k, 0.0F, 0.7853982F, 0.0F); + this.l = new ModelRenderer(this, 0, 83); + this.l.addBox(-3.0F, 0.0F, -2.0F, 6, 15, 3); + this.l.setRotationPoint(-5.0F, 8.0F, 5.0F); + this.l.setTextureSize(128, 128); + this.l.mirror = true; + this.setRotation(this.l, 0.0F, -0.7853982F, 0.0F); + this.m = new ModelRenderer(this, 65, 43); + this.m.addBox(-1.0F, -1.0F, -3.0F, 2, 2, 6); + this.m.setRotationPoint(-6.0F, 10.0F, 1.0F); + this.m.setTextureSize(128, 128); + this.m.mirror = true; + this.setRotation(this.m, 0.0F, 0.0F, 0.7853982F); + this.n = new ModelRenderer(this, 65, 38); + this.n.addBox(-4.0F, -1.0F, -1.0F, 8, 2, 2); + this.n.setRotationPoint(0.0F, 10.0F, 6.0F); + this.n.setTextureSize(128, 128); + this.n.mirror = true; + this.setRotation(this.n, 0.7853982F, 0.0F, 0.0F); + this.o = new ModelRenderer(this, 17, 54); + this.o.addBox(0.0F, 0.0F, 0.0F, 1, 4, 6); + this.o.setRotationPoint(6.0F, 20.0F, -2.0F); + this.o.setTextureSize(128, 128); + this.o.mirror = true; + this.setRotation(this.o, 0.0F, 0.0F, 0.7330383F); + this.p = new ModelRenderer(this, 17, 30); + this.p.addBox(-1.0F, 0.0F, 0.0F, 1, 4, 6); + this.p.setRotationPoint(-6.0F, 20.0F, -2.0F); + this.p.setTextureSize(128, 128); + this.p.mirror = true; + this.setRotation(this.p, 0.0F, 0.0F, -0.7330383F); + this.q = new ModelRenderer(this, 22, 74); + this.q.addBox(0.0F, 0.0F, -1.0F, 8, 6, 1); + this.q.setRotationPoint(-4.0F, 19.0F, 7.0F); + this.q.setTextureSize(128, 128); + this.q.mirror = true; + this.setRotation(this.q, -0.6283185F, 0.0F, 0.0F); + this.rrot = new ModelRenderer(this, 65, 0); + this.rrot.addBox(-1.0F, 0.0F, -1.0F, 2, 13, 2); + this.rrot.setRotationPoint(0.0F, 10.0F, 0.0F); + this.rrot.setTextureSize(128, 128); + this.rrot.mirror = true; + this.setRotation(this.rrot, 0.0F, 0.0F, 0.0F); + this.srot = new ModelRenderer(this, 74, 0); + this.srot.addBox(-2.0F, 0.0F, -2.0F, 4, 9, 4); + this.srot.setRotationPoint(0.0F, 12.0F, 0.0F); + this.srot.setTextureSize(128, 128); + this.srot.mirror = true; + this.setRotation(this.srot, 0.0F, 0.0F, 0.0F); + this.t = new ModelRenderer(this, 65, 19); + this.t.addBox(-8.0F, 0.0F, 0.0F, 16, 2, 1); + this.t.setRotationPoint(0.0F, 21.0F, -3.0F); + this.t.setTextureSize(128, 128); + this.t.mirror = true; + this.setRotation(this.t, 0.0F, 0.0F, 0.0F); + this.u = new ModelRenderer(this, 65, 24); + this.u.addBox(-1.0F, 0.0F, -1.0F, 2, 10, 2); + this.u.setRotationPoint(4.0F, 13.0F, -6.0F); + this.u.setTextureSize(128, 128); + this.u.mirror = true; + this.setRotation(this.u, 0.0F, 0.0F, 0.0F); + this.v = new ModelRenderer(this, 74, 24); + this.v.addBox(-3.0F, -1.0F, -2.0F, 6, 2, 4); + this.v.setRotationPoint(4.0F, 13.0F, -6.0F); + this.v.setTextureSize(128, 128); + this.v.mirror = true; + this.setRotation(this.v, 0.7679449F, 0.0F, 0.0F); + this.w = new ModelRenderer(this, 46, 24); + this.w.addBox(0.0F, 0.0F, 0.0F, 5, 8, 4); + this.w.setRotationPoint(-7.0F, 15.0F, -7.0F); + this.w.setTextureSize(128, 128); + this.w.mirror = true; + this.setRotation(this.w, 0.0F, 0.0F, 0.0F); + this.x = new ModelRenderer(this, 46, 38); + this.x.addBox(0.0F, 0.0F, 0.0F, 5, 2, 3); + this.x.setRotationPoint(-7.0F, 15.0F, -7.0F); + this.x.setTextureSize(128, 128); + this.x.mirror = true; + this.setRotation(this.x, 0.7853982F, 0.0F, 0.0F); + this.y = new ModelRenderer(this, 46, 45); + this.y.addBox(0.0F, 0.0F, 0.0F, 5, 2, 2); + this.y.setRotationPoint(-7.0F, 13.0F, -5.0F); + this.y.setTextureSize(128, 128); + this.y.mirror = true; + this.setRotation(this.y, 0.0F, 0.0F, 0.0F); + } + + public void render(float xuanZhuan, float f5) { + this.a.render(f5); + this.b.render(f5); + this.c.render(f5); + this.d.render(f5); + this.e.render(f5); + this.x.render(f5); + this.g.render(f5); + this.h.render(f5); + this.i.render(f5); + this.j.render(f5); + this.k.render(f5); + this.l.render(f5); + this.m.render(f5); + this.n.render(f5); + this.o.render(f5); + this.p.render(f5); + this.q.render(f5); + this.rrot.rotateAngleY = xuanZhuan; + this.rrot.render(f5); + this.srot.rotateAngleY = xuanZhuan; + this.srot.render(f5); + this.t.render(f5); + this.u.render(f5); + this.v.render(f5); + this.w.render(f5); + this.x.render(f5); + this.y.render(f5); + } + + private void setRotation(ModelRenderer model, float x, float y, float z) { + model.rotateAngleX = x; + model.rotateAngleY = y; + model.rotateAngleZ = z; + } +} diff --git a/src/main/java/atomicscience/muoxing/MLargeTurbine.java b/src/main/java/atomicscience/muoxing/MLargeTurbine.java new file mode 100644 index 0000000..4f3921d --- /dev/null +++ b/src/main/java/atomicscience/muoxing/MLargeTurbine.java @@ -0,0 +1,408 @@ +package atomicscience.muoxing; + +import net.minecraft.client.model.ModelBase; +import net.minecraft.client.model.ModelRenderer; +import org.lwjgl.opengl.GL11; + +public class MLargeTurbine extends ModelBase { + ModelRenderer Centeraxle; + ModelRenderer wall1; + ModelRenderer wall2; + ModelRenderer wall6; + ModelRenderer wall5; + ModelRenderer wall3; + ModelRenderer wall4; + ModelRenderer wallunder1; + ModelRenderer wallunder3; + ModelRenderer wallunder2; + ModelRenderer wallunder6; + ModelRenderer wallunder5; + ModelRenderer wallunder4; + ModelRenderer Blade1; + ModelRenderer Blade2; + ModelRenderer Blade3; + ModelRenderer Blade4; + ModelRenderer Blade5; + ModelRenderer Blade6; + ModelRenderer LargeBlade1; + ModelRenderer LargeBlade2; + ModelRenderer LargeBlade3; + ModelRenderer LargeBlade4; + ModelRenderer LargeBlade5; + ModelRenderer LargeBlade6; + ModelRenderer MediumBlade1; + ModelRenderer MediumBlade2; + ModelRenderer MediumBlade3; + ModelRenderer MediumBlade4; + ModelRenderer MediumBlade5; + ModelRenderer MediumBlade6; + ModelRenderer Support1; + ModelRenderer support2; + ModelRenderer support3; + ModelRenderer cornerbottom1; + ModelRenderer corner1; + ModelRenderer corner2; + ModelRenderer cornerbottom2; + ModelRenderer corner6; + ModelRenderer cornerbottom6; + ModelRenderer corner5; + ModelRenderer cornerbottom5; + ModelRenderer corner4; + ModelRenderer cornerbottom4; + ModelRenderer corner3; + ModelRenderer cornerbottom3; + ModelRenderer Topelectricityoutput; + + + public MLargeTurbine() { + super.textureWidth = 128; + super.textureHeight = 128; + this.Centeraxle = new ModelRenderer(this, 24, 0); + this.Centeraxle.addBox(-1.0F, 0.0F, -1.0F, 2, 16, 2); + this.Centeraxle.setRotationPoint(0.0F, 8.0F, 0.0F); + this.Centeraxle.setTextureSize(128, 128); + this.Centeraxle.mirror = true; + this.setRotation(this.Centeraxle, 0.0F, 0.0F, 0.0F); + this.wall1 = new ModelRenderer(this, 0, 92); + this.wall1.addBox(-12.0F, 0.0F, 20.0F, 24, 12, 1); + this.wall1.setRotationPoint(0.0F, 14.0F, 0.0F); + this.wall1.setTextureSize(128, 128); + this.wall1.mirror = true; + this.setRotation(this.wall1, 0.2094395F, 0.0F, 0.0F); + this.wall2 = new ModelRenderer(this, 0, 92); + this.wall2.addBox(-12.0F, 0.0F, 20.0F, 24, 12, 1); + this.wall2.setRotationPoint(0.0F, 14.0F, 0.0F); + this.wall2.setTextureSize(128, 128); + this.wall2.mirror = true; + this.setRotation(this.wall2, 0.2094395F, 1.047198F, 0.0F); + this.wall6 = new ModelRenderer(this, 0, 92); + this.wall6.addBox(-12.0F, 0.0F, 20.0F, 24, 12, 1); + this.wall6.setRotationPoint(0.0F, 14.0F, 0.0F); + this.wall6.setTextureSize(128, 128); + this.wall6.mirror = true; + this.setRotation(this.wall6, 0.2094395F, -1.047198F, 0.0F); + this.wall5 = new ModelRenderer(this, 0, 92); + this.wall5.addBox(-12.0F, 0.0F, 20.0F, 24, 12, 1); + this.wall5.setRotationPoint(0.0F, 14.0F, 0.0F); + this.wall5.setTextureSize(128, 128); + this.wall5.mirror = true; + this.setRotation(this.wall5, 0.2094395F, -2.094395F, 0.0F); + this.wall3 = new ModelRenderer(this, 0, 92); + this.wall3.addBox(-12.0F, 0.0F, 20.0F, 24, 12, 1); + this.wall3.setRotationPoint(0.0F, 14.0F, 0.0F); + this.wall3.setTextureSize(128, 128); + this.wall3.mirror = true; + this.setRotation(this.wall3, 0.2094395F, 2.094395F, 0.0F); + this.wall4 = new ModelRenderer(this, 0, 92); + this.wall4.addBox(-12.0F, 0.0F, -21.0F, 24, 12, 1); + this.wall4.setRotationPoint(0.0F, 14.0F, 0.0F); + this.wall4.setTextureSize(128, 128); + this.wall4.mirror = true; + this.setRotation(this.wall4, -0.2094395F, 0.0F, 0.0F); + this.wallunder1 = new ModelRenderer(this, 0, 107); + this.wallunder1.addBox(-13.0F, 0.0F, 21.0F, 26, 6, 1); + this.wallunder1.setRotationPoint(0.0F, 18.0F, 0.0F); + this.wallunder1.setTextureSize(128, 128); + this.wallunder1.mirror = true; + this.setRotation(this.wallunder1, 0.0F, 0.0F, 0.0F); + this.wallunder3 = new ModelRenderer(this, 0, 107); + this.wallunder3.addBox(-13.0F, 0.0F, 21.0F, 26, 6, 1); + this.wallunder3.setRotationPoint(0.0F, 18.0F, 0.0F); + this.wallunder3.setTextureSize(128, 128); + this.wallunder3.mirror = true; + this.setRotation(this.wallunder3, 0.0F, 2.094395F, 0.0F); + this.wallunder2 = new ModelRenderer(this, 0, 107); + this.wallunder2.addBox(-13.0F, 0.0F, 21.0F, 26, 6, 1); + this.wallunder2.setRotationPoint(0.0F, 18.0F, 0.0F); + this.wallunder2.setTextureSize(128, 128); + this.wallunder2.mirror = true; + this.setRotation(this.wallunder2, 0.0F, 1.047198F, 0.0F); + this.wallunder6 = new ModelRenderer(this, 0, 107); + this.wallunder6.addBox(-13.0F, 0.0F, 21.0F, 26, 6, 1); + this.wallunder6.setRotationPoint(0.0F, 18.0F, 0.0F); + this.wallunder6.setTextureSize(128, 128); + this.wallunder6.mirror = true; + this.setRotation(this.wallunder6, 0.0F, -1.047198F, 0.0F); + this.wallunder5 = new ModelRenderer(this, 0, 107); + this.wallunder5.addBox(-13.0F, 0.0F, 21.0F, 26, 6, 1); + this.wallunder5.setRotationPoint(0.0F, 18.0F, 0.0F); + this.wallunder5.setTextureSize(128, 128); + this.wallunder5.mirror = true; + this.setRotation(this.wallunder5, 0.0F, -2.094395F, 0.0F); + this.wallunder4 = new ModelRenderer(this, 0, 107); + this.wallunder4.addBox(-13.0F, 0.0F, -22.0F, 26, 6, 1); + this.wallunder4.setRotationPoint(0.0F, 18.0F, 0.0F); + this.wallunder4.setTextureSize(128, 128); + this.wallunder4.mirror = true; + this.setRotation(this.wallunder4, 0.0F, 0.0F, 0.0F); + this.Blade1 = new ModelRenderer(this, 0, 0); + this.Blade1.addBox(-1.0F, 0.0F, -18.0F, 2, 1, 36); + this.Blade1.setRotationPoint(0.0F, 12.0F, 0.0F); + this.Blade1.setTextureSize(128, 128); + this.Blade1.mirror = true; + this.setRotation(this.Blade1, 0.0F, 0.0F, 0.1745329F); + this.Blade2 = new ModelRenderer(this, 0, 0); + this.Blade2.addBox(-1.0F, 0.0F, -18.0F, 2, 1, 36); + this.Blade2.setRotationPoint(0.0F, 12.0F, 0.0F); + this.Blade2.setTextureSize(128, 128); + this.Blade2.mirror = true; + this.setRotation(this.Blade2, 0.0F, 0.5235988F, 0.1745329F); + this.Blade3 = new ModelRenderer(this, 0, 0); + this.Blade3.addBox(-1.0F, 0.0F, -18.0F, 2, 1, 36); + this.Blade3.setRotationPoint(0.0F, 12.0F, 0.0F); + this.Blade3.setTextureSize(128, 128); + this.Blade3.mirror = true; + this.setRotation(this.Blade3, 0.0F, 1.047198F, 0.1745329F); + this.Blade4 = new ModelRenderer(this, 0, 0); + this.Blade4.addBox(-1.0F, 0.0F, -18.0F, 2, 1, 36); + this.Blade4.setRotationPoint(0.0F, 12.0F, 0.0F); + this.Blade4.setTextureSize(128, 128); + this.Blade4.mirror = true; + this.setRotation(this.Blade4, 0.0F, 1.570796F, 0.1745329F); + this.Blade5 = new ModelRenderer(this, 0, 0); + this.Blade5.addBox(-1.0F, 0.0F, -18.0F, 2, 1, 36); + this.Blade5.setRotationPoint(0.0F, 12.0F, 0.0F); + this.Blade5.setTextureSize(128, 128); + this.Blade5.mirror = true; + this.setRotation(this.Blade5, 0.0F, 2.094395F, 0.1745329F); + this.Blade6 = new ModelRenderer(this, 0, 0); + this.Blade6.addBox(-1.0F, 0.0F, -18.0F, 2, 1, 36); + this.Blade6.setRotationPoint(0.0F, 12.0F, 0.0F); + this.Blade6.setTextureSize(128, 128); + this.Blade6.mirror = true; + this.setRotation(this.Blade6, 0.0F, 2.617994F, 0.1745329F); + this.LargeBlade1 = new ModelRenderer(this, 0, 49); + this.LargeBlade1.addBox(-3.0F, 0.0F, -20.0F, 6, 1, 40); + this.LargeBlade1.setRotationPoint(0.0F, 20.0F, 0.0F); + this.LargeBlade1.setTextureSize(128, 128); + this.LargeBlade1.mirror = true; + this.setRotation(this.LargeBlade1, 0.0F, 2.094395F, 0.1745329F); + this.LargeBlade2 = new ModelRenderer(this, 0, 49); + this.LargeBlade2.addBox(-3.0F, 0.0F, -20.0F, 6, 1, 40); + this.LargeBlade2.setRotationPoint(0.0F, 20.0F, 0.0F); + this.LargeBlade2.setTextureSize(128, 128); + this.LargeBlade2.mirror = true; + this.setRotation(this.LargeBlade2, 0.0F, 2.617994F, 0.1745329F); + this.LargeBlade3 = new ModelRenderer(this, 0, 49); + this.LargeBlade3.addBox(-3.0F, 0.0F, -20.0F, 6, 1, 40); + this.LargeBlade3.setRotationPoint(0.0F, 20.0F, 0.0F); + this.LargeBlade3.setTextureSize(128, 128); + this.LargeBlade3.mirror = true; + this.setRotation(this.LargeBlade3, 0.0F, 0.0F, 0.1745329F); + this.LargeBlade4 = new ModelRenderer(this, 0, 49); + this.LargeBlade4.addBox(-3.0F, 0.0F, -20.0F, 6, 1, 40); + this.LargeBlade4.setRotationPoint(0.0F, 20.0F, 0.0F); + this.LargeBlade4.setTextureSize(128, 128); + this.LargeBlade4.mirror = true; + this.setRotation(this.LargeBlade4, 0.0F, 0.5235988F, 0.1745329F); + this.LargeBlade5 = new ModelRenderer(this, 0, 49); + this.LargeBlade5.addBox(-3.0F, 0.0F, -20.0F, 6, 1, 40); + this.LargeBlade5.setRotationPoint(0.0F, 20.0F, 0.0F); + this.LargeBlade5.setTextureSize(128, 128); + this.LargeBlade5.mirror = true; + this.setRotation(this.LargeBlade5, 0.0F, 1.047198F, 0.1745329F); + this.LargeBlade6 = new ModelRenderer(this, 0, 49); + this.LargeBlade6.addBox(-3.0F, 0.0F, -20.0F, 6, 1, 40); + this.LargeBlade6.setRotationPoint(0.0F, 20.0F, 0.0F); + this.LargeBlade6.setTextureSize(128, 128); + this.LargeBlade6.mirror = true; + this.setRotation(this.LargeBlade6, 0.0F, 1.570796F, 0.1745329F); + this.MediumBlade1 = new ModelRenderer(this, 43, 0); + this.MediumBlade1.addBox(-2.0F, 0.0F, -19.0F, 4, 1, 38); + this.MediumBlade1.setRotationPoint(0.0F, 16.0F, 0.0F); + this.MediumBlade1.setTextureSize(128, 128); + this.MediumBlade1.mirror = true; + this.setRotation(this.MediumBlade1, 0.0F, 2.094395F, 0.1745329F); + this.MediumBlade2 = new ModelRenderer(this, 43, 0); + this.MediumBlade2.addBox(-2.0F, 0.0F, -19.0F, 4, 1, 38); + this.MediumBlade2.setRotationPoint(0.0F, 16.0F, 0.0F); + this.MediumBlade2.setTextureSize(128, 128); + this.MediumBlade2.mirror = true; + this.setRotation(this.MediumBlade2, 0.0F, 2.617994F, 0.1745329F); + this.MediumBlade3 = new ModelRenderer(this, 43, 0); + this.MediumBlade3.addBox(-2.0F, 0.0F, -19.0F, 4, 1, 38); + this.MediumBlade3.setRotationPoint(0.0F, 16.0F, 0.0F); + this.MediumBlade3.setTextureSize(128, 128); + this.MediumBlade3.mirror = true; + this.setRotation(this.MediumBlade3, 0.0F, 0.0F, 0.1745329F); + this.MediumBlade4 = new ModelRenderer(this, 43, 0); + this.MediumBlade4.addBox(-2.0F, 0.0F, -19.0F, 4, 1, 38); + this.MediumBlade4.setRotationPoint(0.0F, 16.0F, 0.0F); + this.MediumBlade4.setTextureSize(128, 128); + this.MediumBlade4.mirror = true; + this.setRotation(this.MediumBlade4, 0.0F, 0.5235988F, 0.1745329F); + this.MediumBlade5 = new ModelRenderer(this, 43, 0); + this.MediumBlade5.addBox(-2.0F, 0.0F, -19.0F, 4, 1, 38); + this.MediumBlade5.setRotationPoint(0.0F, 16.0F, 0.0F); + this.MediumBlade5.setTextureSize(128, 128); + this.MediumBlade5.mirror = true; + this.setRotation(this.MediumBlade5, 0.0F, 1.047198F, 0.1745329F); + this.MediumBlade6 = new ModelRenderer(this, 43, 0); + this.MediumBlade6.addBox(-2.0F, 0.0F, -19.0F, 4, 1, 38); + this.MediumBlade6.setRotationPoint(0.0F, 16.0F, 0.0F); + this.MediumBlade6.setTextureSize(128, 128); + this.MediumBlade6.mirror = true; + this.setRotation(this.MediumBlade6, 0.0F, 1.570796F, 0.1745329F); + this.Support1 = new ModelRenderer(this, 0, 0); + this.Support1.addBox(-1.0F, 0.0F, -23.0F, 2, 1, 46); + this.Support1.setRotationPoint(0.0F, 10.0F, 0.0F); + this.Support1.setTextureSize(128, 128); + this.Support1.mirror = true; + this.setRotation(this.Support1, 0.0F, 0.5235988F, 0.0F); + this.support2 = new ModelRenderer(this, 0, 0); + this.support2.addBox(-1.0F, 0.0F, -23.0F, 2, 1, 46); + this.support2.setRotationPoint(0.0F, 10.0F, 0.0F); + this.support2.setTextureSize(128, 128); + this.support2.mirror = true; + this.setRotation(this.support2, 0.0F, 2.617994F, 0.0F); + this.support3 = new ModelRenderer(this, 0, 0); + this.support3.addBox(-1.0F, 0.0F, -23.0F, 2, 1, 46); + this.support3.setRotationPoint(0.0F, 10.0F, 0.0F); + this.support3.setTextureSize(128, 128); + this.support3.mirror = true; + this.setRotation(this.support3, 0.0F, 1.570796F, 0.0F); + this.cornerbottom1 = new ModelRenderer(this, 10, 0); + this.cornerbottom1.addBox(17.0F, 0.0F, 17.0F, 3, 4, 3); + this.cornerbottom1.setRotationPoint(0.0F, 20.0F, 0.0F); + this.cornerbottom1.setTextureSize(128, 128); + this.cornerbottom1.mirror = true; + this.setRotation(this.cornerbottom1, 0.0F, 2.879793F, 0.0F); + this.corner1 = new ModelRenderer(this, 0, 0); + this.corner1.addBox(16.0F, 0.0F, 16.0F, 2, 14, 2); + this.corner1.setRotationPoint(0.0F, 13.0F, 0.0F); + this.corner1.setTextureSize(128, 128); + this.corner1.mirror = true; + this.setRotation(this.corner1, 0.122173F, 2.879793F, -0.1396263F); + this.corner2 = new ModelRenderer(this, 0, 0); + this.corner2.addBox(16.0F, 0.0F, 16.0F, 2, 14, 2); + this.corner2.setRotationPoint(0.0F, 13.0F, 0.0F); + this.corner2.setTextureSize(128, 128); + this.corner2.mirror = true; + this.setRotation(this.corner2, 0.122173F, -2.356194F, -0.1396263F); + this.cornerbottom2 = new ModelRenderer(this, 10, 0); + this.cornerbottom2.addBox(17.0F, 0.0F, 17.0F, 3, 4, 3); + this.cornerbottom2.setRotationPoint(0.0F, 20.0F, 0.0F); + this.cornerbottom2.setTextureSize(128, 128); + this.cornerbottom2.mirror = true; + this.setRotation(this.cornerbottom2, 0.0F, -2.356194F, 0.0F); + this.corner6 = new ModelRenderer(this, 0, 0); + this.corner6.addBox(16.0F, 0.0F, 16.0F, 2, 14, 2); + this.corner6.setRotationPoint(0.0F, 13.0F, 0.0F); + this.corner6.setTextureSize(128, 128); + this.corner6.mirror = true; + this.setRotation(this.corner6, 0.122173F, 1.832596F, -0.1396263F); + this.cornerbottom6 = new ModelRenderer(this, 10, 0); + this.cornerbottom6.addBox(17.0F, 0.0F, 17.0F, 3, 4, 3); + this.cornerbottom6.setRotationPoint(0.0F, 20.0F, 0.0F); + this.cornerbottom6.setTextureSize(128, 128); + this.cornerbottom6.mirror = true; + this.setRotation(this.cornerbottom6, 0.0F, 1.832596F, 0.0F); + this.corner5 = new ModelRenderer(this, 0, 0); + this.corner5.addBox(16.0F, 0.0F, 16.0F, 2, 14, 2); + this.corner5.setRotationPoint(0.0F, 13.0F, 0.0F); + this.corner5.setTextureSize(128, 128); + this.corner5.mirror = true; + this.setRotation(this.corner5, 0.122173F, 0.7853982F, -0.1396263F); + this.cornerbottom5 = new ModelRenderer(this, 10, 0); + this.cornerbottom5.addBox(17.0F, 0.0F, 17.0F, 3, 4, 3); + this.cornerbottom5.setRotationPoint(0.0F, 20.0F, 0.0F); + this.cornerbottom5.setTextureSize(128, 128); + this.cornerbottom5.mirror = true; + this.setRotation(this.cornerbottom5, 0.0F, 0.7853982F, 0.0F); + this.corner4 = new ModelRenderer(this, 0, 0); + this.corner4.addBox(16.0F, 0.0F, 16.0F, 2, 14, 2); + this.corner4.setRotationPoint(0.0F, 13.0F, 0.0F); + this.corner4.setTextureSize(128, 128); + this.corner4.mirror = true; + this.setRotation(this.corner4, 0.122173F, -0.2617994F, -0.1396263F); + this.cornerbottom4 = new ModelRenderer(this, 10, 0); + this.cornerbottom4.addBox(17.0F, 0.0F, 17.0F, 3, 4, 3); + this.cornerbottom4.setRotationPoint(0.0F, 20.0F, 0.0F); + this.cornerbottom4.setTextureSize(128, 128); + this.cornerbottom4.mirror = true; + this.setRotation(this.cornerbottom4, 0.0F, -0.2617994F, 0.0F); + this.corner3 = new ModelRenderer(this, 0, 0); + this.corner3.addBox(16.0F, 0.0F, 16.0F, 2, 14, 2); + this.corner3.setRotationPoint(0.0F, 13.0F, 0.0F); + this.corner3.setTextureSize(128, 128); + this.corner3.mirror = true; + this.setRotation(this.corner3, 0.122173F, -1.308997F, -0.1396263F); + this.cornerbottom3 = new ModelRenderer(this, 10, 0); + this.cornerbottom3.addBox(17.0F, 0.0F, 17.0F, 3, 4, 3); + this.cornerbottom3.setRotationPoint(0.0F, 20.0F, 0.0F); + this.cornerbottom3.setTextureSize(128, 128); + this.cornerbottom3.mirror = true; + this.setRotation(this.cornerbottom3, 0.0F, -1.308997F, 0.0F); + this.Topelectricityoutput = new ModelRenderer(this, 0, 18); + this.Topelectricityoutput.addBox(-3.0F, 0.0F, -3.0F, 6, 2, 6); + this.Topelectricityoutput.setRotationPoint(0.0F, 8.0F, 0.0F); + this.Topelectricityoutput.setTextureSize(128, 128); + this.Topelectricityoutput.mirror = true; + this.setRotation(this.Topelectricityoutput, 0.0F, 0.0F, 0.0F); + } + + public void render(float rotation, float f5) { + this.Centeraxle.render(f5); + this.wall1.render(f5); + this.wall2.render(f5); + this.wall6.render(f5); + this.wall5.render(f5); + this.wall3.render(f5); + this.wall4.render(f5); + this.wallunder1.render(f5); + this.wallunder3.render(f5); + this.wallunder2.render(f5); + this.wallunder6.render(f5); + this.wallunder5.render(f5); + this.wallunder4.render(f5); + GL11.glPushMatrix(); + GL11.glRotatef(rotation, 0.0F, 1.0F, 0.0F); + this.Blade1.render(f5); + this.Blade2.render(f5); + this.Blade3.render(f5); + this.Blade4.render(f5); + this.Blade5.render(f5); + this.Blade6.render(f5); + GL11.glPopMatrix(); + GL11.glPushMatrix(); + GL11.glRotatef(-rotation, 0.0F, 1.0F, 0.0F); + this.MediumBlade1.render(f5); + this.MediumBlade2.render(f5); + this.MediumBlade3.render(f5); + this.MediumBlade4.render(f5); + this.MediumBlade5.render(f5); + this.MediumBlade6.render(f5); + GL11.glPopMatrix(); + GL11.glPushMatrix(); + GL11.glRotatef(rotation, 0.0F, 1.0F, 0.0F); + this.LargeBlade1.render(f5); + this.LargeBlade2.render(f5); + this.LargeBlade3.render(f5); + this.LargeBlade4.render(f5); + this.LargeBlade5.render(f5); + this.LargeBlade6.render(f5); + GL11.glPopMatrix(); + this.Support1.render(f5); + this.support2.render(f5); + this.support3.render(f5); + this.cornerbottom1.render(f5); + this.corner1.render(f5); + this.corner2.render(f5); + this.cornerbottom2.render(f5); + this.corner6.render(f5); + this.cornerbottom6.render(f5); + this.corner5.render(f5); + this.cornerbottom5.render(f5); + this.corner4.render(f5); + this.cornerbottom4.render(f5); + this.corner3.render(f5); + this.cornerbottom3.render(f5); + this.Topelectricityoutput.render(f5); + } + + private void setRotation(ModelRenderer model, float x, float y, float z) { + model.rotateAngleX = x; + model.rotateAngleY = y; + model.rotateAngleZ = z; + } +} diff --git a/src/main/java/atomicscience/muoxing/MNuclearBoiler.java b/src/main/java/atomicscience/muoxing/MNuclearBoiler.java new file mode 100644 index 0000000..e849b10 --- /dev/null +++ b/src/main/java/atomicscience/muoxing/MNuclearBoiler.java @@ -0,0 +1,132 @@ +package atomicscience.muoxing; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import net.minecraft.client.model.ModelBase; +import net.minecraft.client.model.ModelRenderer; + +@SideOnly(Side.CLIENT) +public class MNuclearBoiler extends ModelBase { + ModelRenderer BASE; + ModelRenderer THERMAL_DISPLAY; + ModelRenderer SUPPORT; + ModelRenderer RAD_SHIELD_PLATE_1; + ModelRenderer RAD_SHIELD_PLATE_2; + ModelRenderer RAD_SHIELD_PLATE_3; + ModelRenderer FUEL_BAR_SUPPORT_1_ROTATES; + ModelRenderer FUEL_BAR_SUPPORT_2_ROTATES; + ModelRenderer FUEL_BAR_1_ROTATES; + ModelRenderer FUEL_BAR_2_ROTATES; + ModelRenderer TOP_SUPPORT_A; + ModelRenderer TOP_SUPPORT_B; + ModelRenderer TOP_SUPPORT_C; + + public MNuclearBoiler() { + super.textureWidth = 128; + super.textureHeight = 128; + this.BASE = new ModelRenderer(this, 0, 0); + this.BASE.addBox(0.0F, 0.0F, 0.0F, 16, 1, 16); + this.BASE.setRotationPoint(-8.0F, 23.0F, -8.0F); + this.BASE.setTextureSize(128, 128); + this.BASE.mirror = true; + this.setRotation(this.BASE, 0.0F, 0.0F, 0.0F); + this.THERMAL_DISPLAY = new ModelRenderer(this, 0, 37); + this.THERMAL_DISPLAY.addBox(0.0F, 0.0F, 0.0F, 8, 11, 3); + this.THERMAL_DISPLAY.setRotationPoint(-4.0F, 13.0F, -3.0F); + this.THERMAL_DISPLAY.setTextureSize(128, 128); + this.THERMAL_DISPLAY.mirror = true; + this.setRotation(this.THERMAL_DISPLAY, -0.4363323F, 0.0F, 0.0F); + this.SUPPORT = new ModelRenderer(this, 0, 19); + this.SUPPORT.addBox(0.0F, 0.0F, 0.0F, 14, 3, 13); + this.SUPPORT.setRotationPoint(-7.0F, 20.0F, -5.0F); + this.SUPPORT.setTextureSize(128, 128); + this.SUPPORT.mirror = true; + this.setRotation(this.SUPPORT, 0.0F, 0.0F, 0.0F); + this.RAD_SHIELD_PLATE_1 = new ModelRenderer(this, 46, 37); + this.RAD_SHIELD_PLATE_1.addBox(0.0F, 0.0F, 0.0F, 8, 14, 1); + this.RAD_SHIELD_PLATE_1.setRotationPoint(-4.0F, 9.0F, 0.0F); + this.RAD_SHIELD_PLATE_1.setTextureSize(128, 128); + this.RAD_SHIELD_PLATE_1.mirror = true; + this.setRotation(this.RAD_SHIELD_PLATE_1, 0.0F, 0.0F, 0.0F); + this.RAD_SHIELD_PLATE_2 = new ModelRenderer(this, 24, 37); + this.RAD_SHIELD_PLATE_2.addBox(0.0F, 0.0F, 0.0F, 8, 14, 2); + this.RAD_SHIELD_PLATE_2.setRotationPoint(-8.0F, 9.0F, 7.0F); + this.RAD_SHIELD_PLATE_2.setTextureSize(128, 128); + this.RAD_SHIELD_PLATE_2.mirror = true; + this.setRotation(this.RAD_SHIELD_PLATE_2, 0.0F, 1.064651F, 0.0F); + this.RAD_SHIELD_PLATE_3 = new ModelRenderer(this, 24, 37); + this.RAD_SHIELD_PLATE_3.addBox(0.0F, 0.0F, -2.0F, 8, 14, 2); + this.RAD_SHIELD_PLATE_3.setRotationPoint(8.0F, 9.0F, 7.0F); + this.RAD_SHIELD_PLATE_3.setTextureSize(128, 128); + this.RAD_SHIELD_PLATE_3.mirror = true; + this.setRotation(this.RAD_SHIELD_PLATE_3, 0.0F, 2.094395F, 0.0F); + this.FUEL_BAR_SUPPORT_1_ROTATES = new ModelRenderer(this, 75, 13); + this.FUEL_BAR_SUPPORT_1_ROTATES.addBox(-2.0F, 0.0F, -2.0F, 4, 1, 4); + this.FUEL_BAR_SUPPORT_1_ROTATES.setRotationPoint(3.0F, 19.0F, 5.0F); + this.FUEL_BAR_SUPPORT_1_ROTATES.setTextureSize(128, 128); + this.FUEL_BAR_SUPPORT_1_ROTATES.mirror = true; + this.setRotation(this.FUEL_BAR_SUPPORT_1_ROTATES, 0.0F, 0.5235988F, 0.0F); + this.FUEL_BAR_SUPPORT_2_ROTATES = new ModelRenderer(this, 75, 13); + this.FUEL_BAR_SUPPORT_2_ROTATES.addBox(-2.0F, 0.0F, -2.0F, 4, 1, 4); + this.FUEL_BAR_SUPPORT_2_ROTATES.setRotationPoint(-3.0F, 19.0F, 5.0F); + this.FUEL_BAR_SUPPORT_2_ROTATES.setTextureSize(128, 128); + this.FUEL_BAR_SUPPORT_2_ROTATES.mirror = true; + this.setRotation(this.FUEL_BAR_SUPPORT_2_ROTATES, 0.0F, 1.047198F, 0.0F); + this.FUEL_BAR_1_ROTATES = new ModelRenderer(this, 65, 13); + this.FUEL_BAR_1_ROTATES.addBox(-1.0F, 0.0F, -1.0F, 2, 9, 2); + this.FUEL_BAR_1_ROTATES.setRotationPoint(3.0F, 10.0F, 5.0F); + this.FUEL_BAR_1_ROTATES.setTextureSize(128, 128); + this.FUEL_BAR_1_ROTATES.mirror = true; + this.setRotation(this.FUEL_BAR_1_ROTATES, 0.0F, 0.5235988F, 0.0F); + this.FUEL_BAR_2_ROTATES = new ModelRenderer(this, 65, 13); + this.FUEL_BAR_2_ROTATES.addBox(-1.0F, 0.0F, -1.0F, 2, 9, 2); + this.FUEL_BAR_2_ROTATES.setRotationPoint(-3.0F, 10.0F, 5.0F); + this.FUEL_BAR_2_ROTATES.setTextureSize(128, 128); + this.FUEL_BAR_2_ROTATES.mirror = true; + this.setRotation(this.FUEL_BAR_2_ROTATES, 0.0F, 1.047198F, 0.0F); + this.TOP_SUPPORT_A = new ModelRenderer(this, 65, 6); + this.TOP_SUPPORT_A.addBox(-4.0F, 0.0F, -4.0F, 5, 1, 4); + this.TOP_SUPPORT_A.setRotationPoint(6.0F, 9.0F, 6.0F); + this.TOP_SUPPORT_A.setTextureSize(128, 128); + this.TOP_SUPPORT_A.mirror = true; + this.setRotation(this.TOP_SUPPORT_A, 0.0F, 0.5235988F, 0.0F); + this.TOP_SUPPORT_B = new ModelRenderer(this, 65, 6); + this.TOP_SUPPORT_B.addBox(0.0F, 0.0F, 0.0F, 5, 1, 4); + this.TOP_SUPPORT_B.setRotationPoint(-5.0F, 9.0F, 2.0F); + this.TOP_SUPPORT_B.setTextureSize(128, 128); + this.TOP_SUPPORT_B.mirror = true; + this.setRotation(this.TOP_SUPPORT_B, 0.0F, -0.5235988F, 0.0F); + this.TOP_SUPPORT_C = new ModelRenderer(this, 65, 0); + this.TOP_SUPPORT_C.addBox(0.0F, 0.0F, 0.0F, 12, 1, 4); + this.TOP_SUPPORT_C.setRotationPoint(-6.0F, 9.0F, 4.0F); + this.TOP_SUPPORT_C.setTextureSize(128, 128); + this.TOP_SUPPORT_C.mirror = true; + this.setRotation(this.TOP_SUPPORT_C, 0.0F, 0.0F, 0.0F); + } + + public void render(float rotation, float f5) { + this.BASE.render(f5); + this.THERMAL_DISPLAY.render(f5); + this.SUPPORT.render(f5); + this.RAD_SHIELD_PLATE_1.render(f5); + this.RAD_SHIELD_PLATE_2.render(f5); + this.RAD_SHIELD_PLATE_3.render(f5); + this.FUEL_BAR_SUPPORT_1_ROTATES.rotateAngleY = rotation; + this.FUEL_BAR_SUPPORT_1_ROTATES.render(f5); + this.FUEL_BAR_SUPPORT_2_ROTATES.rotateAngleY = rotation; + this.FUEL_BAR_SUPPORT_2_ROTATES.render(f5); + this.FUEL_BAR_1_ROTATES.rotateAngleY = rotation; + this.FUEL_BAR_1_ROTATES.render(f5); + this.FUEL_BAR_2_ROTATES.rotateAngleY = rotation; + this.FUEL_BAR_2_ROTATES.render(f5); + this.TOP_SUPPORT_A.render(f5); + this.TOP_SUPPORT_B.render(f5); + this.TOP_SUPPORT_C.render(f5); + } + + private void setRotation(ModelRenderer model, float x, float y, float z) { + model.rotateAngleX = x; + model.rotateAngleY = y; + model.rotateAngleZ = z; + } +} diff --git a/src/main/java/atomicscience/muoxing/MReactorCellBottom.java b/src/main/java/atomicscience/muoxing/MReactorCellBottom.java new file mode 100644 index 0000000..f68e896 --- /dev/null +++ b/src/main/java/atomicscience/muoxing/MReactorCellBottom.java @@ -0,0 +1,186 @@ +package atomicscience.muoxing; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import net.minecraft.client.model.ModelBase; +import net.minecraft.client.model.ModelRenderer; + +@SideOnly(Side.CLIENT) +public class MReactorCellBottom extends ModelBase { + + ModelRenderer BaseWidth; + ModelRenderer BottomPad; + ModelRenderer BaseDepth; + ModelRenderer Base; + ModelRenderer MiddleFrontRight; + ModelRenderer MiddleFrontLeft; + ModelRenderer MiddleBackLeft; + ModelRenderer MiddleBackRight; + ModelRenderer MiddlePLeft; + ModelRenderer MiddlePFront; + ModelRenderer MiddlePBack; + ModelRenderer MiddlePRight; + ModelRenderer OPLeftFront; + ModelRenderer OPFrontRight; + ModelRenderer OPBackLeft; + ModelRenderer OPLeftFront2; + ModelRenderer OPRightBack; + ModelRenderer OPFrontLeft; + ModelRenderer OPLeftBack; + ModelRenderer OPBackRight; + + + public MReactorCellBottom() { + super.textureWidth = 128; + super.textureHeight = 128; + this.BaseWidth = new ModelRenderer(this, 53, 16); + this.BaseWidth.addBox(0.0F, 0.0F, 0.0F, 14, 1, 10); + this.BaseWidth.setRotationPoint(-7.0F, 22.0F, -5.0F); + this.BaseWidth.setTextureSize(128, 128); + this.BaseWidth.mirror = true; + this.setRotation(this.BaseWidth, 0.0F, 0.0F, 0.0F); + this.BottomPad = new ModelRenderer(this, 53, 42); + this.BottomPad.addBox(0.0F, 0.0F, 0.0F, 10, 1, 10); + this.BottomPad.setRotationPoint(-5.0F, 23.0F, -5.0F); + this.BottomPad.setTextureSize(128, 128); + this.BottomPad.mirror = true; + this.setRotation(this.BottomPad, 0.0F, 0.0F, 0.0F); + this.BaseDepth = new ModelRenderer(this, 53, 0); + this.BaseDepth.addBox(0.0F, 0.0F, 0.0F, 10, 1, 14); + this.BaseDepth.setRotationPoint(-5.0F, 22.0F, -7.0F); + this.BaseDepth.setTextureSize(128, 128); + this.BaseDepth.mirror = true; + this.setRotation(this.BaseDepth, 0.0F, 0.0F, 0.0F); + this.Base = new ModelRenderer(this, 53, 28); + this.Base.addBox(0.0F, 0.0F, 0.0F, 12, 1, 12); + this.Base.setRotationPoint(-6.0F, 22.0F, -6.0F); + this.Base.setTextureSize(128, 128); + this.Base.mirror = true; + this.setRotation(this.Base, 0.0F, 0.0F, 0.0F); + this.MiddleFrontRight = new ModelRenderer(this, 0, 68); + this.MiddleFrontRight.addBox(0.0F, 0.0F, 0.0F, 1, 14, 1); + this.MiddleFrontRight.setRotationPoint(3.0F, 8.0F, -4.0F); + this.MiddleFrontRight.setTextureSize(128, 128); + this.MiddleFrontRight.mirror = true; + this.setRotation(this.MiddleFrontRight, 0.0F, 0.0F, 0.0F); + this.MiddleFrontLeft = new ModelRenderer(this, 0, 68); + this.MiddleFrontLeft.addBox(0.0F, 0.0F, 0.0F, 1, 14, 1); + this.MiddleFrontLeft.setRotationPoint(-4.0F, 8.0F, -4.0F); + this.MiddleFrontLeft.setTextureSize(128, 128); + this.MiddleFrontLeft.mirror = true; + this.setRotation(this.MiddleFrontLeft, 0.0F, 0.0F, 0.0F); + this.MiddleBackLeft = new ModelRenderer(this, 0, 68); + this.MiddleBackLeft.addBox(0.0F, 0.0F, 0.0F, 1, 14, 1); + this.MiddleBackLeft.setRotationPoint(-4.0F, 8.0F, 3.0F); + this.MiddleBackLeft.setTextureSize(128, 128); + this.MiddleBackLeft.mirror = true; + this.setRotation(this.MiddleBackLeft, 0.0F, 0.0F, 0.0F); + this.MiddleBackRight = new ModelRenderer(this, 0, 68); + this.MiddleBackRight.addBox(0.0F, 0.0F, 0.0F, 1, 14, 1); + this.MiddleBackRight.setRotationPoint(3.0F, 8.0F, 3.0F); + this.MiddleBackRight.setTextureSize(128, 128); + this.MiddleBackRight.mirror = true; + this.setRotation(this.MiddleBackRight, 0.0F, 0.0F, 0.0F); + this.MiddlePLeft = new ModelRenderer(this, 5, 68); + this.MiddlePLeft.addBox(0.0F, 1.466667F, 0.0F, 1, 14, 6); + this.MiddlePLeft.setRotationPoint(-5.0F, 6.5F, -3.0F); + this.MiddlePLeft.setTextureSize(128, 128); + this.MiddlePLeft.mirror = true; + this.setRotation(this.MiddlePLeft, 0.0F, 0.0F, 0.0F); + this.MiddlePFront = new ModelRenderer(this, 23, 83); + this.MiddlePFront.addBox(0.0F, 0.0F, 0.0F, 6, 14, 1); + this.MiddlePFront.setRotationPoint(-3.0F, 8.0F, -5.0F); + this.MiddlePFront.setTextureSize(128, 128); + this.MiddlePFront.mirror = true; + this.setRotation(this.MiddlePFront, 0.0F, 0.0F, 0.0F); + this.MiddlePBack = new ModelRenderer(this, 23, 83); + this.MiddlePBack.addBox(0.0F, 0.0F, 0.0F, 6, 14, 1); + this.MiddlePBack.setRotationPoint(-3.0F, 8.0F, 4.0F); + this.MiddlePBack.setTextureSize(128, 128); + this.MiddlePBack.mirror = true; + this.setRotation(this.MiddlePBack, 0.0F, 0.0F, 0.0F); + this.MiddlePRight = new ModelRenderer(this, 5, 68); + this.MiddlePRight.addBox(0.0F, 0.0F, 0.0F, 1, 14, 6); + this.MiddlePRight.setRotationPoint(4.0F, 8.0F, -3.0F); + this.MiddlePRight.setTextureSize(128, 128); + this.MiddlePRight.mirror = true; + this.setRotation(this.MiddlePRight, 0.0F, 0.0F, 0.0F); + this.OPLeftFront = new ModelRenderer(this, 0, 0); + this.OPLeftFront.addBox(0.0F, 0.0F, 0.0F, 1, 14, 1); + this.OPLeftFront.setRotationPoint(-7.0F, 8.0F, -4.0F); + this.OPLeftFront.setTextureSize(128, 128); + this.OPLeftFront.mirror = true; + this.setRotation(this.OPLeftFront, 0.0F, 0.0F, 0.0F); + this.OPFrontRight = new ModelRenderer(this, 0, 0); + this.OPFrontRight.addBox(0.0F, 0.0F, 0.0F, 1, 14, 1); + this.OPFrontRight.setRotationPoint(3.0F, 8.0F, -7.0F); + this.OPFrontRight.setTextureSize(128, 128); + this.OPFrontRight.mirror = true; + this.setRotation(this.OPFrontRight, 0.0F, 0.0F, 0.0F); + this.OPBackLeft = new ModelRenderer(this, 0, 0); + this.OPBackLeft.addBox(0.0F, 0.0F, 0.0F, 1, 14, 1); + this.OPBackLeft.setRotationPoint(-4.0F, 8.0F, 6.0F); + this.OPBackLeft.setTextureSize(128, 128); + this.OPBackLeft.mirror = true; + this.setRotation(this.OPBackLeft, 0.0F, 0.0F, 0.0F); + this.OPLeftFront2 = new ModelRenderer(this, 0, 0); + this.OPLeftFront2.addBox(0.0F, 0.0F, 0.0F, 1, 14, 1); + this.OPLeftFront2.setRotationPoint(6.0F, 8.0F, -4.0F); + this.OPLeftFront2.setTextureSize(128, 128); + this.OPLeftFront2.mirror = true; + this.setRotation(this.OPLeftFront2, 0.0F, 0.0F, 0.0F); + this.OPRightBack = new ModelRenderer(this, 0, 0); + this.OPRightBack.addBox(0.0F, 0.0F, 0.0F, 1, 14, 1); + this.OPRightBack.setRotationPoint(6.0F, 8.0F, 3.0F); + this.OPRightBack.setTextureSize(128, 128); + this.OPRightBack.mirror = true; + this.setRotation(this.OPRightBack, 0.0F, 0.0F, 0.0F); + this.OPFrontLeft = new ModelRenderer(this, 0, 0); + this.OPFrontLeft.addBox(0.0F, 0.0F, 0.0F, 1, 14, 1); + this.OPFrontLeft.setRotationPoint(-4.0F, 8.0F, -7.0F); + this.OPFrontLeft.setTextureSize(128, 128); + this.OPFrontLeft.mirror = true; + this.setRotation(this.OPFrontLeft, 0.0F, 0.0F, 0.0F); + this.OPLeftBack = new ModelRenderer(this, 0, 0); + this.OPLeftBack.addBox(0.0F, 0.0F, 0.0F, 1, 14, 1); + this.OPLeftBack.setRotationPoint(-7.0F, 8.0F, 3.0F); + this.OPLeftBack.setTextureSize(128, 128); + this.OPLeftBack.mirror = true; + this.setRotation(this.OPLeftBack, 0.0F, 0.0F, 0.0F); + this.OPBackRight = new ModelRenderer(this, 0, 0); + this.OPBackRight.addBox(0.0F, 0.0F, 0.0F, 1, 14, 1); + this.OPBackRight.setRotationPoint(3.0F, 8.0F, 6.0F); + this.OPBackRight.setTextureSize(128, 128); + this.OPBackRight.mirror = true; + this.setRotation(this.OPBackRight, 0.0F, 0.0F, 0.0F); + } + + public void render(float f5) { + this.BaseWidth.render(f5); + this.BottomPad.render(f5); + this.BaseDepth.render(f5); + this.Base.render(f5); + this.MiddleFrontRight.render(f5); + this.MiddleFrontLeft.render(f5); + this.MiddleBackLeft.render(f5); + this.MiddleBackRight.render(f5); + this.MiddlePLeft.render(f5); + this.MiddlePFront.render(f5); + this.MiddlePBack.render(f5); + this.MiddlePRight.render(f5); + this.OPLeftFront.render(f5); + this.OPFrontRight.render(f5); + this.OPBackLeft.render(f5); + this.OPLeftFront2.render(f5); + this.OPRightBack.render(f5); + this.OPFrontLeft.render(f5); + this.OPLeftBack.render(f5); + this.OPBackRight.render(f5); + } + + private void setRotation(ModelRenderer model, float x, float y, float z) { + model.rotateAngleX = x; + model.rotateAngleY = y; + model.rotateAngleZ = z; + } +} diff --git a/src/main/java/atomicscience/muoxing/MReactorCellMiddle.java b/src/main/java/atomicscience/muoxing/MReactorCellMiddle.java new file mode 100644 index 0000000..321d017 --- /dev/null +++ b/src/main/java/atomicscience/muoxing/MReactorCellMiddle.java @@ -0,0 +1,154 @@ +package atomicscience.muoxing; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import net.minecraft.client.model.ModelBase; +import net.minecraft.client.model.ModelRenderer; + +@SideOnly(Side.CLIENT) +public class MReactorCellMiddle extends ModelBase { + + ModelRenderer MiddleFrontRight; + ModelRenderer MiddleFrontLeft; + ModelRenderer MiddleBackLeft; + ModelRenderer MiddleBackRight; + ModelRenderer MiddlePLeft; + ModelRenderer MiddlePFront; + ModelRenderer MiddlePBack; + ModelRenderer MiddlePRight; + ModelRenderer OPLeftFront; + ModelRenderer OPFrontRight; + ModelRenderer OPBackLeft; + ModelRenderer OPLeftFront2; + ModelRenderer OPRightBack; + ModelRenderer OPFrontLeft; + ModelRenderer OPLeftBack; + ModelRenderer OPBackRight; + + + public MReactorCellMiddle() { + super.textureWidth = 128; + super.textureHeight = 128; + this.MiddleFrontRight = new ModelRenderer(this, 0, 68); + this.MiddleFrontRight.addBox(0.0F, 0.0F, 0.0F, 1, 16, 1); + this.MiddleFrontRight.setRotationPoint(3.0F, 8.0F, -4.0F); + this.MiddleFrontRight.setTextureSize(128, 128); + this.MiddleFrontRight.mirror = true; + this.setRotation(this.MiddleFrontRight, 0.0F, 0.0F, 0.0F); + this.MiddleFrontLeft = new ModelRenderer(this, 0, 68); + this.MiddleFrontLeft.addBox(0.0F, 0.0F, 0.0F, 1, 16, 1); + this.MiddleFrontLeft.setRotationPoint(-4.0F, 8.0F, -4.0F); + this.MiddleFrontLeft.setTextureSize(128, 128); + this.MiddleFrontLeft.mirror = true; + this.setRotation(this.MiddleFrontLeft, 0.0F, 0.0F, 0.0F); + this.MiddleBackLeft = new ModelRenderer(this, 0, 68); + this.MiddleBackLeft.addBox(0.0F, 0.0F, 0.0F, 1, 16, 1); + this.MiddleBackLeft.setRotationPoint(-4.0F, 8.0F, 3.0F); + this.MiddleBackLeft.setTextureSize(128, 128); + this.MiddleBackLeft.mirror = true; + this.setRotation(this.MiddleBackLeft, 0.0F, 0.0F, 0.0F); + this.MiddleBackRight = new ModelRenderer(this, 0, 68); + this.MiddleBackRight.addBox(0.0F, 0.0F, 0.0F, 1, 16, 1); + this.MiddleBackRight.setRotationPoint(3.0F, 8.0F, 3.0F); + this.MiddleBackRight.setTextureSize(128, 128); + this.MiddleBackRight.mirror = true; + this.setRotation(this.MiddleBackRight, 0.0F, 0.0F, 0.0F); + this.MiddlePLeft = new ModelRenderer(this, 5, 68); + this.MiddlePLeft.addBox(0.0F, 1.466667F, 0.0F, 1, 16, 6); + this.MiddlePLeft.setRotationPoint(-5.0F, 6.5F, -3.0F); + this.MiddlePLeft.setTextureSize(128, 128); + this.MiddlePLeft.mirror = true; + this.setRotation(this.MiddlePLeft, 0.0F, 0.0F, 0.0F); + this.MiddlePFront = new ModelRenderer(this, 23, 83); + this.MiddlePFront.addBox(0.0F, 0.0F, 0.0F, 6, 16, 1); + this.MiddlePFront.setRotationPoint(-3.0F, 8.0F, -5.0F); + this.MiddlePFront.setTextureSize(128, 128); + this.MiddlePFront.mirror = true; + this.setRotation(this.MiddlePFront, 0.0F, 0.0F, 0.0F); + this.MiddlePBack = new ModelRenderer(this, 23, 83); + this.MiddlePBack.addBox(0.0F, 0.0F, 0.0F, 6, 16, 1); + this.MiddlePBack.setRotationPoint(-3.0F, 8.0F, 4.0F); + this.MiddlePBack.setTextureSize(128, 128); + this.MiddlePBack.mirror = true; + this.setRotation(this.MiddlePBack, 0.0F, 0.0F, 0.0F); + this.MiddlePRight = new ModelRenderer(this, 5, 68); + this.MiddlePRight.addBox(0.0F, 0.0F, 0.0F, 1, 16, 6); + this.MiddlePRight.setRotationPoint(4.0F, 8.0F, -3.0F); + this.MiddlePRight.setTextureSize(128, 128); + this.MiddlePRight.mirror = true; + this.setRotation(this.MiddlePRight, 0.0F, 0.0F, 0.0F); + this.OPLeftFront = new ModelRenderer(this, 0, 0); + this.OPLeftFront.addBox(0.0F, 0.0F, 0.0F, 1, 16, 1); + this.OPLeftFront.setRotationPoint(-7.0F, 8.0F, -4.0F); + this.OPLeftFront.setTextureSize(128, 128); + this.OPLeftFront.mirror = true; + this.setRotation(this.OPLeftFront, 0.0F, 0.0F, 0.0F); + this.OPFrontRight = new ModelRenderer(this, 0, 0); + this.OPFrontRight.addBox(0.0F, 0.0F, 0.0F, 1, 16, 1); + this.OPFrontRight.setRotationPoint(3.0F, 8.0F, -7.0F); + this.OPFrontRight.setTextureSize(128, 128); + this.OPFrontRight.mirror = true; + this.setRotation(this.OPFrontRight, 0.0F, 0.0F, 0.0F); + this.OPBackLeft = new ModelRenderer(this, 0, 0); + this.OPBackLeft.addBox(0.0F, 0.0F, 0.0F, 1, 16, 1); + this.OPBackLeft.setRotationPoint(-4.0F, 8.0F, 6.0F); + this.OPBackLeft.setTextureSize(128, 128); + this.OPBackLeft.mirror = true; + this.setRotation(this.OPBackLeft, 0.0F, 0.0F, 0.0F); + this.OPLeftFront2 = new ModelRenderer(this, 0, 0); + this.OPLeftFront2.addBox(0.0F, 0.0F, 0.0F, 1, 16, 1); + this.OPLeftFront2.setRotationPoint(6.0F, 8.0F, -4.0F); + this.OPLeftFront2.setTextureSize(128, 128); + this.OPLeftFront2.mirror = true; + this.setRotation(this.OPLeftFront2, 0.0F, 0.0F, 0.0F); + this.OPRightBack = new ModelRenderer(this, 0, 0); + this.OPRightBack.addBox(0.0F, 0.0F, 0.0F, 1, 16, 1); + this.OPRightBack.setRotationPoint(6.0F, 8.0F, 3.0F); + this.OPRightBack.setTextureSize(128, 128); + this.OPRightBack.mirror = true; + this.setRotation(this.OPRightBack, 0.0F, 0.0F, 0.0F); + this.OPFrontLeft = new ModelRenderer(this, 0, 0); + this.OPFrontLeft.addBox(0.0F, 0.0F, 0.0F, 1, 16, 1); + this.OPFrontLeft.setRotationPoint(-4.0F, 8.0F, -7.0F); + this.OPFrontLeft.setTextureSize(128, 128); + this.OPFrontLeft.mirror = true; + this.setRotation(this.OPFrontLeft, 0.0F, 0.0F, 0.0F); + this.OPLeftBack = new ModelRenderer(this, 0, 0); + this.OPLeftBack.addBox(0.0F, 0.0F, 0.0F, 1, 16, 1); + this.OPLeftBack.setRotationPoint(-7.0F, 8.0F, 3.0F); + this.OPLeftBack.setTextureSize(128, 128); + this.OPLeftBack.mirror = true; + this.setRotation(this.OPLeftBack, 0.0F, 0.0F, 0.0F); + this.OPBackRight = new ModelRenderer(this, 0, 0); + this.OPBackRight.addBox(0.0F, 0.0F, 0.0F, 1, 16, 1); + this.OPBackRight.setRotationPoint(3.0F, 8.0F, 6.0F); + this.OPBackRight.setTextureSize(128, 128); + this.OPBackRight.mirror = true; + this.setRotation(this.OPBackRight, 0.0F, 0.0F, 0.0F); + } + + public void render(float f5) { + this.MiddleFrontRight.render(f5); + this.MiddleFrontLeft.render(f5); + this.MiddleBackLeft.render(f5); + this.MiddleBackRight.render(f5); + this.MiddlePLeft.render(f5); + this.MiddlePFront.render(f5); + this.MiddlePBack.render(f5); + this.MiddlePRight.render(f5); + this.OPLeftFront.render(f5); + this.OPFrontRight.render(f5); + this.OPBackLeft.render(f5); + this.OPLeftFront2.render(f5); + this.OPRightBack.render(f5); + this.OPFrontLeft.render(f5); + this.OPLeftBack.render(f5); + this.OPBackRight.render(f5); + } + + private void setRotation(ModelRenderer model, float x, float y, float z) { + model.rotateAngleX = x; + model.rotateAngleY = y; + model.rotateAngleZ = z; + } +} diff --git a/src/main/java/atomicscience/muoxing/MReactorCellTop.java b/src/main/java/atomicscience/muoxing/MReactorCellTop.java new file mode 100644 index 0000000..e4a24ab --- /dev/null +++ b/src/main/java/atomicscience/muoxing/MReactorCellTop.java @@ -0,0 +1,280 @@ +package atomicscience.muoxing; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import net.minecraft.client.model.ModelBase; +import net.minecraft.client.model.ModelRenderer; + +@SideOnly(Side.CLIENT) +public class MReactorCellTop extends ModelBase { + ModelRenderer TopBaseWidth; + ModelRenderer BaseWidth; + ModelRenderer BottomPad; + ModelRenderer TopBaseDepth; + ModelRenderer TopBase; + ModelRenderer BaseDepth; + ModelRenderer Base; + ModelRenderer HatMiddle; + ModelRenderer HatCover; + ModelRenderer HatTop; + ModelRenderer HatDepth; + ModelRenderer HatWidth; + ModelRenderer MiddleFrontRight; + ModelRenderer MiddleFrontLeft; + ModelRenderer MiddleBackLeft; + ModelRenderer MiddleBackRight; + ModelRenderer MiddlePLeft; + ModelRenderer MiddlePFront; + ModelRenderer MiddlePBack; + ModelRenderer MiddlePRight; + ModelRenderer FrontLeftSpike; + ModelRenderer FrontRightSpike; + ModelRenderer BackRightSpike; + ModelRenderer BackLeftSpike; + ModelRenderer OPLeftFront; + ModelRenderer OPFrontRight; + ModelRenderer OPBackLeft; + ModelRenderer OPLeftFront2; + ModelRenderer OPRightBack; + ModelRenderer OPFrontLeft; + ModelRenderer OPLeftBack; + ModelRenderer OPBackRight; + + public MReactorCellTop() { + super.textureWidth = 128; + super.textureHeight = 128; + this.TopBaseWidth = new ModelRenderer(this, 53, 16); + this.TopBaseWidth.addBox(0.0F, 0.0F, 0.0F, 14, 1, 10); + this.TopBaseWidth.setRotationPoint(-7.0F, 13.0F, -5.0F); + this.TopBaseWidth.setTextureSize(64, 32); + this.TopBaseWidth.mirror = true; + this.setRotation(this.TopBaseWidth, 0.0F, 0.0F, 0.0F); + this.BaseWidth = new ModelRenderer(this, 53, 16); + this.BaseWidth.addBox(0.0F, 0.0F, 0.0F, 14, 1, 10); + this.BaseWidth.setRotationPoint(-7.0F, 22.0F, -5.0F); + this.BaseWidth.setTextureSize(64, 32); + this.BaseWidth.mirror = true; + this.setRotation(this.BaseWidth, 0.0F, 0.0F, 0.0F); + this.BottomPad = new ModelRenderer(this, 53, 42); + this.BottomPad.addBox(0.0F, 0.0F, 0.0F, 10, 1, 10); + this.BottomPad.setRotationPoint(-5.0F, 23.0F, -5.0F); + this.BottomPad.setTextureSize(64, 32); + this.BottomPad.mirror = true; + this.setRotation(this.BottomPad, 0.0F, 0.0F, 0.0F); + this.TopBaseDepth = new ModelRenderer(this, 53, 0); + this.TopBaseDepth.addBox(0.0F, 0.0F, 0.0F, 10, 1, 14); + this.TopBaseDepth.setRotationPoint(-5.0F, 13.0F, -7.0F); + this.TopBaseDepth.setTextureSize(64, 32); + this.TopBaseDepth.mirror = true; + this.setRotation(this.TopBaseDepth, 0.0F, 0.0F, 0.0F); + this.TopBase = new ModelRenderer(this, 53, 28); + this.TopBase.addBox(0.0F, 0.0F, 0.0F, 12, 1, 12); + this.TopBase.setRotationPoint(-6.0F, 13.0F, -6.0F); + this.TopBase.setTextureSize(64, 32); + this.TopBase.mirror = true; + this.setRotation(this.TopBase, 0.0F, 0.0F, 0.0F); + this.BaseDepth = new ModelRenderer(this, 53, 0); + this.BaseDepth.addBox(0.0F, 0.0F, 0.0F, 10, 1, 14); + this.BaseDepth.setRotationPoint(-5.0F, 22.0F, -7.0F); + this.BaseDepth.setTextureSize(64, 32); + this.BaseDepth.mirror = true; + this.setRotation(this.BaseDepth, 0.0F, 0.0F, 0.0F); + this.Base = new ModelRenderer(this, 53, 28); + this.Base.addBox(0.0F, 0.0F, 0.0F, 12, 1, 12); + this.Base.setRotationPoint(-6.0F, 22.0F, -6.0F); + this.Base.setTextureSize(64, 32); + this.Base.mirror = true; + this.setRotation(this.Base, 0.0F, 0.0F, 0.0F); + this.HatMiddle = new ModelRenderer(this, 0, 42); + this.HatMiddle.addBox(0.0F, 0.0F, 0.0F, 10, 1, 10); + this.HatMiddle.setRotationPoint(-5.0F, 12.0F, -5.0F); + this.HatMiddle.setTextureSize(64, 32); + this.HatMiddle.mirror = true; + this.setRotation(this.HatMiddle, 0.0F, 0.0F, 0.0F); + this.HatCover = new ModelRenderer(this, 0, 12); + this.HatCover.addBox(0.0F, 0.0F, 0.0F, 7, 1, 7); + this.HatCover.setRotationPoint(-3.5F, 11.0F, -3.5F); + this.HatCover.setTextureSize(64, 32); + this.HatCover.mirror = true; + this.setRotation(this.HatCover, 0.0F, 0.0F, 0.0F); + this.HatTop = new ModelRenderer(this, 0, 21); + this.HatTop.addBox(0.0F, 0.0F, 0.0F, 9, 1, 9); + this.HatTop.setRotationPoint(-4.5F, 11.5F, -4.5F); + this.HatTop.setTextureSize(64, 32); + this.HatTop.mirror = true; + this.setRotation(this.HatTop, 0.0F, 0.0F, 0.0F); + this.HatDepth = new ModelRenderer(this, 0, 54); + this.HatDepth.addBox(0.0F, 0.0F, 0.0F, 8, 1, 12); + this.HatDepth.setRotationPoint(-4.0F, 12.0F, -6.0F); + this.HatDepth.setTextureSize(64, 32); + this.HatDepth.mirror = true; + this.setRotation(this.HatDepth, 0.0F, 0.0F, 0.0F); + this.HatWidth = new ModelRenderer(this, 0, 32); + this.HatWidth.addBox(0.0F, 0.0F, 0.0F, 12, 1, 8); + this.HatWidth.setRotationPoint(-6.0F, 12.0F, -4.0F); + this.HatWidth.setTextureSize(64, 32); + this.HatWidth.mirror = true; + this.setRotation(this.HatWidth, 0.0F, 0.0F, 0.0F); + this.MiddleFrontRight = new ModelRenderer(this, 0, 68); + this.MiddleFrontRight.addBox(0.0F, 0.0F, 0.0F, 1, 8, 1); + this.MiddleFrontRight.setRotationPoint(3.0F, 14.0F, -4.0F); + this.MiddleFrontRight.setTextureSize(64, 32); + this.MiddleFrontRight.mirror = true; + this.setRotation(this.MiddleFrontRight, 0.0F, 0.0F, 0.0F); + this.MiddleFrontLeft = new ModelRenderer(this, 0, 68); + this.MiddleFrontLeft.addBox(0.0F, 0.0F, 0.0F, 1, 8, 1); + this.MiddleFrontLeft.setRotationPoint(-4.0F, 14.0F, -4.0F); + this.MiddleFrontLeft.setTextureSize(64, 32); + this.MiddleFrontLeft.mirror = true; + this.setRotation(this.MiddleFrontLeft, 0.0F, 0.0F, 0.0F); + this.MiddleBackLeft = new ModelRenderer(this, 0, 68); + this.MiddleBackLeft.addBox(0.0F, 0.0F, 0.0F, 1, 8, 1); + this.MiddleBackLeft.setRotationPoint(-4.0F, 14.0F, 3.0F); + this.MiddleBackLeft.setTextureSize(64, 32); + this.MiddleBackLeft.mirror = true; + this.setRotation(this.MiddleBackLeft, 0.0F, 0.0F, 0.0F); + this.MiddleBackRight = new ModelRenderer(this, 0, 68); + this.MiddleBackRight.addBox(0.0F, 0.0F, 0.0F, 1, 8, 1); + this.MiddleBackRight.setRotationPoint(3.0F, 14.0F, 3.0F); + this.MiddleBackRight.setTextureSize(64, 32); + this.MiddleBackRight.mirror = true; + this.setRotation(this.MiddleBackRight, 0.0F, 0.0F, 0.0F); + this.MiddlePLeft = new ModelRenderer(this, 5, 68); + this.MiddlePLeft.addBox(0.0F, 1.466667F, 0.0F, 1, 8, 6); + this.MiddlePLeft.setRotationPoint(-5.0F, 12.5F, -3.0F); + this.MiddlePLeft.setTextureSize(64, 32); + this.MiddlePLeft.mirror = true; + this.setRotation(this.MiddlePLeft, 0.0F, 0.0F, 0.0F); + this.MiddlePFront = new ModelRenderer(this, 5, 83); + this.MiddlePFront.addBox(0.0F, 0.0F, 0.0F, 6, 8, 1); + this.MiddlePFront.setRotationPoint(-3.0F, 14.0F, -5.0F); + this.MiddlePFront.setTextureSize(64, 32); + this.MiddlePFront.mirror = true; + this.setRotation(this.MiddlePFront, 0.0F, 0.0F, 0.0F); + this.MiddlePBack = new ModelRenderer(this, 5, 83); + this.MiddlePBack.addBox(0.0F, 0.0F, 0.0F, 6, 8, 1); + this.MiddlePBack.setRotationPoint(-3.0F, 14.0F, 4.0F); + this.MiddlePBack.setTextureSize(64, 32); + this.MiddlePBack.mirror = true; + this.setRotation(this.MiddlePBack, 0.0F, 0.0F, 0.0F); + this.MiddlePRight = new ModelRenderer(this, 5, 68); + this.MiddlePRight.addBox(0.0F, 0.0F, 0.0F, 1, 8, 6); + this.MiddlePRight.setRotationPoint(4.0F, 14.0F, -3.0F); + this.MiddlePRight.setTextureSize(64, 32); + this.MiddlePRight.mirror = true; + this.setRotation(this.MiddlePRight, 0.0F, 0.0F, 0.0F); + this.FrontLeftSpike = new ModelRenderer(this, 44, 0); + this.FrontLeftSpike.addBox(-0.5F, -0.5F, 0.0F, 2, 3, 2); + this.FrontLeftSpike.setRotationPoint(-6.0F, 11.0F, -3.0F); + this.FrontLeftSpike.setTextureSize(64, 32); + this.FrontLeftSpike.mirror = true; + this.setRotation(this.FrontLeftSpike, 0.0F, 0.0F, -0.4363323F); + this.FrontRightSpike = new ModelRenderer(this, 44, 0); + this.FrontRightSpike.addBox(-0.5F, -1.0F, 0.0F, 2, 3, 2); + this.FrontRightSpike.setRotationPoint(5.0F, 11.0F, -3.0F); + this.FrontRightSpike.setTextureSize(64, 32); + this.FrontRightSpike.mirror = true; + this.setRotation(this.FrontRightSpike, 0.0F, 0.0F, 0.4363323F); + this.BackRightSpike = new ModelRenderer(this, 44, 0); + this.BackRightSpike.addBox(-0.5F, -1.0F, 0.0F, 2, 3, 2); + this.BackRightSpike.setRotationPoint(5.0F, 11.0F, 1.0F); + this.BackRightSpike.setTextureSize(64, 32); + this.BackRightSpike.mirror = true; + this.setRotation(this.BackRightSpike, 0.0F, 0.0F, 0.4363323F); + this.BackLeftSpike = new ModelRenderer(this, 44, 0); + this.BackLeftSpike.addBox(-0.5F, -0.5F, 0.0F, 2, 3, 2); + this.BackLeftSpike.setRotationPoint(-6.0F, 11.0F, 1.0F); + this.BackLeftSpike.setTextureSize(64, 32); + this.BackLeftSpike.mirror = true; + this.setRotation(this.BackLeftSpike, 0.0F, 0.0F, -0.4363323F); + this.OPLeftFront = new ModelRenderer(this, 0, 0); + this.OPLeftFront.addBox(0.0F, 0.0F, 0.0F, 1, 8, 1); + this.OPLeftFront.setRotationPoint(-7.0F, 14.0F, -4.0F); + this.OPLeftFront.setTextureSize(64, 32); + this.OPLeftFront.mirror = true; + this.setRotation(this.OPLeftFront, 0.0F, 0.0F, 0.0F); + this.OPFrontRight = new ModelRenderer(this, 0, 0); + this.OPFrontRight.addBox(0.0F, 0.0F, 0.0F, 1, 8, 1); + this.OPFrontRight.setRotationPoint(3.0F, 14.0F, -7.0F); + this.OPFrontRight.setTextureSize(64, 32); + this.OPFrontRight.mirror = true; + this.setRotation(this.OPFrontRight, 0.0F, 0.0F, 0.0F); + this.OPBackLeft = new ModelRenderer(this, 0, 0); + this.OPBackLeft.addBox(0.0F, 0.0F, 0.0F, 1, 8, 1); + this.OPBackLeft.setRotationPoint(-4.0F, 14.0F, 6.0F); + this.OPBackLeft.setTextureSize(64, 32); + this.OPBackLeft.mirror = true; + this.setRotation(this.OPBackLeft, 0.0F, 0.0F, 0.0F); + this.OPLeftFront2 = new ModelRenderer(this, 0, 0); + this.OPLeftFront2.addBox(0.0F, 0.0F, 0.0F, 1, 8, 1); + this.OPLeftFront2.setRotationPoint(6.0F, 14.0F, -4.0F); + this.OPLeftFront2.setTextureSize(64, 32); + this.OPLeftFront2.mirror = true; + this.setRotation(this.OPLeftFront2, 0.0F, 0.0F, 0.0F); + this.OPRightBack = new ModelRenderer(this, 0, 0); + this.OPRightBack.addBox(0.0F, 0.0F, 0.0F, 1, 8, 1); + this.OPRightBack.setRotationPoint(6.0F, 14.0F, 3.0F); + this.OPRightBack.setTextureSize(64, 32); + this.OPRightBack.mirror = true; + this.setRotation(this.OPRightBack, 0.0F, 0.0F, 0.0F); + this.OPFrontLeft = new ModelRenderer(this, 0, 0); + this.OPFrontLeft.addBox(0.0F, 0.0F, 0.0F, 1, 8, 1); + this.OPFrontLeft.setRotationPoint(-4.0F, 14.0F, -7.0F); + this.OPFrontLeft.setTextureSize(64, 32); + this.OPFrontLeft.mirror = true; + this.setRotation(this.OPFrontLeft, 0.0F, 0.0F, 0.0F); + this.OPLeftBack = new ModelRenderer(this, 0, 0); + this.OPLeftBack.addBox(0.0F, 0.0F, 0.0F, 1, 8, 1); + this.OPLeftBack.setRotationPoint(-7.0F, 14.0F, 3.0F); + this.OPLeftBack.setTextureSize(64, 32); + this.OPLeftBack.mirror = true; + this.setRotation(this.OPLeftBack, 0.0F, 0.0F, 0.0F); + this.OPBackRight = new ModelRenderer(this, 0, 0); + this.OPBackRight.addBox(0.0F, 0.0F, 0.0F, 1, 8, 1); + this.OPBackRight.setRotationPoint(3.0F, 14.0F, 6.0F); + this.OPBackRight.setTextureSize(64, 32); + this.OPBackRight.mirror = true; + this.setRotation(this.OPBackRight, 0.0F, 0.0F, 0.0F); + } + + public void render(float f5) { + this.TopBaseWidth.render(f5); + this.BaseWidth.render(f5); + this.BottomPad.render(f5); + this.TopBaseDepth.render(f5); + this.TopBase.render(f5); + this.BaseDepth.render(f5); + this.Base.render(f5); + this.HatMiddle.render(f5); + this.HatCover.render(f5); + this.HatTop.render(f5); + this.HatDepth.render(f5); + this.HatWidth.render(f5); + this.MiddleFrontRight.render(f5); + this.MiddleFrontLeft.render(f5); + this.MiddleBackLeft.render(f5); + this.MiddleBackRight.render(f5); + this.MiddlePLeft.render(f5); + this.MiddlePFront.render(f5); + this.MiddlePBack.render(f5); + this.MiddlePRight.render(f5); + this.FrontLeftSpike.render(f5); + this.FrontRightSpike.render(f5); + this.BackRightSpike.render(f5); + this.BackLeftSpike.render(f5); + this.OPLeftFront.render(f5); + this.OPFrontRight.render(f5); + this.OPBackLeft.render(f5); + this.OPLeftFront2.render(f5); + this.OPRightBack.render(f5); + this.OPFrontLeft.render(f5); + this.OPLeftBack.render(f5); + this.OPBackRight.render(f5); + } + + private void setRotation(ModelRenderer model, float x, float y, float z) { + model.rotateAngleX = x; + model.rotateAngleY = y; + model.rotateAngleZ = z; + } +} diff --git a/src/main/java/atomicscience/muoxing/MTurbine.java b/src/main/java/atomicscience/muoxing/MTurbine.java new file mode 100644 index 0000000..9f753a3 --- /dev/null +++ b/src/main/java/atomicscience/muoxing/MTurbine.java @@ -0,0 +1,221 @@ +package atomicscience.muoxing; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import net.minecraft.client.model.ModelBase; +import net.minecraft.client.model.ModelRenderer; + +@SideOnly(Side.CLIENT) +public class MTurbine extends ModelBase { + ModelRenderer SUPPORT; + ModelRenderer PLUG; + ModelRenderer MAIN_AXIS_SPINS; + ModelRenderer BLADE_A1_SPINS; + ModelRenderer BLADE_A2_SPINS; + ModelRenderer BLADE_A3_SPINS; + ModelRenderer BLADE_B1_SPINS; + ModelRenderer BLADE_B2_SPINS; + ModelRenderer BLADE_B3_SPINS; + ModelRenderer TURBINE_HEAD_SPINS; + ModelRenderer SHIELD_A1_SPINS; + ModelRenderer SHIELD_A2_SPINS; + ModelRenderer SHIELD_A3_SPINS; + ModelRenderer SHIELD_A4_SPINS; + ModelRenderer SHIELD_A5_SPINS; + ModelRenderer SHIELD_A6_SPINS; + ModelRenderer SHIELD_B1_SPINS; + ModelRenderer SHIELD_B2_SPINS; + ModelRenderer SHIELD_B3_SPINS; + ModelRenderer SHIELD_B4_SPINS; + ModelRenderer SHIELD_B5_SPINS; + ModelRenderer SHIELD_B6_SPINS; + + + public MTurbine() { + super.textureWidth = 64; + super.textureHeight = 64; + this.SUPPORT = new ModelRenderer(this, 0, 0); + this.SUPPORT.addBox(0.0F, 0.0F, 0.0F, 8, 1, 8); + this.SUPPORT.setRotationPoint(-4.0F, 9.0F, -4.0F); + this.SUPPORT.setTextureSize(64, 64); + this.SUPPORT.mirror = true; + this.setRotation(this.SUPPORT, 0.0F, 0.0F, 0.0F); + this.PLUG = new ModelRenderer(this, 0, 10); + this.PLUG.addBox(0.0F, 0.0F, 0.0F, 4, 1, 4); + this.PLUG.setRotationPoint(-2.0F, 8.0F, -2.0F); + this.PLUG.setTextureSize(64, 64); + this.PLUG.mirror = true; + this.setRotation(this.PLUG, 0.0F, 0.0F, 0.0F); + this.MAIN_AXIS_SPINS = new ModelRenderer(this, 33, 0); + this.MAIN_AXIS_SPINS.addBox(-1.0F, 0.0F, -1.0F, 2, 13, 2); + this.MAIN_AXIS_SPINS.setRotationPoint(0.0F, 10.0F, 0.0F); + this.MAIN_AXIS_SPINS.setTextureSize(64, 64); + this.MAIN_AXIS_SPINS.mirror = true; + this.setRotation(this.MAIN_AXIS_SPINS, 0.0F, 0.0F, 0.0F); + this.BLADE_A1_SPINS = new ModelRenderer(this, 0, 16); + this.BLADE_A1_SPINS.addBox(-6.0F, 0.0F, -1.0F, 12, 1, 2); + this.BLADE_A1_SPINS.setRotationPoint(0.0F, 13.0F, 0.0F); + this.BLADE_A1_SPINS.setTextureSize(64, 64); + this.BLADE_A1_SPINS.mirror = true; + this.setRotation(this.BLADE_A1_SPINS, 0.2617994F, 2.094395F, 0.0F); + this.BLADE_A2_SPINS = new ModelRenderer(this, 0, 16); + this.BLADE_A2_SPINS.addBox(-6.0F, 0.0F, -1.0F, 12, 1, 2); + this.BLADE_A2_SPINS.setRotationPoint(0.0F, 13.0F, 0.0F); + this.BLADE_A2_SPINS.setTextureSize(64, 64); + this.BLADE_A2_SPINS.mirror = true; + this.setRotation(this.BLADE_A2_SPINS, 0.2617994F, 1.047198F, 0.0F); + this.BLADE_A3_SPINS = new ModelRenderer(this, 0, 16); + this.BLADE_A3_SPINS.addBox(-6.0F, 0.0F, -1.0F, 12, 1, 2); + this.BLADE_A3_SPINS.setRotationPoint(0.0F, 13.0F, 0.0F); + this.BLADE_A3_SPINS.setTextureSize(64, 64); + this.BLADE_A3_SPINS.mirror = true; + this.setRotation(this.BLADE_A3_SPINS, 0.2617994F, 0.0F, 0.0F); + this.BLADE_B1_SPINS = new ModelRenderer(this, 0, 20); + this.BLADE_B1_SPINS.addBox(-5.0F, 0.0F, -1.0F, 10, 1, 2); + this.BLADE_B1_SPINS.setRotationPoint(0.0F, 18.0F, 0.0F); + this.BLADE_B1_SPINS.setTextureSize(64, 64); + this.BLADE_B1_SPINS.mirror = true; + this.setRotation(this.BLADE_B1_SPINS, 0.2617994F, 1.570796F, 0.0F); + this.BLADE_B2_SPINS = new ModelRenderer(this, 0, 20); + this.BLADE_B2_SPINS.addBox(-5.0F, 0.0F, -1.0F, 10, 1, 2); + this.BLADE_B2_SPINS.setRotationPoint(0.0F, 18.0F, 0.0F); + this.BLADE_B2_SPINS.setTextureSize(64, 64); + this.BLADE_B2_SPINS.mirror = true; + this.setRotation(this.BLADE_B2_SPINS, 0.2617994F, 2.617994F, 0.0F); + this.BLADE_B3_SPINS = new ModelRenderer(this, 0, 20); + this.BLADE_B3_SPINS.addBox(-5.0F, 0.0F, -1.0F, 10, 1, 2); + this.BLADE_B3_SPINS.setRotationPoint(0.0F, 18.0F, 0.0F); + this.BLADE_B3_SPINS.setTextureSize(64, 64); + this.BLADE_B3_SPINS.mirror = true; + this.setRotation(this.BLADE_B3_SPINS, 0.2617994F, 0.5235988F, 0.0F); + this.TURBINE_HEAD_SPINS = new ModelRenderer(this, 0, 24); + this.TURBINE_HEAD_SPINS.addBox(-2.0F, 0.0F, -2.0F, 4, 2, 4); + this.TURBINE_HEAD_SPINS.setRotationPoint(0.0F, 20.0F, 0.0F); + this.TURBINE_HEAD_SPINS.setTextureSize(64, 64); + this.TURBINE_HEAD_SPINS.mirror = true; + this.setRotation(this.TURBINE_HEAD_SPINS, 0.0F, 0.0F, 0.0F); + this.SHIELD_A1_SPINS = new ModelRenderer(this, 0, 40); + this.SHIELD_A1_SPINS.addBox(6.0F, 0.0F, -4.0F, 1, 2, 8); + this.SHIELD_A1_SPINS.setRotationPoint(0.0F, 13.0F, 0.0F); + this.SHIELD_A1_SPINS.setTextureSize(64, 64); + this.SHIELD_A1_SPINS.mirror = true; + this.setRotation(this.SHIELD_A1_SPINS, 0.0F, -3.141593F, 0.0F); + this.SHIELD_A2_SPINS = new ModelRenderer(this, 0, 40); + this.SHIELD_A2_SPINS.addBox(6.0F, 0.0F, -4.0F, 1, 2, 8); + this.SHIELD_A2_SPINS.setRotationPoint(0.0F, 13.0F, 0.0F); + this.SHIELD_A2_SPINS.setTextureSize(64, 64); + this.SHIELD_A2_SPINS.mirror = true; + this.setRotation(this.SHIELD_A2_SPINS, 0.0F, 1.047198F, 0.0F); + this.SHIELD_A3_SPINS = new ModelRenderer(this, 0, 40); + this.SHIELD_A3_SPINS.addBox(6.0F, 0.0F, -4.0F, 1, 2, 8); + this.SHIELD_A3_SPINS.setRotationPoint(0.0F, 13.0F, 0.0F); + this.SHIELD_A3_SPINS.setTextureSize(64, 64); + this.SHIELD_A3_SPINS.mirror = true; + this.setRotation(this.SHIELD_A3_SPINS, 0.0F, -1.047198F, 0.0F); + this.SHIELD_A4_SPINS = new ModelRenderer(this, 0, 40); + this.SHIELD_A4_SPINS.addBox(6.0F, 0.0F, -4.0F, 1, 2, 8); + this.SHIELD_A4_SPINS.setRotationPoint(0.0F, 13.0F, 0.0F); + this.SHIELD_A4_SPINS.setTextureSize(64, 64); + this.SHIELD_A4_SPINS.mirror = true; + this.setRotation(this.SHIELD_A4_SPINS, 0.0F, -2.094395F, 0.0F); + this.SHIELD_A5_SPINS = new ModelRenderer(this, 0, 40); + this.SHIELD_A5_SPINS.addBox(6.0F, 0.0F, -4.0F, 1, 2, 8); + this.SHIELD_A5_SPINS.setRotationPoint(0.0F, 13.0F, 0.0F); + this.SHIELD_A5_SPINS.setTextureSize(64, 64); + this.SHIELD_A5_SPINS.mirror = true; + this.setRotation(this.SHIELD_A5_SPINS, 0.0F, 0.0F, 0.0F); + this.SHIELD_A6_SPINS = new ModelRenderer(this, 0, 40); + this.SHIELD_A6_SPINS.addBox(6.0F, 0.0F, -4.0F, 1, 2, 8); + this.SHIELD_A6_SPINS.setRotationPoint(0.0F, 13.0F, 0.0F); + this.SHIELD_A6_SPINS.setTextureSize(64, 64); + this.SHIELD_A6_SPINS.mirror = true; + this.setRotation(this.SHIELD_A6_SPINS, 0.0F, 2.094395F, 0.0F); + this.SHIELD_B1_SPINS = new ModelRenderer(this, 0, 31); + this.SHIELD_B1_SPINS.addBox(5.0F, 0.0F, -3.0F, 1, 2, 6); + this.SHIELD_B1_SPINS.setRotationPoint(0.0F, 18.0F, 0.0F); + this.SHIELD_B1_SPINS.setTextureSize(64, 64); + this.SHIELD_B1_SPINS.mirror = true; + this.setRotation(this.SHIELD_B1_SPINS, 0.0F, -0.5235988F, 0.0F); + this.SHIELD_B2_SPINS = new ModelRenderer(this, 0, 31); + this.SHIELD_B2_SPINS.addBox(5.0F, 0.0F, -3.0F, 1, 2, 6); + this.SHIELD_B2_SPINS.setRotationPoint(0.0F, 18.0F, 0.0F); + this.SHIELD_B2_SPINS.setTextureSize(64, 64); + this.SHIELD_B2_SPINS.mirror = true; + this.setRotation(this.SHIELD_B2_SPINS, 0.0F, 1.570796F, 0.0F); + this.SHIELD_B3_SPINS = new ModelRenderer(this, 0, 31); + this.SHIELD_B3_SPINS.addBox(5.0F, 0.0F, -3.0F, 1, 2, 6); + this.SHIELD_B3_SPINS.setRotationPoint(0.0F, 18.0F, 0.0F); + this.SHIELD_B3_SPINS.setTextureSize(64, 64); + this.SHIELD_B3_SPINS.mirror = true; + this.setRotation(this.SHIELD_B3_SPINS, 0.0F, 0.5235988F, 0.0F); + this.SHIELD_B4_SPINS = new ModelRenderer(this, 0, 31); + this.SHIELD_B4_SPINS.addBox(5.0F, 0.0F, -3.0F, 1, 2, 6); + this.SHIELD_B4_SPINS.setRotationPoint(0.0F, 18.0F, 0.0F); + this.SHIELD_B4_SPINS.setTextureSize(64, 64); + this.SHIELD_B4_SPINS.mirror = true; + this.setRotation(this.SHIELD_B4_SPINS, 0.0F, -1.570796F, 0.0F); + this.SHIELD_B5_SPINS = new ModelRenderer(this, 0, 31); + this.SHIELD_B5_SPINS.addBox(5.0F, 0.0F, -3.0F, 1, 2, 6); + this.SHIELD_B5_SPINS.setRotationPoint(0.0F, 18.0F, 0.0F); + this.SHIELD_B5_SPINS.setTextureSize(64, 64); + this.SHIELD_B5_SPINS.mirror = true; + this.setRotation(this.SHIELD_B5_SPINS, 0.0F, 2.617994F, 0.0F); + this.SHIELD_B6_SPINS = new ModelRenderer(this, 0, 31); + this.SHIELD_B6_SPINS.addBox(5.0F, 0.0F, -3.0F, 1, 2, 6); + this.SHIELD_B6_SPINS.setRotationPoint(0.0F, 18.0F, 0.0F); + this.SHIELD_B6_SPINS.setTextureSize(64, 64); + this.SHIELD_B6_SPINS.mirror = true; + this.setRotation(this.SHIELD_B6_SPINS, 0.0F, -2.617994F, 0.0F); + } + + public void render(float rotation, float f5) { + this.SUPPORT.render(f5); + this.PLUG.render(f5); + this.MAIN_AXIS_SPINS.rotateAngleY = -rotation; + this.MAIN_AXIS_SPINS.render(f5); + this.BLADE_A1_SPINS.rotateAngleY = (float)(-((double)rotation + 1.570796D)); + this.BLADE_A1_SPINS.render(f5); + this.BLADE_A2_SPINS.rotateAngleY = (float)(-((double)rotation + 2.617994D)); + this.BLADE_A2_SPINS.render(f5); + this.BLADE_A3_SPINS.rotateAngleY = (float)(-((double)rotation + 0.5235988D)); + this.BLADE_A3_SPINS.render(f5); + this.BLADE_B1_SPINS.rotateAngleY = (float)((double)rotation + 1.570796D); + this.BLADE_B1_SPINS.render(f5); + this.BLADE_B2_SPINS.rotateAngleY = (float)((double)rotation + 2.617994D); + this.BLADE_B2_SPINS.render(f5); + this.BLADE_B3_SPINS.rotateAngleY = (float)((double)rotation + 0.5235988D); + this.BLADE_B3_SPINS.render(f5); + this.TURBINE_HEAD_SPINS.rotateAngleY = rotation; + this.TURBINE_HEAD_SPINS.render(f5); + this.SHIELD_A1_SPINS.rotateAngleY = -rotation; + this.SHIELD_A1_SPINS.render(f5); + this.SHIELD_A2_SPINS.rotateAngleY = (float)(-((double)rotation + 2.094395D)); + this.SHIELD_A2_SPINS.render(f5); + this.SHIELD_A3_SPINS.rotateAngleY = (float)(-((double)rotation - 3.141593D)); + this.SHIELD_A3_SPINS.render(f5); + this.SHIELD_A4_SPINS.rotateAngleY = (float)(-((double)rotation + 1.047198D)); + this.SHIELD_A4_SPINS.render(f5); + this.SHIELD_A5_SPINS.rotateAngleY = (float)(-((double)rotation - 1.047198D)); + this.SHIELD_A5_SPINS.render(f5); + this.SHIELD_A6_SPINS.rotateAngleY = (float)(-((double)rotation - 2.094395D)); + this.SHIELD_A6_SPINS.render(f5); + this.SHIELD_B1_SPINS.rotateAngleY = rotation; + this.SHIELD_B1_SPINS.render(f5); + this.SHIELD_B2_SPINS.rotateAngleY = (float)((double)rotation + 2.094395D); + this.SHIELD_B2_SPINS.render(f5); + this.SHIELD_B3_SPINS.rotateAngleY = (float)((double)rotation - 3.141593D); + this.SHIELD_B3_SPINS.render(f5); + this.SHIELD_B4_SPINS.rotateAngleY = (float)((double)rotation + 1.047198D); + this.SHIELD_B4_SPINS.render(f5); + this.SHIELD_B5_SPINS.rotateAngleY = (float)((double)rotation - 1.047198D); + this.SHIELD_B5_SPINS.render(f5); + this.SHIELD_B6_SPINS.rotateAngleY = (float)((double)rotation - 2.094395D); + this.SHIELD_B6_SPINS.render(f5); + } + + private void setRotation(ModelRenderer model, float x, float y, float z) { + model.rotateAngleX = x; + model.rotateAngleY = y; + model.rotateAngleZ = z; + } +} diff --git a/src/main/java/atomicscience/muoxing/MUnused.java b/src/main/java/atomicscience/muoxing/MUnused.java new file mode 100644 index 0000000..50fd6d5 --- /dev/null +++ b/src/main/java/atomicscience/muoxing/MUnused.java @@ -0,0 +1,159 @@ +package atomicscience.muoxing; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import net.minecraft.client.model.ModelBase; +import net.minecraft.client.model.ModelRenderer; + +@SideOnly(Side.CLIENT) +public class MUnused extends ModelBase { + ModelRenderer BASE; + ModelRenderer SHIELD_1; + ModelRenderer SHIELD_2; + ModelRenderer SHIELD_3; + ModelRenderer SHIELD_4; + ModelRenderer REACTOR_SUPPORT_ROD_ROTATES; + ModelRenderer SUPPORT_PLATE_1_ROTATES; + ModelRenderer SUPPORT_PLATE_2_ROTATES; + ModelRenderer FUEL_BAR_1_ROTATES; + ModelRenderer FUEL_BAR_2_ROTATES; + ModelRenderer FUEL_BAR_3_ROTATES; + ModelRenderer FUEL_BAR_4_ROTATES; + ModelRenderer CONVERTER; + ModelRenderer SUB_SHIELD_1; + ModelRenderer SUB_SHIELD_2; + ModelRenderer Shape1; + + public MUnused() { + super.textureWidth = 128; + super.textureHeight = 128; + this.BASE = new ModelRenderer(this, 0, 0); + this.BASE.addBox(0.0F, 0.0F, 0.0F, 16, 1, 16); + this.BASE.setRotationPoint(-8.0F, 23.0F, -8.0F); + this.BASE.setTextureSize(128, 128); + this.BASE.mirror = true; + this.setRotation(this.BASE, 0.0F, 0.0F, 0.0F); + this.SHIELD_1 = new ModelRenderer(this, 11, 18); + this.SHIELD_1.addBox(0.0F, 0.0F, 0.0F, 1, 10, 8); + this.SHIELD_1.setRotationPoint(0.0F, 13.0F, 6.0F); + this.SHIELD_1.setTextureSize(128, 128); + this.SHIELD_1.mirror = true; + this.setRotation(this.SHIELD_1, 0.0F, -2.234021F, 0.0F); + this.SHIELD_2 = new ModelRenderer(this, 0, 18); + this.SHIELD_2.addBox(0.0F, 0.0F, 0.0F, 1, 10, 4); + this.SHIELD_2.setRotationPoint(-7.0F, 13.0F, -2.0F); + this.SHIELD_2.setTextureSize(128, 128); + this.SHIELD_2.mirror = true; + this.setRotation(this.SHIELD_2, 0.0F, 0.0F, 0.0F); + this.SHIELD_3 = new ModelRenderer(this, 11, 37); + this.SHIELD_3.addBox(0.0F, 0.0F, 0.0F, 1, 10, 8); + this.SHIELD_3.setRotationPoint(5.0F, 13.0F, -3.0F); + this.SHIELD_3.setTextureSize(128, 128); + this.SHIELD_3.mirror = true; + this.setRotation(this.SHIELD_3, 0.0F, 0.0F, 0.0F); + this.SHIELD_4 = new ModelRenderer(this, 0, 37); + this.SHIELD_4.addBox(0.0F, 0.0F, 0.0F, 1, 10, 4); + this.SHIELD_4.setRotationPoint(6.0F, 13.0F, -3.0F); + this.SHIELD_4.setTextureSize(128, 128); + this.SHIELD_4.mirror = true; + this.setRotation(this.SHIELD_4, 0.0F, -2.094395F, 0.0F); + this.REACTOR_SUPPORT_ROD_ROTATES = new ModelRenderer(this, 0, 67); + this.REACTOR_SUPPORT_ROD_ROTATES.addBox(-1.0F, 0.0F, -1.0F, 2, 13, 2); + this.REACTOR_SUPPORT_ROD_ROTATES.setRotationPoint(0.0F, 10.0F, 0.0F); + this.REACTOR_SUPPORT_ROD_ROTATES.setTextureSize(128, 128); + this.REACTOR_SUPPORT_ROD_ROTATES.mirror = true; + this.setRotation(this.REACTOR_SUPPORT_ROD_ROTATES, 0.0F, 0.0F, 0.0F); + this.SUPPORT_PLATE_1_ROTATES = new ModelRenderer(this, 9, 57); + this.SUPPORT_PLATE_1_ROTATES.addBox(-3.0F, 0.0F, -3.0F, 6, 1, 6); + this.SUPPORT_PLATE_1_ROTATES.setRotationPoint(0.0F, 19.0F, 0.0F); + this.SUPPORT_PLATE_1_ROTATES.setTextureSize(128, 128); + this.SUPPORT_PLATE_1_ROTATES.mirror = true; + this.setRotation(this.SUPPORT_PLATE_1_ROTATES, 0.0F, 0.7853982F, 0.0F); + this.SUPPORT_PLATE_2_ROTATES = new ModelRenderer(this, 9, 57); + this.SUPPORT_PLATE_2_ROTATES.addBox(-3.0F, 0.0F, -3.0F, 6, 1, 6); + this.SUPPORT_PLATE_2_ROTATES.setRotationPoint(0.0F, 13.0F, 0.0F); + this.SUPPORT_PLATE_2_ROTATES.setTextureSize(128, 128); + this.SUPPORT_PLATE_2_ROTATES.mirror = true; + this.setRotation(this.SUPPORT_PLATE_2_ROTATES, 0.0F, 0.7853982F, 0.0F); + this.FUEL_BAR_1_ROTATES = new ModelRenderer(this, 0, 54); + this.FUEL_BAR_1_ROTATES.addBox(-1.0F, 0.0F, 2.0F, 2, 9, 2); + this.FUEL_BAR_1_ROTATES.setRotationPoint(0.0F, 12.0F, 0.0F); + this.FUEL_BAR_1_ROTATES.setTextureSize(128, 128); + this.FUEL_BAR_1_ROTATES.mirror = true; + this.setRotation(this.FUEL_BAR_1_ROTATES, 0.0F, 0.0F, 0.0F); + this.FUEL_BAR_2_ROTATES = new ModelRenderer(this, 0, 54); + this.FUEL_BAR_2_ROTATES.addBox(2.0F, 0.0F, -1.0F, 2, 9, 2); + this.FUEL_BAR_2_ROTATES.setRotationPoint(0.0F, 12.0F, 0.0F); + this.FUEL_BAR_2_ROTATES.setTextureSize(128, 128); + this.FUEL_BAR_2_ROTATES.mirror = true; + this.setRotation(this.FUEL_BAR_2_ROTATES, 0.0F, 0.0F, 0.0F); + this.FUEL_BAR_3_ROTATES = new ModelRenderer(this, 0, 54); + this.FUEL_BAR_3_ROTATES.addBox(-1.0F, 0.0F, -4.0F, 2, 9, 2); + this.FUEL_BAR_3_ROTATES.setRotationPoint(0.0F, 12.0F, 0.0F); + this.FUEL_BAR_3_ROTATES.setTextureSize(128, 128); + this.FUEL_BAR_3_ROTATES.mirror = true; + this.setRotation(this.FUEL_BAR_3_ROTATES, 0.0F, 0.0F, 0.0F); + this.FUEL_BAR_4_ROTATES = new ModelRenderer(this, 0, 54); + this.FUEL_BAR_4_ROTATES.addBox(-4.0F, 0.0F, -1.0F, 2, 9, 2); + this.FUEL_BAR_4_ROTATES.setRotationPoint(0.0F, 12.0F, 0.0F); + this.FUEL_BAR_4_ROTATES.setTextureSize(128, 128); + this.FUEL_BAR_4_ROTATES.mirror = true; + this.setRotation(this.FUEL_BAR_4_ROTATES, 0.0F, 0.0F, 0.0F); + this.CONVERTER = new ModelRenderer(this, 35, 56); + this.CONVERTER.addBox(0.0F, 0.0F, 0.0F, 7, 10, 1); + this.CONVERTER.setRotationPoint(-1.0F, 13.0F, 6.0F); + this.CONVERTER.setTextureSize(128, 128); + this.CONVERTER.mirror = true; + this.setRotation(this.CONVERTER, 0.0F, 0.296706F, 0.0F); + this.SUB_SHIELD_1 = new ModelRenderer(this, 53, 37); + this.SUB_SHIELD_1.addBox(0.0F, 0.0F, 0.0F, 1, 4, 4); + this.SUB_SHIELD_1.setRotationPoint(8.0F, 19.0F, -5.0F); + this.SUB_SHIELD_1.setTextureSize(128, 128); + this.SUB_SHIELD_1.mirror = true; + this.setRotation(this.SUB_SHIELD_1, 0.0F, -2.094395F, 0.0F); + this.SUB_SHIELD_2 = new ModelRenderer(this, 30, 37); + this.SUB_SHIELD_2.addBox(0.0F, 0.0F, 0.0F, 1, 4, 10); + this.SUB_SHIELD_2.setRotationPoint(7.0F, 19.0F, -5.0F); + this.SUB_SHIELD_2.setTextureSize(128, 128); + this.SUB_SHIELD_2.mirror = true; + this.setRotation(this.SUB_SHIELD_2, 0.0F, 0.0F, 0.0F); + this.Shape1 = new ModelRenderer(this, 10, 65); + this.Shape1.addBox(0.0F, 0.0F, 0.0F, 5, 2, 5); + this.Shape1.setRotationPoint(-7.0F, 22.0F, -7.0F); + this.Shape1.setTextureSize(128, 128); + this.Shape1.mirror = true; + this.setRotation(this.Shape1, 0.1745329F, 0.0F, 0.0F); + } + + public void render(float rotation, float f5) { + this.BASE.render(f5); + this.SHIELD_1.render(f5); + this.SHIELD_2.render(f5); + this.SHIELD_3.render(f5); + this.SHIELD_4.render(f5); + this.REACTOR_SUPPORT_ROD_ROTATES.rotateAngleY = rotation; + this.REACTOR_SUPPORT_ROD_ROTATES.render(f5); + this.SUPPORT_PLATE_1_ROTATES.rotateAngleY = rotation; + this.SUPPORT_PLATE_1_ROTATES.render(f5); + this.SUPPORT_PLATE_2_ROTATES.rotateAngleY = rotation; + this.SUPPORT_PLATE_2_ROTATES.render(f5); + this.FUEL_BAR_1_ROTATES.rotateAngleY = rotation; + this.FUEL_BAR_1_ROTATES.render(f5); + this.FUEL_BAR_2_ROTATES.rotateAngleY = rotation; + this.FUEL_BAR_2_ROTATES.render(f5); + this.FUEL_BAR_3_ROTATES.rotateAngleY = rotation; + this.FUEL_BAR_3_ROTATES.render(f5); + this.FUEL_BAR_4_ROTATES.rotateAngleY = rotation; + this.FUEL_BAR_4_ROTATES.render(f5); + this.CONVERTER.render(f5); + this.SUB_SHIELD_1.render(f5); + this.SUB_SHIELD_2.render(f5); + this.Shape1.render(f5); + } + + private void setRotation(ModelRenderer model, float x, float y, float z) { + model.rotateAngleX = x; + model.rotateAngleY = y; + model.rotateAngleZ = z; + } +} diff --git a/src/main/java/atomicscience/render/RAtomicAssembler.java b/src/main/java/atomicscience/render/RAtomicAssembler.java new file mode 100644 index 0000000..9de20e9 --- /dev/null +++ b/src/main/java/atomicscience/render/RAtomicAssembler.java @@ -0,0 +1,44 @@ +package atomicscience.render; + +import atomicscience.TAtomicAssembler; +import atomicscience.muoxing.MAtomicAssembler; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import net.minecraft.client.renderer.entity.RenderItem; +import net.minecraft.client.renderer.entity.RenderManager; +import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer; +import net.minecraft.entity.item.EntityItem; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.ResourceLocation; + +import org.lwjgl.opengl.GL11; + +@SideOnly(Side.CLIENT) +public class RAtomicAssembler extends TileEntitySpecialRenderer { + + public static final MAtomicAssembler MODEL = new MAtomicAssembler(); + public static final String TEXTURE = "atomic_assembler.png"; + //private final RenderBlocks renderBlocks = new RenderBlocks(); + + public void renderModelAt(TAtomicAssembler tileEntity, double x, double y, double z, float f) { + GL11.glPushMatrix(); + GL11.glTranslatef((float)x + 0.5F, (float)y + 1.5F, (float)z + 0.5F); + this.bindTexture(new ResourceLocation("atomicscience", "textures/models/atomic_assembler.png")); + GL11.glRotatef(180.0F, 0.0F, 0.0F, 1.0F); + MODEL.render(tileEntity.rotationYaw1, tileEntity.rotationYaw2, tileEntity.rotationYaw3, 0.0625F); + GL11.glPopMatrix(); + RenderItem renderItem = (RenderItem)RenderManager.instance.getEntityClassRenderObject(EntityItem.class); + //RenderEngine renderEngine = Minecraft.getMinecraft().renderEngine; + GL11.glPushMatrix(); + if(tileEntity.entityItem != null) { + renderItem.doRender(tileEntity.entityItem, x + 0.5D, y + 0.4D, z + 0.5D, 0.0F, 0.0F); + } + + GL11.glPopMatrix(); + } + + @Override + public void renderTileEntityAt(TileEntity tileEntity, double var2, double var4, double var6, float var8) { + this.renderModelAt((TAtomicAssembler)tileEntity, var2, var4, var6, var8); + } +} diff --git a/src/main/java/atomicscience/render/RCentrifuge.java b/src/main/java/atomicscience/render/RCentrifuge.java new file mode 100644 index 0000000..6256624 --- /dev/null +++ b/src/main/java/atomicscience/render/RCentrifuge.java @@ -0,0 +1,51 @@ +package atomicscience.render; + +import atomicscience.fenlie.TCentrifuge; +import atomicscience.muoxing.MCentrifuge; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.ResourceLocation; + +import org.lwjgl.opengl.GL11; + +@SideOnly(Side.CLIENT) +public class RCentrifuge extends TileEntitySpecialRenderer { + public static final MCentrifuge MODEL = new MCentrifuge(); + public static final String TEXTURE = "centrifuge.png"; + + + public void renderAModelAt(TCentrifuge tileEntity, double x, double y, double z, float f) { + GL11.glPushMatrix(); + GL11.glTranslatef((float)x + 0.5F, (float)y + 1.5F, (float)z + 0.5F); + this.bindTexture(new ResourceLocation("atomicscience", "textures/models/centrifuge.png")); + GL11.glRotatef(180.0F, 0.0F, 0.0F, 1.0F); + int facingDirection = tileEntity.getBlockMetadata(); + switch(facingDirection) { + case 2: + GL11.glRotatef(180.0F, 0.0F, 1.0F, 0.0F); + break; + case 3: + GL11.glRotatef(0.0F, 0.0F, 1.0F, 0.0F); + break; + case 4: + GL11.glRotatef(90.0F, 0.0F, 1.0F, 0.0F); + break; + case 5: + GL11.glRotatef(-90.0F, 0.0F, 1.0F, 0.0F); + } + + if(tileEntity.smeltingTicks > 0) { + tileEntity.xuanZhuan = (float)((double)tileEntity.xuanZhuan + (double)f * 0.3D); + } + + MODEL.render(tileEntity.xuanZhuan, 0.0625F); + GL11.glPopMatrix(); + } + + public void renderTileEntityAt(TileEntity tileEntity, double var2, double var4, double var6, float var8) { + this.renderAModelAt((TCentrifuge)tileEntity, var2, var4, var6, var8); + } + +} diff --git a/src/main/java/atomicscience/render/RExtractor.java b/src/main/java/atomicscience/render/RExtractor.java new file mode 100644 index 0000000..e9147c0 --- /dev/null +++ b/src/main/java/atomicscience/render/RExtractor.java @@ -0,0 +1,50 @@ +package atomicscience.render; + +import atomicscience.jiqi.TChemicalExtractor; +import atomicscience.muoxing.MExtractor; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.ResourceLocation; +import org.lwjgl.opengl.GL11; + +@SideOnly(Side.CLIENT) +public class RExtractor extends TileEntitySpecialRenderer { + public static final MExtractor MODEL = new MExtractor(); + public static final String TEXTURE = "extractor.png"; + + @Override + public void renderTileEntityAt(TileEntity tileEntity, double x, double y, + double z, float f) { + TChemicalExtractor te = (TChemicalExtractor)tileEntity; + GL11.glPushMatrix(); + GL11.glTranslatef((float)x + 0.5F, (float)y + 1.5F, (float)z + 0.5F); + this.bindTexture( + new ResourceLocation("atomicscience", "textures/models/extractor.png")); + GL11.glRotatef(180.0F, 0.0F, 0.0F, 1.0F); + switch ( + te.getDirection(te.getWorldObj(), te.xCoord, te.yCoord, te.zCoord)) { + case NORTH: + GL11.glRotatef(90.0F, 0.0F, 1.0F, 0.0F); + break; + case SOUTH: + GL11.glRotatef(-90.0F, 0.0F, 1.0F, 0.0F); + break; + case WEST: + GL11.glRotatef(0.0F, 0.0F, 1.0F, 0.0F); + break; + case EAST: + GL11.glRotatef(180.0F, 0.0F, 1.0F, 0.0F); + default: + break; + } + + if (te.smeltingTicks > 0) { + te.rotation = (float)((double)te.rotation + (double)f * 0.3D); + } + + MODEL.render(te.rotation, 0.0625F); + GL11.glPopMatrix(); + } +} diff --git a/src/main/java/atomicscience/render/RFusionReactor.java b/src/main/java/atomicscience/render/RFusionReactor.java new file mode 100644 index 0000000..2713e7b --- /dev/null +++ b/src/main/java/atomicscience/render/RFusionReactor.java @@ -0,0 +1,36 @@ +package atomicscience.render; + +import atomicscience.hecheng.TFusionReactor; +import atomicscience.muoxing.MFusionReactor; +import calclavia.lib.render.RenderTaggedTile; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.ResourceLocation; + +import org.lwjgl.opengl.GL11; + +@SideOnly(Side.CLIENT) +public class RFusionReactor extends RenderTaggedTile { + + public static final MFusionReactor MODEL = new MFusionReactor(); + public static final String TEXTURE = "fusion_reactor.png"; + + + public void renderTileEntityAt(TileEntity t, double x, double y, double z, float f) { + super.renderTileEntityAt(t, x, y, z, f); + TFusionReactor tileEntity = (TFusionReactor)t; + GL11.glPushMatrix(); + GL11.glTranslatef((float)x + 0.5F, (float)y + 1.5F, (float)z + 0.5F); + this.bindTexture(new ResourceLocation("atomicscience", "textures/models/fusion_reactor.png")); + GL11.glRotatef(180.0F, 0.0F, 0.0F, 1.0F); + MODEL.render((float)Math.toRadians((double)tileEntity.rotation), 0.0625F); + tileEntity.rotation = (float)((double)tileEntity.rotation + tileEntity.wattsReceived / 500.0D); + if(tileEntity.rotation > 360.0F) { + tileEntity.rotation = 0.0F; + } + + GL11.glPopMatrix(); + } + +} diff --git a/src/main/java/atomicscience/render/RH.java b/src/main/java/atomicscience/render/RH.java new file mode 100644 index 0000000..50fc133 --- /dev/null +++ b/src/main/java/atomicscience/render/RH.java @@ -0,0 +1,74 @@ +package atomicscience.render; + +import atomicscience.AtomicScience; +import cpw.mods.fml.client.FMLClientHandler; +import cpw.mods.fml.client.registry.ISimpleBlockRenderingHandler; +import cpw.mods.fml.client.registry.RenderingRegistry; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import net.minecraft.block.Block; +import net.minecraft.client.renderer.RenderBlocks; +import net.minecraft.util.ResourceLocation; +import net.minecraft.world.IBlockAccess; +import org.lwjgl.opengl.GL11; + +@SideOnly(Side.CLIENT) +public class RH implements ISimpleBlockRenderingHandler { + + public static final int BLOCK_RENDER_ID = + RenderingRegistry.getNextAvailableRenderId(); + + public void renderInventoryBlock(Block block, int metadata, int modelID, + RenderBlocks renderer) { + GL11.glPushMatrix(); + GL11.glTranslatef(0.0F, 1.1F, 0.0F); + GL11.glRotatef(180.0F, 0.0F, 0.0F, 1.0F); + if (block == AtomicScience.bTurbine) { + FMLClientHandler.instance().getClient().renderEngine.bindTexture( + new ResourceLocation("atomicscience", "textures/models/turbine.png")); + RTurbine.MODEL.render(0.0F, 0.0625F); + } else if (block == AtomicScience.bCentrifuge) { + FMLClientHandler.instance().getClient().renderEngine.bindTexture( + new ResourceLocation("atomicscience", + "textures/models/centrifuge.png")); + RCentrifuge.MODEL.render(0.0F, 0.0625F); + } else if (block == AtomicScience.bChemicalExtractor) { + FMLClientHandler.instance().getClient().renderEngine.bindTexture( + new ResourceLocation("atomicscience", + "textures/models/extractor.png")); + RExtractor.MODEL.render(0.0F, 0.0625F); + } else if (block == AtomicScience.bNuclearBoiler) { + FMLClientHandler.instance().getClient().renderEngine.bindTexture( + new ResourceLocation("atomicscience", + "textures/models/expansion.png")); + RNuclearBoiler.MODEL.render(0.0F, 0.0625F); + } else if (block == AtomicScience.bFusionReactor) { + FMLClientHandler.instance().getClient().renderEngine.bindTexture( + new ResourceLocation("atomicscience", + "textures/models/fusion_reactor.png")); + RFusionReactor.MODEL.render(0.0F, 0.0625F); + } else if (block == AtomicScience.bAtomicAssembler) { + FMLClientHandler.instance().getClient().renderEngine.bindTexture( + new ResourceLocation("atomicscience", + "textures/models/atomic_assembler.png")); + RAtomicAssembler.MODEL.render(0.0F, 0.0F, 0.0F, 0.0625F); + } else if (block == AtomicScience.bFissionReactor) { + FMLClientHandler.instance().getClient().renderEngine.bindTexture( + new ResourceLocation("atomicscience", + "textures/models/reactorCell_top.png")); + RReactorCell.MODEL_TOP.render(0.0625F); + } + + GL11.glPopMatrix(); + } + + public boolean shouldRender3DInInventory(int meta) { return true; } + + public int getRenderId() { return BLOCK_RENDER_ID; } + + public boolean renderWorldBlock(IBlockAccess world, int x, int y, int z, + Block block, int modelId, + RenderBlocks renderer) { + return false; + } +} diff --git a/src/main/java/atomicscience/render/RMatter.java b/src/main/java/atomicscience/render/RMatter.java new file mode 100644 index 0000000..ae02d15 --- /dev/null +++ b/src/main/java/atomicscience/render/RMatter.java @@ -0,0 +1,87 @@ +package atomicscience.render; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import java.util.Random; +import net.minecraft.client.renderer.RenderHelper; +import net.minecraft.client.renderer.Tessellator; +import net.minecraft.client.renderer.entity.Render; +import net.minecraft.entity.Entity; +import net.minecraft.util.ResourceLocation; +import org.lwjgl.opengl.GL11; + +@SideOnly(Side.CLIENT) +public class RMatter extends Render { + @Override + public void doRender(Entity entity, double x, double y, double z, float var8, + float var9) { + Tessellator tessellator = Tessellator.instance; + + float par2; + for (par2 = (float)entity.ticksExisted; par2 > 200.0F; par2 -= 100.0F) { + ; + } + + RenderHelper.disableStandardItemLighting(); + float var41 = (5.0F + par2) / 200.0F; + float var51 = 0.0F; + if (var41 > 0.8F) { + var51 = (var41 - 0.8F) / 0.2F; + } + + Random rand = new Random(432L); + GL11.glPushMatrix(); + GL11.glTranslatef((float)x + 0.15F, (float)y + 0.15F, (float)z + 0.15F); + GL11.glScalef(0.15F, 0.15F, 0.15F); + GL11.glDisable(3553); + GL11.glShadeModel(7425); + GL11.glEnable(3042); + GL11.glBlendFunc(770, 1); + GL11.glDisable(3008); + GL11.glEnable(2884); + GL11.glDepthMask(false); + GL11.glPushMatrix(); + GL11.glTranslatef(0.0F, -1.0F, -2.0F); + + for (int i1 = 0; (float)i1 < (var41 + var41 * var41) / 2.0F * 60.0F; ++i1) { + GL11.glRotatef(rand.nextFloat() * 360.0F, 1.0F, 0.0F, 0.0F); + GL11.glRotatef(rand.nextFloat() * 360.0F, 0.0F, 1.0F, 0.0F); + GL11.glRotatef(rand.nextFloat() * 360.0F, 0.0F, 0.0F, 1.0F); + GL11.glRotatef(rand.nextFloat() * 360.0F, 1.0F, 0.0F, 0.0F); + GL11.glRotatef(rand.nextFloat() * 360.0F, 0.0F, 1.0F, 0.0F); + GL11.glRotatef(rand.nextFloat() * 360.0F + var41 * 90.0F, 0.0F, 0.0F, + 1.0F); + tessellator.startDrawing(6); + float var81 = rand.nextFloat() * 20.0F + 5.0F + var51 * 10.0F; + float var91 = rand.nextFloat() * 2.0F + 1.0F + var51 * 2.0F; + tessellator.setColorRGBA_I(16777215, (int)(255.0F * (1.0F - var51))); + tessellator.addVertex(0.0D, 0.0D, 0.0D); + tessellator.setColorRGBA_I(0, 0); + tessellator.addVertex(-0.866D * (double)var91, (double)var81, + (double)(-0.5F * var91)); + tessellator.addVertex(0.866D * (double)var91, (double)var81, + (double)(-0.5F * var91)); + tessellator.addVertex(0.0D, (double)var81, (double)(1.0F * var91)); + tessellator.addVertex(-0.866D * (double)var91, (double)var81, + (double)(-0.5F * var91)); + tessellator.draw(); + } + + GL11.glPopMatrix(); + GL11.glDepthMask(true); + GL11.glDisable(2884); + GL11.glDisable(3042); + GL11.glShadeModel(7424); + GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F); + GL11.glEnable(3553); + GL11.glEnable(3008); + RenderHelper.enableStandardItemLighting(); + GL11.glPopMatrix(); + } + + // TODO: NPE? + @Override + protected ResourceLocation getEntityTexture(Entity arg0) { + return null; + } +} diff --git a/src/main/java/atomicscience/render/RNuclearBoiler.java b/src/main/java/atomicscience/render/RNuclearBoiler.java new file mode 100644 index 0000000..039b214 --- /dev/null +++ b/src/main/java/atomicscience/render/RNuclearBoiler.java @@ -0,0 +1,56 @@ +package atomicscience.render; + +import atomicscience.fenlie.TNuclearBoiler; +import atomicscience.muoxing.MNuclearBoiler; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.ResourceLocation; +import org.lwjgl.opengl.GL11; + +@SideOnly(Side.CLIENT) +public class RNuclearBoiler extends TileEntitySpecialRenderer { + public static final MNuclearBoiler MODEL = new MNuclearBoiler(); + public static final String TEXTURE = "expansion.png"; + + public void renderAModelAt(TNuclearBoiler tileEntity, double x, double y, + double z, float f) { + GL11.glPushMatrix(); + GL11.glTranslatef((float)x + 0.5F, (float)y + 1.5F, (float)z + 0.5F); + this.bindTexture( + new ResourceLocation("atomicscience", "textures/models/expansion.png")); + GL11.glRotatef(180.0F, 0.0F, 0.0F, 1.0F); + GL11.glRotatef(-90.0F, 0.0F, 1.0F, 0.0F); + switch (tileEntity.getDirection(tileEntity.getWorldObj(), tileEntity.xCoord, + tileEntity.yCoord, tileEntity.zCoord)) { + case NORTH: + GL11.glRotatef(90.0F, 0.0F, 1.0F, 0.0F); + break; + case SOUTH: + GL11.glRotatef(-90.0F, 0.0F, 1.0F, 0.0F); + break; + case WEST: + GL11.glRotatef(0.0F, 0.0F, 1.0F, 0.0F); + break; + case EAST: + GL11.glRotatef(180.0F, 0.0F, 1.0F, 0.0F); + default: + break; + } + + if (tileEntity.smeltingTicks > 0) { + tileEntity.rotation = + (float)((double)tileEntity.rotation + (double)f * 0.3D); + } + + MODEL.render(tileEntity.rotation, 0.0625F); + GL11.glPopMatrix(); + } + + @Override + public void renderTileEntityAt(TileEntity tileEntity, double var2, double var4, + double var6, float var8) { + this.renderAModelAt((TNuclearBoiler)tileEntity, var2, var4, var6, var8); + } +} diff --git a/src/main/java/atomicscience/render/RReactorCell.java b/src/main/java/atomicscience/render/RReactorCell.java new file mode 100644 index 0000000..08251b0 --- /dev/null +++ b/src/main/java/atomicscience/render/RReactorCell.java @@ -0,0 +1,67 @@ +package atomicscience.render; + +import atomicscience.fenlie.TFissionReactor; +import atomicscience.muoxing.MCube; +import atomicscience.muoxing.MReactorCellBottom; +import atomicscience.muoxing.MReactorCellMiddle; +import atomicscience.muoxing.MReactorCellTop; +import calclavia.lib.render.RenderTaggedTile; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.ResourceLocation; +import org.lwjgl.opengl.GL11; + +@SideOnly(Side.CLIENT) +public class RReactorCell extends RenderTaggedTile { + public static final MReactorCellTop MODEL_TOP = new MReactorCellTop(); + public static final MReactorCellMiddle MODEL_MIDDLE = + new MReactorCellMiddle(); + public static final MReactorCellBottom MODEL_BOTTOM = + new MReactorCellBottom(); + public static final String TEXTURE_TOP = "reactorCell_top.png"; + public static final String TEXTURE_MIDDLE = "reactorCell_middle.png"; + public static final String TEXTURE_BOTTOM = "reactorCell_bottom.png"; + + public void renderTileEntityAt(TileEntity t, double x, double y, double z, + float f) { + TFissionReactor tileEntity = (TFissionReactor)t; + GL11.glPushMatrix(); + GL11.glTranslatef((float)x + 0.5F, (float)y + 1.5F, (float)z + 0.5F); + GL11.glRotatef(180.0F, 0.0F, 0.0F, 1.0F); + switch (tileEntity.getBlockMetadata()) { + case 0: + this.bindTexture(new ResourceLocation( + "atomicscience", "textures/models/reactorCell_bottom.png")); + MODEL_BOTTOM.render(0.0625F); + break; + case 1: + this.bindTexture(new ResourceLocation( + "atomicscience", "textures/models/reactorCell_middle.png")); + MODEL_MIDDLE.render(0.0625F); + break; + case 2: + GL11.glTranslatef(0.0F, -0.4F, 0.0F); + GL11.glScalef(1.0F, 1.3F, 1.0F); + this.bindTexture(new ResourceLocation( + "atomicscience", "textures/models/reactorCell_top.png")); + MODEL_TOP.render(0.0625F); + } + + GL11.glPopMatrix(); + if (tileEntity.getStackInSlot(0) != null) { + float height = (float)tileEntity.getHeight() * + ((float)(tileEntity.getStackInSlot(0).getMaxDamage() - + tileEntity.getStackInSlot(0).getItemDamage()) / + (float)tileEntity.getStackInSlot(0).getMaxDamage()); + GL11.glPushMatrix(); + GL11.glTranslatef((float)x + 0.5F, (float)y + 0.5F * height, + (float)z + 0.5F); + GL11.glScalef(0.4F, 1.0F * height, 0.4F); + this.bindTexture(new ResourceLocation( + "atomicscience", "textures/models/fissileMaterial.png")); + MCube.INSTNACE.render(); + GL11.glPopMatrix(); + } + } +} diff --git a/src/main/java/atomicscience/render/RThermometer.java b/src/main/java/atomicscience/render/RThermometer.java new file mode 100644 index 0000000..e0ee0ff --- /dev/null +++ b/src/main/java/atomicscience/render/RThermometer.java @@ -0,0 +1,101 @@ +package atomicscience.render; + +import atomicscience.api.ITemperature; +import atomicscience.jiqi.TThermometer; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import net.minecraft.client.gui.FontRenderer; +import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer; +import net.minecraft.tileentity.TileEntity; +import org.lwjgl.opengl.GL11; + +@SideOnly(Side.CLIENT) +public class RThermometer extends TileEntitySpecialRenderer { + public void renderTileEntityAt(TileEntity var1, double x, double y, double z, + float var8) { + TThermometer tileEntity = (TThermometer)var1; + + for (int side = 2; side < 6; ++side) { + GL11.glPushMatrix(); + GL11.glPolygonOffset(-10.0F, -10.0F); + GL11.glEnable('\u8037'); + float dx = 0.0625F; + float dz = 0.0625F; + float displayWidth = 0.875F; + float displayHeight = 0.875F; + GL11.glTranslatef((float)x, (float)y, (float)z); + switch (side) { + case 0: + GL11.glTranslatef(1.0F, 1.0F, 0.0F); + GL11.glRotatef(180.0F, 1.0F, 0.0F, 0.0F); + GL11.glRotatef(180.0F, 0.0F, 1.0F, 0.0F); + case 1: + default: + break; + case 2: + GL11.glTranslatef(1.0F, 1.0F, 1.0F); + GL11.glRotatef(180.0F, 0.0F, 1.0F, 0.0F); + GL11.glRotatef(90.0F, 1.0F, 0.0F, 0.0F); + break; + case 3: + GL11.glTranslatef(0.0F, 1.0F, 0.0F); + GL11.glRotatef(0.0F, 0.0F, 1.0F, 0.0F); + GL11.glRotatef(90.0F, 1.0F, 0.0F, 0.0F); + break; + case 4: + GL11.glTranslatef(1.0F, 1.0F, 0.0F); + GL11.glRotatef(-90.0F, 0.0F, 1.0F, 0.0F); + GL11.glRotatef(90.0F, 1.0F, 0.0F, 0.0F); + break; + case 5: + GL11.glTranslatef(0.0F, 1.0F, 1.0F); + GL11.glRotatef(90.0F, 0.0F, 1.0F, 0.0F); + GL11.glRotatef(90.0F, 1.0F, 0.0F, 0.0F); + } + + GL11.glTranslatef(dx + displayWidth / 2.0F, 1.0F, + dz + displayHeight / 2.0F); + GL11.glRotatef(-90.0F, 1.0F, 0.0F, 0.0F); + GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F); + FontRenderer fontRenderer = this.func_147498_b(); + byte maxWidth = 1; + String wenDu = Math.round(tileEntity.temp) + " C"; + if (tileEntity.shouldEmitRedstone()) { + wenDu = "§4" + wenDu; + } + + String zhuYiWenDu = "Warn: " + tileEntity.getWarningTemp(); + if (tileEntity.linkedTileCoords != null && + tileEntity.linkedTileCoords.getTileEntity(tileEntity.getWorldObj()) + instanceof ITemperature) { + zhuYiWenDu = "§4" + zhuYiWenDu; + } + + int var28 = Math.max(fontRenderer.getStringWidth(wenDu), maxWidth); + var28 = Math.max(fontRenderer.getStringWidth(zhuYiWenDu), var28); + var28 += 4; + int lineHeight = fontRenderer.FONT_HEIGHT + 2; + int requiredHeight = lineHeight * 1; + float scaleX = displayWidth / (float)var28; + float scaleY = displayHeight / (float)requiredHeight; + float scale = (float)((double)Math.min(scaleX, scaleY) * 0.8D); + GL11.glScalef(scale, -scale, scale); + GL11.glDepthMask(false); + int realHeight = (int)Math.floor((double)(displayHeight / scale)); + int realWidth = (int)Math.floor((double)(displayWidth / scale)); + int offsetX = (realWidth - var28) / 2 + 2; + int offsetY = (realHeight - requiredHeight) / 2; + GL11.glDisable(2896); + fontRenderer.drawString(wenDu, offsetX - realWidth / 2, + 1 + offsetY - realHeight / 2 + 0 * lineHeight, 1); + fontRenderer.drawString(zhuYiWenDu, offsetX - realWidth / 2, + 1 + offsetY - realHeight / 2 + 1 * lineHeight, 1); + GL11.glEnable(2896); + GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F); + GL11.glDepthMask(true); + GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F); + GL11.glDisable('\u8037'); + GL11.glPopMatrix(); + } + } +} diff --git a/src/main/java/atomicscience/render/RTurbine.java b/src/main/java/atomicscience/render/RTurbine.java new file mode 100644 index 0000000..9dd2457 --- /dev/null +++ b/src/main/java/atomicscience/render/RTurbine.java @@ -0,0 +1,47 @@ +package atomicscience.render; + +import atomicscience.jiqi.TTurbine; +import atomicscience.muoxing.MLargeTurbine; +import atomicscience.muoxing.MTurbine; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.ResourceLocation; + +import org.lwjgl.opengl.GL11; + +@SideOnly(Side.CLIENT) +public class RTurbine extends TileEntitySpecialRenderer { + public static final MTurbine MODEL = new MTurbine(); + public static final MLargeTurbine DA_MODEL = new MLargeTurbine(); + public static final String TEXTURE = "turbine.png"; + public static final String DA_TEXTURE = "large_turbine.png"; + + + public void renderAModelAt(TTurbine tileEntity, double x, double y, double z, float f) { + if(!tileEntity.hasMaster()) { + GL11.glPushMatrix(); + GL11.glTranslatef((float)x + 0.5F, (float)y + 1.5F, (float)z + 0.5F); + GL11.glRotatef(180.0F, 0.0F, 0.0F, 1.0F); + if(tileEntity.isMultiblock) { + GL11.glScalef(0.9F, 1.0F, 1.0F); + this.bindTexture(new ResourceLocation("atomicscience", "textures/models/large_turbine.png")); + DA_MODEL.render(tileEntity.rotation, 0.0625F); + } else { + GL11.glScalef(1.0F, 1.1F, 1.0F); + this.bindTexture(new ResourceLocation("atomicscience", "textures/models/turbine.png")); + MODEL.render((float)Math.toRadians((double)tileEntity.rotation), 0.0625F); + } + + GL11.glPopMatrix(); + } + + } + + @Override + public void renderTileEntityAt(TileEntity tileEntity, double var2, double var4, double var6, float var8) { + this.renderAModelAt((TTurbine)tileEntity, var2, var4, var6, var8); + } + +} diff --git a/src/main/java/atomicscience/shimian/CFissionReactor.java b/src/main/java/atomicscience/shimian/CFissionReactor.java new file mode 100644 index 0000000..5b382f0 --- /dev/null +++ b/src/main/java/atomicscience/shimian/CFissionReactor.java @@ -0,0 +1,56 @@ +package atomicscience.shimian; + +import atomicscience.fenlie.TFissionReactor; +import atomicscience.wujian.ItFissileFuel; +import calclavia.lib.gui.ContainerBase; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.inventory.Slot; +import net.minecraft.item.ItemStack; +import universalelectricity.prefab.SlotSpecific; + +public class CFissionReactor extends ContainerBase { + public CFissionReactor(EntityPlayer player, TFissionReactor tileEntity) { + super(tileEntity); + this.addPlayerInventory(player); + this.addSlotToContainer(new SlotSpecific(tileEntity, 0, 79, 21, new Class[]{ItFissileFuel.class})); + } + + @Override + public ItemStack transferStackInSlot(EntityPlayer par1EntityPlayer, int par1) { + ItemStack var2 = null; + Slot var3 = (Slot)super.inventorySlots.get(par1); + if(var3 != null && var3.getHasStack()) { + ItemStack itemStack = var3.getStack(); + var2 = itemStack.copy(); + if(par1 >= super.slotCount) { + if(this.getSlot(0).isItemValid(itemStack)) { + if(!this.mergeItemStack(itemStack, 0, 1, false)) { + return null; + } + } else if(par1 < 27 + super.slotCount) { + if(!this.mergeItemStack(itemStack, 27 + super.slotCount, 36 + super.slotCount, false)) { + return null; + } + } else if(par1 >= 27 + super.slotCount && par1 < 36 + super.slotCount && !this.mergeItemStack(itemStack, 4, 30, false)) { + return null; + } + } else if(!this.mergeItemStack(itemStack, super.slotCount, 36 + super.slotCount, false)) { + return null; + } + + if(itemStack.stackSize == 0) { + var3.putStack((ItemStack)null); + } else { + var3.onSlotChanged(); + } + + if(itemStack.stackSize == var2.stackSize) { + return null; + } + + var3.onPickupFromSlot(par1EntityPlayer, itemStack); + } + + return var2; + } +} diff --git a/src/main/java/atomicscience/shimian/GAccelerator.java b/src/main/java/atomicscience/shimian/GAccelerator.java new file mode 100644 index 0000000..730f4af --- /dev/null +++ b/src/main/java/atomicscience/shimian/GAccelerator.java @@ -0,0 +1,89 @@ +package atomicscience.shimian; + +import atomicscience.fanwusu.CAccelerator; +import atomicscience.fanwusu.EMatter; +import atomicscience.fanwusu.TAccelerator; +import net.minecraft.client.gui.inventory.GuiContainer; +import net.minecraft.entity.player.InventoryPlayer; +import net.minecraft.util.ResourceLocation; +import org.lwjgl.opengl.GL11; +import universalelectricity.core.electricity.ElectricityDisplay; +import universalelectricity.core.vector.Vector3; + +public class GAccelerator extends GuiContainer { + private TAccelerator tileEntity; + private int containerWidth; + private int containerHeight; + + public GAccelerator(InventoryPlayer par1InventoryPlayer, + TAccelerator tileEntity) { + super(new CAccelerator(par1InventoryPlayer, tileEntity)); + this.tileEntity = tileEntity; + } + + @Override + public void drawGuiContainerForegroundLayer(int par1, int par2) { + this.fontRendererObj.drawString(this.tileEntity.getInventoryName(), 40, 10, + 4210752); + String status = ""; + Vector3 position = new Vector3(this.tileEntity); + position.modifyPositionFromSide( + this.tileEntity + .getDirection(this.tileEntity.getWorldObj(), this.tileEntity.xCoord, + this.tileEntity.xCoord, this.tileEntity.zCoord) + .getOpposite()); + if (this.tileEntity.isDisabled()) { + status = "Disabled"; + } else if (!EMatter.canCunZai( + this.tileEntity.getWorldObj(), position, + this.tileEntity + .getDirection(this.tileEntity.getWorldObj(), + this.tileEntity.xCoord, + this.tileEntity.yCoord, + this.tileEntity.zCoord) + .getOpposite())) { + status = "Failure"; + } else if (this.tileEntity.wuSu != null && this.tileEntity.suDu > 0.0F) { + status = "Accelerating"; + } else { + status = "Idle"; + } + + this.fontRendererObj.drawString( + "Velocity: " + Math.round(this.tileEntity.suDu / 1.0F * 100.0F) + "%", + 8, 27, 4210752); + this.fontRendererObj.drawString("Status: " + status, 8, 38, 4210752); + this.fontRendererObj.drawString( + "Used: " + ElectricityDisplay.getDisplayShort( + this.tileEntity.yongDianLiang, + ElectricityDisplay.ElectricUnit.JOULES), + 8, 49, 4210752); + StringBuilder var10001 = new StringBuilder(); + this.tileEntity.getClass(); + this.fontRendererObj.drawString( + var10001 + .append(ElectricityDisplay.getDisplayShort( + (double)(10000 * 20), ElectricityDisplay.ElectricUnit.WATT)) + .append(" ") + .append(ElectricityDisplay.getDisplayShort( + this.tileEntity.getVoltage(), + ElectricityDisplay.ElectricUnit.VOLTAGE)) + .toString(), + 8, 60, 4210752); + this.fontRendererObj.drawString( + "Antimatter: " + this.tileEntity.antimatter + " mg", 8, + this.ySize - 96 + 2, 4210752); + } + + @Override + protected void drawGuiContainerBackgroundLayer(float par1, int par2, + int par3) { + this.mc.renderEngine.bindTexture(new ResourceLocation( + "atomicscience", "textures/gui/gui_accelerator.png")); + GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F); + this.containerWidth = (this.width - this.xSize) / 2; + this.containerHeight = (this.height - this.ySize) / 2; + this.drawTexturedModalRect(this.containerWidth, this.containerHeight, 0, 0, + this.xSize, this.ySize); + } +} diff --git a/src/main/java/atomicscience/shimian/GAtomicAssembler.java b/src/main/java/atomicscience/shimian/GAtomicAssembler.java new file mode 100644 index 0000000..ad699f3 --- /dev/null +++ b/src/main/java/atomicscience/shimian/GAtomicAssembler.java @@ -0,0 +1,62 @@ +package atomicscience.shimian; + +import atomicscience.TAtomicAssembler; +import atomicscience.jiqi.CAssembler; +import net.minecraft.client.gui.inventory.GuiContainer; +import net.minecraft.entity.player.InventoryPlayer; +import net.minecraft.util.ResourceLocation; +import net.minecraft.util.StatCollector; +import org.lwjgl.opengl.GL11; + +public class GAtomicAssembler extends GuiContainer { + private TAtomicAssembler tileEntity; + private int containerWidth; + private int containerHeight; + + public GAtomicAssembler(InventoryPlayer par1InventoryPlayer, + TAtomicAssembler tileEntity) { + super(new CAssembler(par1InventoryPlayer, tileEntity)); + this.tileEntity = tileEntity; + this.ySize = 230; + } + + public void drawGuiContainerForegroundLayer(int par1, int par2) { + this.fontRendererObj.drawString( + this.tileEntity.getInventoryName(), + 65 - this.tileEntity.getInventoryName().length(), 6, 4210752); + String displayText = ""; + if (this.tileEntity.isDisabled()) { + displayText = "Disabled!"; + } else if (this.tileEntity.smeltingTicks > 0) { + StringBuilder var10000 = (new StringBuilder()).append("Process: "); + float var10002 = (float)this.tileEntity.smeltingTicks; + this.tileEntity.getClass(); + displayText = var10000.append((int)(100.0F - var10002 / 1200.0F * 100.0F)) + .append("%") + .toString(); + } else if (this.tileEntity.canWork()) { + displayText = "Ready"; + } else { + displayText = "Idle"; + } + + this.fontRendererObj.drawString(displayText, 100, this.ySize - 108 + 2, + 4210752); + this.fontRendererObj.drawString("Voltage: " + + (int)this.tileEntity.getVoltage(), + 100, this.ySize - 96 + 2, 4210752); + this.fontRendererObj.drawString( + StatCollector.translateToLocal("container.inventory"), 8, + this.ySize - 96 + 2, 4210752); + } + + protected void drawGuiContainerBackgroundLayer(float par1, int par2, int par3) { + this.mc.renderEngine.bindTexture(new ResourceLocation( + "atomicscience", "textures/gui/gui_atomic_assembler.png")); + GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F); + this.containerWidth = (this.width - this.xSize) / 2; + this.containerHeight = (this.height - this.ySize) / 2; + this.drawTexturedModalRect(this.containerWidth, this.containerHeight, 0, 0, + this.xSize, this.ySize); + } +} diff --git a/src/main/java/atomicscience/shimian/GAutoBuilder.java b/src/main/java/atomicscience/shimian/GAutoBuilder.java new file mode 100644 index 0000000..09f4c18 --- /dev/null +++ b/src/main/java/atomicscience/shimian/GAutoBuilder.java @@ -0,0 +1,81 @@ +package atomicscience.shimian; + +import atomicscience.TAutoBuilder; +import calclavia.lib.gui.GuiScreenBase; +import net.minecraft.client.gui.GuiButton; +import net.minecraft.client.gui.GuiTextField; +import net.minecraft.tileentity.TileEntity; + +public class GAutoBuilder extends GuiScreenBase { + private TileEntity tileEntity; + private GuiTextField tfBbanJing; + private TAutoBuilder.AutoBuilderType mode = TAutoBuilder.AutoBuilderType.get(0); + + public GAutoBuilder(TileEntity tileEntity) { this.tileEntity = tileEntity; } + + @Override + public void initGui() { + super.initGui(); + this.tfBbanJing = new GuiTextField(this.fontRendererObj, 45, 58, 50, 12); + this.buttonList.add(new GuiButton(0, this.width / 2 - 80, + this.height / 2 - 10, 58, 20, "Build")); + this.buttonList.add(new GuiButton(1, this.width / 2 - 50, + this.height / 2 - 35, 120, 20, "Mode")); + } + + @Override + protected void drawForegroundLayer(int x, int y, float var1) { + this.fontRendererObj.drawString("Auto Builder", 60, 6, 4210752); + this.fontRendererObj.drawString("This is a creative only cheat", 9, 20, + 4210752); + this.fontRendererObj.drawString("which allows you to auto build", 9, 30, + 4210752); + this.fontRendererObj.drawString("structures for testing.", 9, 40, 4210752); + this.fontRendererObj.drawString("Radius: ", 9, 60, 4210752); + this.tfBbanJing.drawTextBox(); + ((GuiButton)this.buttonList.get(1)).displayString = this.mode.name; + this.fontRendererObj.drawString("Mode: ", 9, 80, 4210752); + super.drawForegroundLayer(x, y, var1); + this.fontRendererObj.drawString("Warning!", 9, 130, 4210752); + this.fontRendererObj.drawString("This will replace blocks without", 9, 140, + 4210752); + this.fontRendererObj.drawString("dropping it! You may lose items.", 9, 150, + 4210752); + } + + @Override + protected void keyTyped(char par1, int par2) { + super.keyTyped(par1, par2); + this.tfBbanJing.textboxKeyTyped(par1, par2); + } + + @Override + protected void mouseClicked(int x, int y, int par3) { + super.mouseClicked(x, y, par3); + this.tfBbanJing.mouseClicked(x - super.containerWidth, + y - super.containerHeight, par3); + } + + @Override + protected void actionPerformed(GuiButton par1GuiButton) { + super.actionPerformed(par1GuiButton); + if (par1GuiButton.id == 0) { + int radius = 0; + + try { + radius = Integer.parseInt(this.tfBbanJing.getText()); + } catch (Exception var4) { + ; + } + + if (radius > 0) { + // TODO: WTF + // PacketDispatcher.sendPacketToServer(PacketManager.getPacket("AtomicScience", + // this.tileEntity, new Object[]{Integer.valueOf(this.mode.ordinal()), + // Integer.valueOf(radius)})); + } + } else if (par1GuiButton.id == 1) { + this.mode = this.mode.next(); + } + } +} diff --git a/src/main/java/atomicscience/shimian/GBase.java b/src/main/java/atomicscience/shimian/GBase.java new file mode 100644 index 0000000..3da1008 --- /dev/null +++ b/src/main/java/atomicscience/shimian/GBase.java @@ -0,0 +1,156 @@ +package atomicscience.shimian; + +import net.minecraft.client.gui.inventory.GuiContainer; +import net.minecraft.client.renderer.RenderHelper; +import net.minecraft.inventory.Container; +import net.minecraft.util.ResourceLocation; +import org.lwjgl.opengl.GL11; + +public class GBase extends GuiContainer { + public static final int METER_HEIGHT = 49; + public static final int METER_WIDTH = 14; + protected int kuanDu; + protected int gaoDu; + + public GBase(Container par1Container) { super(par1Container); } + + @Override + protected void drawGuiContainerBackgroundLayer(float var1, int var2, + int var3) { + this.kuanDu = (this.width - this.xSize) / 2; + this.gaoDu = (this.height - this.ySize) / 2; + this.mc.renderEngine.bindTexture( + new ResourceLocation("atomicscience", "textures/gui/gui_base.png")); + GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F); + this.drawTexturedModalRect(this.kuanDu, this.gaoDu, 0, 0, this.xSize, + this.ySize); + } + + protected void drawSlot(int x, int y, GBase.SlotType type) { + this.mc.renderEngine.bindTexture(new ResourceLocation( + "atomicscience", "textures/gui/gui_components.png")); + GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F); + this.drawTexturedModalRect(this.kuanDu + x, this.gaoDu + y, 0, 0, 18, 18); + switch (type) { + case DIAN: + this.drawTexturedModalRect(this.kuanDu + x, this.gaoDu + y, 0, 18, 18, + 18); + break; + case SHUI: + this.drawTexturedModalRect(this.kuanDu + x, this.gaoDu + y, 0, 36, 18, + 18); + break; + case QI: + this.drawTexturedModalRect(this.kuanDu + x, this.gaoDu + y, 0, 54, 18, + 18); + default: + break; + } + } + + protected void drawSlot(int x, int y) { + this.drawSlot(x, y, GBase.SlotType.NONE); + } + + protected void drawBar(int x, int y, float scale) { + this.mc.renderEngine.bindTexture(new ResourceLocation( + "atomicscience", "textures/gui/gui_components.png")); + GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F); + this.drawTexturedModalRect(this.kuanDu + x, this.gaoDu + y, 18, 0, 22, 15); + if (scale > 0.0F) { + this.drawTexturedModalRect(this.kuanDu + x, this.gaoDu + y, 18, 15, + 22 - (int)(scale * 22.0F), 15); + } + } + + protected void drawMeter(int x, int y, float scale, float r, float g, + float b) { + this.mc.renderEngine.bindTexture(new ResourceLocation( + "atomicscience", "textures/gui/gui_components.png")); + GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F); + this.drawTexturedModalRect(this.kuanDu + x, this.gaoDu + y, 40, 0, 14, 49); + GL11.glColor4f(r, g, b, 1.0F); + int actualScale = (int)(48.0F * scale); + this.drawTexturedModalRect(this.kuanDu + x, + this.gaoDu + y + (48 - actualScale), 40, 49, 13, + actualScale); + GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F); + this.drawTexturedModalRect(this.kuanDu + x, this.gaoDu + y, 40, 98, 14, 49); + } + + public void drawTooltip(int x, int y, String... toolTips) { + GL11.glDisable('\u803a'); + RenderHelper.disableStandardItemLighting(); + GL11.glDisable(2896); + GL11.glDisable(2929); + if (toolTips != null) { + int var5 = 0; + + int var6; + int var7; + for (var6 = 0; var6 < toolTips.length; ++var6) { + var7 = this.fontRendererObj.getStringWidth(toolTips[var6]); + if (var7 > var5) { + var5 = var7; + } + } + + var6 = x + 12; + var7 = y - 12; + int var9 = 8; + if (toolTips.length > 1) { + var9 += 2 + (toolTips.length - 1) * 10; + } + + if (this.guiTop + var7 + var9 + 6 > this.height) { + var7 = this.height - var9 - this.guiTop - 6; + } + + super.zLevel = 300.0F; + int var10 = -267386864; + this.drawGradientRect(var6 - 3, var7 - 4, var6 + var5 + 3, var7 - 3, + var10, var10); + this.drawGradientRect(var6 - 3, var7 + var9 + 3, var6 + var5 + 3, + var7 + var9 + 4, var10, var10); + this.drawGradientRect(var6 - 3, var7 - 3, var6 + var5 + 3, + var7 + var9 + 3, var10, var10); + this.drawGradientRect(var6 - 4, var7 - 3, var6 - 3, var7 + var9 + 3, + var10, var10); + this.drawGradientRect(var6 + var5 + 3, var7 - 3, var6 + var5 + 4, + var7 + var9 + 3, var10, var10); + int var11 = 1347420415; + int var12 = (var11 & 16711422) >> 1 | var11 & -16777216; + this.drawGradientRect(var6 - 3, var7 - 3 + 1, var6 - 3 + 1, + var7 + var9 + 3 - 1, var11, var12); + this.drawGradientRect(var6 + var5 + 2, var7 - 3 + 1, var6 + var5 + 3, + var7 + var9 + 3 - 1, var11, var12); + this.drawGradientRect(var6 - 3, var7 - 3, var6 + var5 + 3, var7 - 3 + 1, + var11, var11); + this.drawGradientRect(var6 - 3, var7 + var9 + 2, var6 + var5 + 3, + var7 + var9 + 3, var12, var12); + + for (int var13 = 0; var13 < toolTips.length; ++var13) { + String var14 = toolTips[var13]; + this.fontRendererObj.drawStringWithShadow(var14, var6, var7, -1); + if (var13 == 0) { + var7 += 2; + } + + var7 += 10; + } + + super.zLevel = 0.0F; + GL11.glEnable(2929); + GL11.glEnable(2896); + RenderHelper.enableGUIStandardItemLighting(); + GL11.glEnable('\u803a'); + } + } + + public static enum SlotType { + NONE, + DIAN, + SHUI, + QI; + } +} diff --git a/src/main/java/atomicscience/shimian/GCentrifuge.java b/src/main/java/atomicscience/shimian/GCentrifuge.java new file mode 100644 index 0000000..c0968f3 --- /dev/null +++ b/src/main/java/atomicscience/shimian/GCentrifuge.java @@ -0,0 +1,69 @@ +package atomicscience.shimian; + +import atomicscience.fenlie.CCentrifuge; +import atomicscience.fenlie.TCentrifuge; +import net.minecraft.entity.player.InventoryPlayer; +import net.minecraft.util.StatCollector; +import universalelectricity.core.electricity.ElectricityDisplay; + +public class GCentrifuge extends GBase { + private TCentrifuge tileEntity; + + public GCentrifuge(InventoryPlayer par1InventoryPlayer, + TCentrifuge tileEntity) { + super(new CCentrifuge(par1InventoryPlayer, tileEntity)); + this.tileEntity = tileEntity; + } + + @Override + public void drawGuiContainerForegroundLayer(int x, int y) { + this.fontRendererObj.drawString(this.tileEntity.getInventoryName(), 60, 6, + 4210752); + String displayText = ""; + if (this.tileEntity.isDisabled()) { + displayText = "Disabled!"; + } else if (this.tileEntity.smeltingTicks > 0) { + displayText = "Processing"; + } else if (this.tileEntity.canWork()) { + displayText = "Ready"; + } else { + displayText = "Idle"; + } + + this.fontRendererObj.drawString("Status: " + displayText, 70, 50, 4210752); + this.fontRendererObj.drawString( + ElectricityDisplay.getDisplay(10000.0D, + ElectricityDisplay.ElectricUnit.WATT), + 70, 60, 4210752); + this.fontRendererObj.drawString( + ElectricityDisplay.getDisplay(this.tileEntity.getVoltage(), + ElectricityDisplay.ElectricUnit.VOLTAGE), + 70, 70, 4210752); + this.fontRendererObj.drawString( + StatCollector.translateToLocal("container.inventory"), 8, + this.ySize - 96 + 2, 4210752); + if (this.func_146978_c(8, 18, 14, 49, x, y) && + this.tileEntity.gasTank.getFluid() != null) { + this.drawTooltip( + x - this.guiLeft, y - this.guiTop + 10, + new String[] {this.tileEntity.gasTank.getFluid().getLocalizedName(), + (float)this.tileEntity.gasTank.getFluidAmount() / + 1000.0F + + " dm3"}); + } + } + + @Override + protected void drawGuiContainerBackgroundLayer(float par1, int x, int y) { + super.drawGuiContainerBackgroundLayer(par1, x, y); + this.drawSlot(80, 25); + this.drawSlot(100, 25); + this.drawSlot(130, 25, GBase.SlotType.DIAN); + this.drawBar(40, 26, (float)this.tileEntity.smeltingTicks / 2400.0F); + this.drawMeter(8, 18, + (float)this.tileEntity.gasTank.getFluidAmount() / + (float)this.tileEntity.gasTank.getCapacity(), + 0.84F, 0.9F, 0.69F); + this.drawSlot(24, 49, GBase.SlotType.QI); + } +} diff --git a/src/main/java/atomicscience/shimian/GChemicalReactor.java b/src/main/java/atomicscience/shimian/GChemicalReactor.java new file mode 100644 index 0000000..ce53190 --- /dev/null +++ b/src/main/java/atomicscience/shimian/GChemicalReactor.java @@ -0,0 +1,58 @@ +package atomicscience.shimian; + +import atomicscience.hecheng.CChemicalExtractor; +import atomicscience.jiqi.TChemicalExtractor; +import net.minecraft.entity.player.InventoryPlayer; +import net.minecraft.util.StatCollector; +import universalelectricity.core.electricity.ElectricityDisplay; + +public class GChemicalReactor extends GBase { + private TChemicalExtractor tileEntity; + + public GChemicalReactor(InventoryPlayer par1InventoryPlayer, + TChemicalExtractor tileEntity) { + super(new CChemicalExtractor(par1InventoryPlayer, tileEntity)); + this.tileEntity = tileEntity; + } + + @Override + public void drawGuiContainerForegroundLayer(int x, int y) { + this.fontRendererObj.drawString(this.tileEntity.getInventoryName(), 45, 6, + 4210752); + this.tileEntity.getClass(); + this.fontRendererObj.drawString( + ElectricityDisplay.getDisplay((double)(500.0F * 20.0F), + ElectricityDisplay.ElectricUnit.WATT), + 90, 48, 4210752); + this.fontRendererObj.drawString( + ElectricityDisplay.getDisplay(this.tileEntity.getVoltage(), + ElectricityDisplay.ElectricUnit.VOLTAGE), + 90, 60, 4210752); + this.fontRendererObj.drawString( + StatCollector.translateToLocal("container.inventory"), 8, + this.ySize - 96 + 2, 4210752); + if (this.func_146978_c(8, 18, 14, 49, x, y) && + this.tileEntity.waterTank.getFluid() != null) { + this.drawTooltip( + x - this.guiLeft, y - this.guiTop + 10, + new String[] {this.tileEntity.waterTank.getFluid().getLocalizedName(), + this.tileEntity.waterTank.getFluidAmount() + " ml"}); + } + } + + @Override + protected void drawGuiContainerBackgroundLayer(float par1, int x, int y) { + super.drawGuiContainerBackgroundLayer(par1, x, y); + this.drawSlot(64, 24); + this.drawSlot(64, 48, GBase.SlotType.DIAN); + this.drawSlot(117, 24); + float var10003 = (float)this.tileEntity.smeltingTicks; + this.tileEntity.getClass(); + this.drawBar(87, 24, var10003 / 280.0F); + this.drawMeter(8, 18, + (float)this.tileEntity.waterTank.getFluidAmount() / + (float)this.tileEntity.waterTank.getCapacity(), + 0.16F, 0.52F, 0.99F); + this.drawSlot(24, 49, GBase.SlotType.SHUI); + } +} diff --git a/src/main/java/atomicscience/shimian/GFissionReactor.java b/src/main/java/atomicscience/shimian/GFissionReactor.java new file mode 100644 index 0000000..ad6979b --- /dev/null +++ b/src/main/java/atomicscience/shimian/GFissionReactor.java @@ -0,0 +1,74 @@ +package atomicscience.shimian; + +import atomicscience.fenlie.TFissionReactor; +import calclavia.lib.gui.GuiContainerBase; +import net.minecraft.entity.player.InventoryPlayer; +import universalelectricity.core.electricity.ElectricityDisplay; + +public class GFissionReactor extends GuiContainerBase { + private TFissionReactor tileEntity; + + public GFissionReactor(InventoryPlayer inventory, TFissionReactor tileEntity) { + super(new CFissionReactor(inventory.player, tileEntity)); + this.tileEntity = tileEntity; + } + + @Override + public void drawGuiContainerForegroundLayer(int x, int y) { + this.fontRendererObj.drawString( + this.tileEntity.getInventoryName(), + this.xSize / 2 - this.fontRendererObj.getStringWidth( + this.tileEntity.getInventoryName()) / + 2, + 6, 4210752); + int toxicity = 0; + if (this.tileEntity.wasteTank.getFluid() != null) { + toxicity = this.tileEntity.wasteTank.getFluidAmount(); + } + + this.fontRendererObj.drawString("Toxicity: " + toxicity + " dm3", 9, 45, + 4210752); + this.fontRendererObj.drawString( + "Temperature: " + (int)this.tileEntity.wenDu + " Celsius", 9, 70, + 4210752); + this.fontRendererObj.drawString( + "Steam Emission: " + + ElectricityDisplay.roundDecimals( + (double)(1.0F / (Math.max(40.0F - this.tileEntity.wenDu / + 2000.0F * 40.0F, + 2.0F) / + 20.0F))) + + "/second", + 9, 95, 4210752); + if (this.tileEntity.getStackInSlot(0) != null) { + int ticksLeft = this.tileEntity.getStackInSlot(0).getMaxDamage() - + this.tileEntity.getStackInSlot(0).getItemDamage(); + this.fontRendererObj.drawString( + "Time Left: " + ticksLeft / 20 / this.tileEntity.getHeight() + + " seconds " + ticksLeft, + 9, 105, 4210752); + } + } + + @Override + protected void drawGuiContainerBackgroundLayer(float par1, int x, int y) { + //super.drawGuiContainerBackgroundLayer(par1, x, y); + this.drawSlot(78, 20); + if (this.tileEntity.wasteTank.getFluid() != null) { + int toxicity1 = this.tileEntity.wasteTank.getFluidAmount(); + this.drawForce(10, 55, + (float)toxicity1 / + (float)this.tileEntity.wasteTank.getCapacity()); + } + + this.drawForce(10, 80, this.tileEntity.wenDu / 2000.0F); + if (this.tileEntity.getStackInSlot(0) != null) { + float ticksLeft = + (float)(this.tileEntity.getStackInSlot(0).getMaxDamage() - + this.tileEntity.getStackInSlot(0).getItemDamage()); + this.drawElectricity( + 10, 115, + ticksLeft / (float)this.tileEntity.getStackInSlot(0).getMaxDamage()); + } + } +} diff --git a/src/main/java/atomicscience/shimian/GNuclearBoiler.java b/src/main/java/atomicscience/shimian/GNuclearBoiler.java new file mode 100644 index 0000000..946acb6 --- /dev/null +++ b/src/main/java/atomicscience/shimian/GNuclearBoiler.java @@ -0,0 +1,70 @@ +package atomicscience.shimian; + +import atomicscience.fenlie.TNuclearBoiler; +import atomicscience.hecheng.CNuclearBoiler; +import net.minecraft.entity.player.InventoryPlayer; +import net.minecraft.util.StatCollector; +import universalelectricity.core.electricity.ElectricityDisplay; + +public class GNuclearBoiler extends GBase { + + private TNuclearBoiler tileEntity; + + public GNuclearBoiler(InventoryPlayer par1InventoryPlayer, TNuclearBoiler tileEntity) { + super(new CNuclearBoiler(par1InventoryPlayer, tileEntity)); + this.tileEntity = tileEntity; + } + + @Override + public void drawGuiContainerForegroundLayer(int x, int y) { + this.fontRendererObj.drawString(this.tileEntity.getInventoryName(), 52, 6, + 4210752); + this.tileEntity.getClass(); + this.fontRendererObj.drawString( + ElectricityDisplay.getDisplay((double)(800.0F * 20.0F), + ElectricityDisplay.ElectricUnit.WATT), + 55, 48, 4210752); + this.fontRendererObj.drawString( + ElectricityDisplay.getDisplay(this.tileEntity.getVoltage(), + ElectricityDisplay.ElectricUnit.VOLTAGE), + 55, 60, 4210752); + this.fontRendererObj.drawString( + StatCollector.translateToLocal("container.inventory"), 8, + this.ySize - 96 + 2, 4210752); + if (this.func_146978_c(8, 18, 14, 49, x, y) && + this.tileEntity.waterTank.getFluid() != null) { + this.drawTooltip( + x - this.guiLeft, y - this.guiTop + 10, + new String[] {this.tileEntity.waterTank.getFluid().getLocalizedName(), + this.tileEntity.waterTank.getFluidAmount() + " ml"}); + } else if (this.func_146978_c(155, 18, 14, 49, x, y) && + this.tileEntity.gasTank.getFluid() != null) { + this.drawTooltip( + x - this.guiLeft, y - this.guiTop + 10, + new String[] {this.tileEntity.gasTank.getFluid().getLocalizedName(), + (float)this.tileEntity.gasTank.getFluidAmount() / + 1000.0F + + " dm3"}); + } + } + + @Override + protected void drawGuiContainerBackgroundLayer(float par1, int x, int y) { + super.drawGuiContainerBackgroundLayer(par1, x, y); + this.drawSlot(55, 25, GBase.SlotType.DIAN); + this.drawSlot(80, 25); + float var10003 = (float)this.tileEntity.smeltingTicks; + this.tileEntity.getClass(); + this.drawBar(110, 26, var10003 / 300.0F); + this.drawMeter(8, 18, + (float)this.tileEntity.waterTank.getFluidAmount() / + (float)this.tileEntity.waterTank.getCapacity(), + 0.16F, 0.52F, 0.99F); + this.drawSlot(24, 49, GBase.SlotType.SHUI); + this.drawMeter(155, 18, + (float)this.tileEntity.gasTank.getFluidAmount() / + (float)this.tileEntity.gasTank.getCapacity(), + 0.84F, 0.9F, 0.69F); + this.drawSlot(135, 49, GBase.SlotType.QI); + } +} diff --git a/src/main/java/atomicscience/strangematter.ogg b/src/main/java/atomicscience/strangematter.ogg new file mode 100644 index 0000000..f9baaa1 Binary files /dev/null and b/src/main/java/atomicscience/strangematter.ogg differ diff --git a/src/main/java/atomicscience/turbine.ogg b/src/main/java/atomicscience/turbine.ogg new file mode 100644 index 0000000..298bf89 Binary files /dev/null and b/src/main/java/atomicscience/turbine.ogg differ diff --git a/src/main/java/atomicscience/wujian/ItAS.java b/src/main/java/atomicscience/wujian/ItAS.java new file mode 100644 index 0000000..b58805d --- /dev/null +++ b/src/main/java/atomicscience/wujian/ItAS.java @@ -0,0 +1,12 @@ +package atomicscience.wujian; + +import atomicscience.TabAS; +import net.minecraft.item.Item; + +public class ItAS extends Item { + public ItAS(String name) { + super(); + this.setUnlocalizedName("atomicscience:" + name); + this.setCreativeTab(TabAS.INSTANCE); + } +} diff --git a/src/main/java/atomicscience/wujian/ItBreederFuel.java b/src/main/java/atomicscience/wujian/ItBreederFuel.java new file mode 100644 index 0000000..cac91c0 --- /dev/null +++ b/src/main/java/atomicscience/wujian/ItBreederFuel.java @@ -0,0 +1,25 @@ +package atomicscience.wujian; + +import atomicscience.api.IFissileMaterial; +import atomicscience.api.ITemperature; +import atomicscience.fenlie.ItRadioactive; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; + +public class ItBreederFuel extends ItRadioactive implements IFissileMaterial { + public static final int FU_LAN = 40000; + + public ItBreederFuel() { + super("rodBreederFuel"); + this.setMaxDamage('\u9c40'); + this.setMaxStackSize(1); + this.setNoRepair(); + } + + public int onFissile(ITemperature reactor) { + TileEntity tileEntity = (TileEntity)reactor; + World worldObj = tileEntity.getWorldObj(); + reactor.setTemperature((float)((double)reactor.getTemperature() + 1.5D + (double)worldObj.rand.nextFloat() * 0.5D)); + return 0; + } +} diff --git a/src/main/java/atomicscience/wujian/ItCell.java b/src/main/java/atomicscience/wujian/ItCell.java new file mode 100644 index 0000000..dee1bd6 --- /dev/null +++ b/src/main/java/atomicscience/wujian/ItCell.java @@ -0,0 +1,7 @@ +package atomicscience.wujian; + +public class ItCell extends ItAS { + public ItCell(String name) { + super(name); + } +} diff --git a/src/main/java/atomicscience/wujian/ItElectricAS.java b/src/main/java/atomicscience/wujian/ItElectricAS.java new file mode 100644 index 0000000..b060a19 --- /dev/null +++ b/src/main/java/atomicscience/wujian/ItElectricAS.java @@ -0,0 +1,12 @@ +package atomicscience.wujian; + +import atomicscience.TabAS; +import universalelectricity.core.item.ItemElectric; + +public abstract class ItElectricAS extends ItemElectric { + public ItElectricAS(String name) { + super(); + this.setUnlocalizedName("atomicscience:" + name); + this.setCreativeTab(TabAS.INSTANCE); + } +} diff --git a/src/main/java/atomicscience/wujian/ItFissileFuel.java b/src/main/java/atomicscience/wujian/ItFissileFuel.java new file mode 100644 index 0000000..acb8303 --- /dev/null +++ b/src/main/java/atomicscience/wujian/ItFissileFuel.java @@ -0,0 +1,77 @@ +package atomicscience.wujian; + +import atomicscience.api.IFissileMaterial; +import atomicscience.api.IReactor; +import atomicscience.api.ITemperature; +import atomicscience.fenlie.ItRadioactive; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; + +import java.util.List; +import net.minecraft.block.Block; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; +import net.minecraftforge.common.util.ForgeDirection; +import universalelectricity.core.vector.Vector3; + +public class ItFissileFuel extends ItRadioactive implements IFissileMaterial { + public static final int FU_LAN = 50000; + + public ItFissileFuel() { + super("rodFissileFuel"); + this.setMaxDamage('\uc350'); + this.setMaxStackSize(1); + this.setNoRepair(); + } + + @Override + public int onFissile(ITemperature reactor) { + TileEntity tileEntity = (TileEntity)reactor; + World worldObj = tileEntity.getWorldObj(); + float wenDu = 0.0F; + int reactors = 0; + + for (int chance = 0; chance < 6; ++chance) { + Vector3 iWenDuDiDian = + (new Vector3(tileEntity)) + .modifyPositionFromSide(ForgeDirection.getOrientation(chance)); + Block fangGe = iWenDuDiDian.getBlock(worldObj); + if (fangGe != null) { + TileEntity tile = iWenDuDiDian.getTileEntity(worldObj); + if (tile instanceof IReactor) { + ++reactors; + } + + if (fangGe instanceof ITemperature) { + wenDu += ((ITemperature)fangGe).getTemperature(); + } else if (tile instanceof ITemperature) { + wenDu += ((ITemperature)tile).getTemperature(); + } + } + } + + if (reactors >= 4) { + float var11 = Math.max((wenDu - 5000.0F) / 2000.0F, 0.0F); + if (Math.random() <= (double)var11) { + return 2; + } else { + return 1; + } + } else { + reactor.setTemperature((float)((double)reactor.getTemperature() + 1.6D + + (double)worldObj.rand.nextFloat() * 0.4D)); + return 0; + } + } + + @Override + @SideOnly(Side.CLIENT) + public void getSubItems(Item par1, CreativeTabs par2CreativeTabs, + List par3List) { + par3List.add(new ItemStack(par1, 1, 0)); + par3List.add(new ItemStack(par1, 1, this.getMaxDamage() - 1)); + } +} diff --git a/src/main/java/calclavia/lib/Calclavia.java b/src/main/java/calclavia/lib/Calclavia.java new file mode 100644 index 0000000..ff6b180 --- /dev/null +++ b/src/main/java/calclavia/lib/Calclavia.java @@ -0,0 +1,32 @@ +package calclavia.lib; + +import java.util.ArrayList; +import java.util.List; + +public class Calclavia { + + public static final String RESOURCE_DIRECTORY = "/mods/calclavia/"; + public static final String TEXTURE_DIRECTORY = "/mods/calclavia/textures/"; + public static final String GUI_DIRECTORY = "/mods/calclavia/textures/gui/"; + public static final String GUI_COMPONENTS = "/mods/calclavia/textures/gui/gui_components.png"; + public static final String GUI_BASE_FILE = "/mods/calclavia/textures/gui/gui_base.png"; + public static final String GUI_EMPTY_FILE = "/mods/calclavia/textures/gui/gui_empty.png"; + + + public static List splitStringPerWord(String string, int wordsPerLine) { + String[] words = string.split(" "); + ArrayList lines = new ArrayList<>(); + + for(int lineCount = 0; (double)lineCount < Math.ceil((double)((float)words.length / (float)wordsPerLine)); ++lineCount) { + String stringInLine = ""; + + for(int i = lineCount * wordsPerLine; i < Math.min(wordsPerLine + lineCount * wordsPerLine, words.length); ++i) { + stringInLine = stringInLine + words[i] + " "; + } + + lines.add(stringInLine.trim()); + } + + return lines; + } +} diff --git a/src/main/java/calclavia/lib/CalculationHelper.java b/src/main/java/calclavia/lib/CalculationHelper.java new file mode 100644 index 0000000..1748b8b --- /dev/null +++ b/src/main/java/calclavia/lib/CalculationHelper.java @@ -0,0 +1,111 @@ +package calclavia.lib; + +import java.util.Iterator; +import java.util.List; +import net.minecraft.entity.Entity; +import net.minecraft.util.AxisAlignedBB; +import net.minecraft.util.MovingObjectPosition; +import net.minecraft.util.Vec3; +import net.minecraft.world.World; +import universalelectricity.core.vector.Vector3; + +public class CalculationHelper { + + public static void rotateByAngle(Vector3 vector, double yaw) { + double yawRadians = Math.toRadians(yaw); + double x = vector.x; + double z = vector.z; + if(yaw != 0.0D) { + vector.x = x * Math.cos(yawRadians) - z * Math.sin(yawRadians); + vector.z = x * Math.sin(yawRadians) + z * Math.cos(yawRadians); + } + + } + + public static void rotateByAngle(Vector3 vector, double yaw, double pitch) { + rotateByAngle(vector, yaw, pitch, 0.0D); + } + + public static void rotateByAngle(Vector3 vector, double yaw, double pitch, double roll) { + double yawRadians = Math.toRadians(yaw); + double pitchRadians = Math.toRadians(pitch); + double rollRadians = Math.toRadians(roll); + double x = vector.x; + double y = vector.y; + double z = vector.z; + vector.x = x * Math.cos(yawRadians) * Math.cos(pitchRadians) + z * (Math.cos(yawRadians) * Math.sin(pitchRadians) * Math.sin(rollRadians) - Math.sin(yawRadians) * Math.cos(rollRadians)) + y * (Math.cos(yawRadians) * Math.sin(pitchRadians) * Math.cos(rollRadians) + Math.sin(yawRadians) * Math.sin(rollRadians)); + vector.z = x * Math.sin(yawRadians) * Math.cos(pitchRadians) + z * (Math.sin(yawRadians) * Math.sin(pitchRadians) * Math.sin(rollRadians) + Math.cos(yawRadians) * Math.cos(rollRadians)) + y * (Math.sin(yawRadians) * Math.sin(pitchRadians) * Math.cos(rollRadians) - Math.cos(yawRadians) * Math.sin(rollRadians)); + vector.y = -x * Math.sin(pitchRadians) + z * Math.cos(pitchRadians) * Math.sin(rollRadians) + y * Math.cos(pitchRadians) * Math.cos(rollRadians); + } + + public static Vector3 getDeltaPositionFromRotation(float rotationYaw, float rotationPitch) { + rotationYaw += 90.0F; + rotationPitch = -rotationPitch; + return new Vector3(Math.cos(Math.toRadians((double)rotationYaw)), Math.sin(Math.toRadians((double)rotationPitch)), Math.sin(Math.toRadians((double)rotationYaw))); + } + + public static MovingObjectPosition raytraceEntities(World world, Vector3 startPosition, float rotationYaw, float rotationPitch, boolean collisionFlag, double reachDistance) { + MovingObjectPosition pickedEntity = null; + Vec3 startingPosition = startPosition.toVec3(); + Vec3 look = getDeltaPositionFromRotation(rotationYaw, rotationPitch).toVec3(); + Vec3 reachPoint = Vec3.createVectorHelper(startingPosition.xCoord + look.xCoord * reachDistance, startingPosition.yCoord + look.yCoord * reachDistance, startingPosition.zCoord + look.zCoord * reachDistance); + double playerBorder = 1.1D * reachDistance; + AxisAlignedBB boxToScan = AxisAlignedBB.getBoundingBox(-playerBorder, -playerBorder, -playerBorder, playerBorder, playerBorder, playerBorder); + List entitiesHit = world.getEntitiesWithinAABBExcludingEntity((Entity)null, boxToScan); + double closestEntity = reachDistance; + if(entitiesHit != null && !entitiesHit.isEmpty()) { + Iterator i$ = entitiesHit.iterator(); + + while(i$.hasNext()) { + Entity entityHit = (Entity)i$.next(); + if(entityHit != null && entityHit.canBeCollidedWith() && entityHit.boundingBox != null) { + float border = entityHit.getCollisionBorderSize(); + AxisAlignedBB aabb = entityHit.boundingBox.expand((double)border, (double)border, (double)border); + MovingObjectPosition hitMOP = aabb.calculateIntercept(startingPosition, reachPoint); + if(hitMOP != null) { + if(aabb.isVecInside(startingPosition)) { + if(0.0D < closestEntity || closestEntity == 0.0D) { + pickedEntity = new MovingObjectPosition(entityHit); + if(pickedEntity != null) { + pickedEntity.hitVec = hitMOP.hitVec; + closestEntity = 0.0D; + } + } + } else { + double distance = startingPosition.distanceTo(hitMOP.hitVec); + if(distance < closestEntity || closestEntity == 0.0D) { + pickedEntity = new MovingObjectPosition(entityHit); + pickedEntity.hitVec = hitMOP.hitVec; + closestEntity = distance; + } + } + } + } + } + + return pickedEntity; + } else { + return null; + } + } + + public static MovingObjectPosition raytraceBlocks(World world, Vector3 startPosition, float rotationYaw, float rotationPitch, boolean collisionFlag, double reachDistance) { + Vector3 lookVector = getDeltaPositionFromRotation(rotationYaw, rotationPitch); + Vector3 reachPoint = Vector3.add(startPosition, Vector3.multiply(lookVector, reachDistance)); + return world.rayTraceBlocks(startPosition.toVec3(), reachPoint.toVec3(), collisionFlag); + } + + public static MovingObjectPosition doCustomRayTrace(World world, Vector3 startPosition, float rotationYaw, float rotationPitch, boolean collisionFlag, double reachDistance) { + MovingObjectPosition pickedBlock = raytraceBlocks(world, startPosition, rotationYaw, rotationPitch, collisionFlag, reachDistance); + MovingObjectPosition pickedEntity = raytraceEntities(world, startPosition, rotationYaw, rotationPitch, collisionFlag, reachDistance); + if(pickedBlock == null) { + return pickedEntity; + } else if(pickedEntity == null) { + return pickedBlock; + } else { + double dBlock = startPosition.distanceTo(new Vector3(pickedBlock.hitVec)); + double dEntity = startPosition.distanceTo(new Vector3(pickedEntity.hitVec)); + return dEntity < dBlock?pickedEntity:pickedBlock; + } + } +} diff --git a/src/main/java/calclavia/lib/IPlayerUsing.java b/src/main/java/calclavia/lib/IPlayerUsing.java new file mode 100644 index 0000000..c7681eb --- /dev/null +++ b/src/main/java/calclavia/lib/IPlayerUsing.java @@ -0,0 +1,8 @@ +package calclavia.lib; + +import java.util.HashSet; + +public interface IPlayerUsing { + + HashSet getPlayersUsing(); +} diff --git a/src/main/java/calclavia/lib/IUniversalEnergyTile.java b/src/main/java/calclavia/lib/IUniversalEnergyTile.java new file mode 100644 index 0000000..ed5452c --- /dev/null +++ b/src/main/java/calclavia/lib/IUniversalEnergyTile.java @@ -0,0 +1,7 @@ +package calclavia.lib; + +import universalelectricity.core.block.IConnector; +import universalelectricity.core.block.IVoltage; + +public interface IUniversalEnergyTile extends IConnector, IVoltage { +} diff --git a/src/main/java/calclavia/lib/TileEntityUniversalProducer.java b/src/main/java/calclavia/lib/TileEntityUniversalProducer.java new file mode 100644 index 0000000..e90c0c9 --- /dev/null +++ b/src/main/java/calclavia/lib/TileEntityUniversalProducer.java @@ -0,0 +1,25 @@ +package calclavia.lib; + +import net.minecraftforge.common.util.ForgeDirection; +import universalelectricity.core.electricity.ElectricityNetworkHelper; +import universalelectricity.core.electricity.ElectricityPack; +import universalelectricity.prefab.implement.IRotatable; +import universalelectricity.prefab.tile.TileEntityElectrical; + +public class TileEntityUniversalProducer extends TileEntityElectrical { + public ElectricityPack produce(double watts) { + ElectricityPack pack = + new ElectricityPack(watts / this.getVoltage(), this.getVoltage()); + ElectricityPack remaining = + ElectricityNetworkHelper.produceFromMultipleSides(this, pack); + + return remaining; + } + + @Override + public boolean canConnect(ForgeDirection direction) { + return this instanceof IRotatable + ? direction.ordinal() == this.getBlockMetadata() + : true; + } +} diff --git a/src/main/java/calclavia/lib/TileEntityUniversalRunnable.java b/src/main/java/calclavia/lib/TileEntityUniversalRunnable.java new file mode 100644 index 0000000..19387fb --- /dev/null +++ b/src/main/java/calclavia/lib/TileEntityUniversalRunnable.java @@ -0,0 +1,28 @@ +package calclavia.lib; + +import net.minecraft.world.IBlockAccess; +import net.minecraft.world.World; +import net.minecraftforge.common.util.ForgeDirection; +import universalelectricity.prefab.implement.IRotatable; +import universalelectricity.prefab.tile.TileEntityElectricityRunnable; + +public abstract class TileEntityUniversalRunnable + extends TileEntityElectricityRunnable implements IUniversalEnergyTile { + @Override + public boolean canConnect(ForgeDirection direction) { + return this instanceof IRotatable + ? direction == ForgeDirection.getOrientation(this.getBlockMetadata()) + .getOpposite() + : true; + } + + public ForgeDirection getDirection(IBlockAccess world, int x, int y, int z) { + return ForgeDirection.getOrientation(this.getBlockMetadata()); + } + + public void setDirection(World world, int x, int y, int z, + ForgeDirection facingDirection) { + this.worldObj.setBlockMetadataWithNotify( + this.xCoord, this.yCoord, this.zCoord, facingDirection.ordinal(), 2); + } +} diff --git a/src/main/java/calclavia/lib/TileEntityUniversalStorable.java b/src/main/java/calclavia/lib/TileEntityUniversalStorable.java new file mode 100644 index 0000000..a5a1978 --- /dev/null +++ b/src/main/java/calclavia/lib/TileEntityUniversalStorable.java @@ -0,0 +1,28 @@ +package calclavia.lib; + +import net.minecraft.world.IBlockAccess; +import net.minecraft.world.World; +import net.minecraftforge.common.util.ForgeDirection; +import universalelectricity.prefab.implement.IRotatable; +import universalelectricity.prefab.tile.TileEntityElectricityStorage; + +public abstract class TileEntityUniversalStorable + extends TileEntityElectricityStorage implements IUniversalEnergyTile { + @Override + public boolean canConnect(ForgeDirection direction) { + return this instanceof IRotatable + ? direction == ForgeDirection.getOrientation(this.getBlockMetadata()) + .getOpposite() + : true; + } + + public ForgeDirection getDirection(IBlockAccess world, int x, int y, int z) { + return ForgeDirection.getOrientation(this.getBlockMetadata()); + } + + public void setDirection(World world, int x, int y, int z, + ForgeDirection facingDirection) { + this.worldObj.setBlockMetadataWithNotify( + this.xCoord, this.yCoord, this.zCoord, facingDirection.ordinal(), 2); + } +} diff --git a/src/main/java/calclavia/lib/UniversalRecipes.java b/src/main/java/calclavia/lib/UniversalRecipes.java new file mode 100644 index 0000000..198b506 --- /dev/null +++ b/src/main/java/calclavia/lib/UniversalRecipes.java @@ -0,0 +1,102 @@ +package calclavia.lib; + +import cpw.mods.fml.common.FMLLog; +import java.util.Arrays; +import java.util.Iterator; +import java.util.List; +import net.minecraft.item.ItemStack; +import net.minecraftforge.oredict.OreDictionary; + +public class UniversalRecipes { + public static final String PRIMARY_METAL = "ingotSteel"; + public static final String PRIMARY_PLATE = "plateSteel"; + public static final String SECONDARY_METAL = "ingotBronze"; + public static final String SECONDARY_PLATE = "plateBronze"; + public static final String CIRCUIT_T1 = "calclavia:CIRCUIT_T1"; + public static final String CIRCUIT_T2 = "calclavia:CIRCUIT_T2"; + public static final String CIRCUIT_T3 = "calclavia:CIRCUIT_T3"; + public static String ADVANCED_BATTERY = "calclavia:ADVANCED_BATTERY"; + public static String BATTERY = "calclavia:BATTERY"; + public static String BATTERY_BOX = "calclavia:BATTERY_BOX"; + public static final String WRENCH = "calclavia:WRENCH"; + public static final String WIRE = "calclavia:WIRE"; + public static final String MOTOR = "calclavia:MOTOR"; + public static boolean isInit = false; + + public static void init() { + if (!isInit) { + // TODO: WTF + // register("calclavia:CIRCUIT_T1", new Object[]{"circuitBasic", + // Items.getItem("electronicCircuit"), new + // ItemStack(Blocks.redstone_torch)}); register("calclavia:CIRCUIT_T2", + // new Object[]{"circuitAdvanced", Items.getItem("advancedCircuit"), new + // ItemStack(Items.repeater)}); register("calclavia:CIRCUIT_T3", new + // Object[]{"circuitElite", Items.getItem("iridiumPlate"), new + // ItemStack(Block.field_94346_cn)}); register(ADVANCED_BATTERY, new + // Object[]{"advancedBattery", Items.getItem("energyCrystal"), "battery", + // new ItemStack(Items.repeater)}); register(BATTERY, new + // Object[]{"battery", Items.getItem("reBattery"), new + // ItemStack(Items.repeater)}); + // register(BATTERY_BOX, new Object[]{"batteryBox", + // Items.getItem("batBox"), new ItemStack(Block.field_72105_ah)}); + // register("calclavia:WRENCH", new Object[]{"wrench", + // Items.getItem("wrench"), new ItemStack(Item.field_77708_h)}); + // register("calclavia:WIRE", new Object[]{"copperWire", + // "copperCableBlock", new ItemStack(Item.field_77767_aC)}); + // register("calclavia:MOTOR", new Object[]{"motor", + // Items.getItem("generator"), new ItemStack(Block.field_71963_Z)}); + isInit = true; + } + } + + public static void register(String name, Object... possiblities) { + Object[] arr$ = possiblities; + int len$ = possiblities.length; + + for (int i$ = 0; i$ < len$; ++i$) { + Object possiblity = arr$[i$]; + if (possiblity instanceof ItemStack) { + if (registerItemStacksToDictionary( + name, new ItemStack[] {(ItemStack)possiblity})) { + break; + } + } else if (possiblity instanceof String) { + if (registerItemStacksToDictionary(name, (String)possiblity)) { + break; + } + } else { + FMLLog.severe("Universal Recipes: Error Registering " + name, + new Object[0]); + } + } + } + + public static boolean registerItemStacksToDictionary(String name, + List itemStacks) { + boolean returnValue = false; + if (itemStacks != null && itemStacks.size() > 0) { + Iterator i$ = itemStacks.iterator(); + + while (i$.hasNext()) { + ItemStack stack = (ItemStack)i$.next(); + if (stack != null) { + OreDictionary.registerOre(name, stack); + returnValue = true; + } + } + } + + return returnValue; + } + + public static boolean + registerItemStacksToDictionary(String name, ItemStack... itemStacks) { + return registerItemStacksToDictionary(name, Arrays.asList(itemStacks)); + } + + public static boolean registerItemStacksToDictionary(String name, + String stackName) { + return registerItemStacksToDictionary( + name, (List)OreDictionary.getOres(stackName)); + } +} diff --git a/src/main/java/calclavia/lib/gui/ContainerBase.java b/src/main/java/calclavia/lib/gui/ContainerBase.java new file mode 100644 index 0000000..d2c20d4 --- /dev/null +++ b/src/main/java/calclavia/lib/gui/ContainerBase.java @@ -0,0 +1,96 @@ +package calclavia.lib.gui; + +import calclavia.lib.IPlayerUsing; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.inventory.Container; +import net.minecraft.inventory.IInventory; +import net.minecraft.inventory.Slot; +import net.minecraft.item.ItemStack; + +public class ContainerBase extends Container { + + protected int slotCount = 0; + private IInventory inventory; + + + public ContainerBase(IInventory inventory) { + this.inventory = inventory; + this.slotCount = inventory.getSizeInventory(); + } + + public void onContainerClosed(EntityPlayer player) { + if(this.inventory instanceof IPlayerUsing) { + ((IPlayerUsing)this.inventory).getPlayersUsing().remove(player); + } + + } + + public void addPlayerInventory(EntityPlayer player) { + if(this.inventory instanceof IPlayerUsing) { + ((IPlayerUsing)this.inventory).getPlayersUsing().add(player); + } + + int var3; + for(var3 = 0; var3 < 3; ++var3) { + for(int var4 = 0; var4 < 9; ++var4) { + this.addSlotToContainer(new Slot(player.inventory, var4 + var3 * 9 + 9, 8 + var4 * 18, 135 + var3 * 18)); + } + } + + for(var3 = 0; var3 < 9; ++var3) { + this.addSlotToContainer(new Slot(player.inventory, var3, 8 + var3 * 18, 193)); + } + + } + + public ItemStack transferStackInSlot(EntityPlayer par1EntityPlayer, int slotID) { + ItemStack var2 = null; + Slot var3 = (Slot)super.inventorySlots.get(slotID); + if(var3 != null && var3.getHasStack()) { + ItemStack itemStack = var3.getStack(); + var2 = itemStack.copy(); + if(slotID >= this.slotCount) { + boolean didTry = false; + + for(int i = 0; i < this.slotCount; ++i) { + if(this.getSlot(i).isItemValid(itemStack)) { + didTry = true; + if(this.mergeItemStack(itemStack, i, i + 1, false)) { + break; + } + } + } + + if(!didTry) { + if(slotID < 27 + this.slotCount) { + if(!this.mergeItemStack(itemStack, 27 + this.slotCount, 36 + this.slotCount, false)) { + return null; + } + } else if(slotID >= 27 + this.slotCount && slotID < 36 + this.slotCount && !this.mergeItemStack(itemStack, this.slotCount, 27 + this.slotCount, false)) { + return null; + } + } + } else if(!this.mergeItemStack(itemStack, this.slotCount, 36 + this.slotCount, false)) { + return null; + } + + if(itemStack.stackSize == 0) { + var3.putStack((ItemStack)null); + } else { + var3.onSlotChanged(); + } + + if(itemStack.stackSize == var2.stackSize) { + return null; + } + + var3.onPickupFromSlot(par1EntityPlayer, itemStack); + } + + return var2; + } + + public boolean canInteractWith(EntityPlayer entityplayer) { + return this.inventory.isUseableByPlayer(entityplayer); + } +} diff --git a/src/main/java/calclavia/lib/gui/GuiContainerBase.java b/src/main/java/calclavia/lib/gui/GuiContainerBase.java new file mode 100644 index 0000000..8d2cad3 --- /dev/null +++ b/src/main/java/calclavia/lib/gui/GuiContainerBase.java @@ -0,0 +1,296 @@ +package calclavia.lib.gui; + +import calclavia.lib.Calclavia; +import java.util.HashMap; +import java.util.Map.Entry; +import net.minecraft.client.gui.GuiScreen; +import net.minecraft.client.gui.inventory.GuiContainer; +import net.minecraft.client.renderer.RenderHelper; +import net.minecraft.inventory.Container; +import net.minecraft.item.ItemStack; +import net.minecraft.util.IIcon; +import net.minecraft.util.ResourceLocation; +import net.minecraftforge.fluids.FluidStack; +import org.lwjgl.input.Keyboard; +import org.lwjgl.opengl.GL11; +import universalelectricity.core.vector.Vector2; +import universalelectricity.prefab.TranslationHelper; +import universalelectricity.prefab.vector.Region2; + +public class GuiContainerBase extends GuiContainer { + + //private static final int METER_X = 54; + public static final int METER_HEIGHT = 49; + public static final int METER_WIDTH = 14; + public static final int METER_END = 68; + public String tooltip = ""; + protected HashMap tooltips = new HashMap<>(); + protected int containerWidth; + protected int containerHeight; + + public GuiContainerBase(Container container) { + super(container); + this.ySize = 217; + } + + @Override + public void initGui() { + super.initGui(); + } + + @Override + public void onGuiClosed() { + Keyboard.enableRepeatEvents(false); + super.onGuiClosed(); + } + + @Override + protected void drawGuiContainerForegroundLayer(int mouseX, int mouseY) { + for (Entry entry : this.tooltips.entrySet()) { + if (((Region2)entry.getKey()) + .isIn(new Vector2((double)(mouseX - this.guiLeft), + (double)(mouseY - this.guiTop)))) { + this.tooltip = (String)entry.getValue(); + break; + } + } + + if (this.tooltip != null && this.tooltip != "") { + this.drawTooltip(mouseX - this.guiLeft, mouseY - this.guiTop, + (String[])Calclavia.splitStringPerWord(this.tooltip, 5) + .toArray(new String[0])); + } + + this.tooltip = ""; + } + + @Override + protected void drawGuiContainerBackgroundLayer(float var1, int x, int y) { + this.containerWidth = (this.width - this.xSize) / 2; + this.containerHeight = (this.height - this.ySize) / 2; + this.mc.renderEngine.bindTexture( + new ResourceLocation("calclavia", "textures/gui/gui_base.png")); + GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F); + this.drawTexturedModalRect(this.containerWidth, this.containerHeight, 0, 0, + this.xSize, this.ySize); + } + + protected void drawBulb(int x, int y, boolean isOn) { + this.mc.renderEngine.bindTexture( + new ResourceLocation("calclavia", "textures/gui/gui_base.png")); + GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F); + if (isOn) { + this.drawTexturedModalRect(this.containerWidth + x, + this.containerHeight + y, 161, 0, 6, 6); + } else { + this.drawTexturedModalRect(this.containerWidth + x, + this.containerHeight + y, 161, 4, 6, 6); + } + } + + protected void drawSlot(int x, int y, ItemStack itemStack) { + this.mc.renderEngine.bindTexture( + new ResourceLocation("calclavia", "textures/gui/gui_base.png")); + GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F); + this.drawTexturedModalRect(this.containerWidth + x, + this.containerHeight + y, 0, 0, 18, 18); + this.drawItemStack(itemStack, this.containerWidth + x, + this.containerHeight + y); + } + + protected void drawItemStack(ItemStack itemStack, int x, int y) { + ++x; + ++y; + GL11.glTranslatef(0.0F, 0.0F, 32.0F); + itemRender.renderItemAndEffectIntoGUI( + this.fontRendererObj, this.mc.renderEngine, itemStack, x, y); + } + + protected void drawTextWithTooltip(String textName, String format, int x, + int y, int mouseX, int mouseY) { + this.drawTextWithTooltip(textName, format, x, y, mouseX, mouseY, 4210752); + } + + protected void drawTextWithTooltip(String textName, String format, int x, + int y, int mouseX, int mouseY, int color) { + String name = TranslationHelper.getLocal("gui." + textName + ".name"); + String text = format.replaceAll("%1", name); + this.fontRendererObj.drawString(text, x, y, color); + String tooltip = TranslationHelper.getLocal("gui." + textName + ".tooltip"); + if (tooltip != null && tooltip != "" && + this.func_146978_c(x, y, (int)((double)text.length() * 4.8D), 12, + mouseX, mouseY)) { + this.tooltip = tooltip; + } + } + + protected void drawTextWithTooltip(String textName, int x, int y, int mouseX, + int mouseY) { + this.drawTextWithTooltip(textName, "%1", x, y, mouseX, mouseY); + } + + protected void drawSlot(int x, int y, GuiSlotType type, float r, float g, + float b) { + this.mc.renderEngine.bindTexture( + new ResourceLocation("calclavia", "textures/gui/gui_components.png")); + GL11.glColor4f(r, g, b, 1.0F); + this.drawTexturedModalRect(this.containerWidth + x, + this.containerHeight + y, 0, 0, 18, 18); + if (type != GuiSlotType.NONE) { + this.drawTexturedModalRect(this.containerWidth + x, + this.containerHeight + y, 0, + 18 * type.ordinal(), 18, 18); + } + } + + protected void drawSlot(int x, int y, GuiSlotType type) { + this.drawSlot(x, y, type, 1.0F, 1.0F, 1.0F); + } + + protected void drawSlot(int x, int y) { + this.drawSlot(x, y, GuiSlotType.NONE); + } + + protected void drawBar(int x, int y, float scale) { + this.mc.renderEngine.bindTexture( + new ResourceLocation("calclavia", "textures/gui/gui_components.png")); + GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F); + this.drawTexturedModalRect(this.containerWidth + x, + this.containerHeight + y, 18, 0, 22, 15); + if (scale > 0.0F) { + this.drawTexturedModalRect(this.containerWidth + x, + this.containerHeight + y, 18, 15, + 22 - (int)(scale * 22.0F), 15); + } + } + + protected void drawForce(int x, int y, float scale) { + this.mc.renderEngine.bindTexture( + new ResourceLocation("calclavia", "textures/gui/gui_components.png")); + GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F); + this.drawTexturedModalRect(this.containerWidth + x, + this.containerHeight + y, 54, 0, 107, 11); + if (scale > 0.0F) { + this.drawTexturedModalRect(this.containerWidth + x, + this.containerHeight + y, 54, 11, + (int)(scale * 107.0F), 11); + } + } + + protected void drawElectricity(int x, int y, float scale) { + this.mc.renderEngine.bindTexture( + new ResourceLocation("calclavia", "textures/gui/gui_components.png")); + GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F); + this.drawTexturedModalRect(this.containerWidth + x, + this.containerHeight + y, 54, 0, 107, 11); + if (scale > 0.0F) { + this.drawTexturedModalRect(this.containerWidth + x, + this.containerHeight + y, 54, 22, + (int)(scale * 107.0F), 11); + } + } + + protected void drawMeter(int x, int y, float scale, FluidStack liquidStack) { + this.mc.renderEngine.bindTexture( + new ResourceLocation("calclavia", "textures/gui/gui_base.png")); + GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F); + this.drawTexturedModalRect(this.containerWidth + x, + this.containerHeight + y, 40, 0, 14, 49); + this.displayGauge(this.containerWidth + x, this.containerHeight + y, 0, 0, + (int)(48.0F * scale), liquidStack); + this.mc.renderEngine.bindTexture( + new ResourceLocation("calclavia", "textures/gui/gui_base.png")); + this.drawTexturedModalRect(this.containerWidth + x, + this.containerHeight + y, 40, 98, 14, 49); + } + + public void drawTooltip(int x, int y, String... toolTips) { + if (!GuiScreen.isShiftKeyDown()) { + GL11.glDisable('\u803a'); + RenderHelper.disableStandardItemLighting(); + GL11.glDisable(2896); + GL11.glDisable(2929); + if (toolTips != null) { + int var5 = 0; + + int var6; + int var7; + for (var6 = 0; var6 < toolTips.length; ++var6) { + var7 = this.fontRendererObj.getStringWidth(toolTips[var6]); + if (var7 > var5) { + var5 = var7; + } + } + + var6 = x + 12; + var7 = y - 12; + int var9 = 8; + if (toolTips.length > 1) { + var9 += 2 + (toolTips.length - 1) * 10; + } + + if (this.guiTop + var7 + var9 + 6 > this.height) { + var7 = this.height - var9 - this.guiTop - 6; + } + + super.zLevel = 300.0F; + int var10 = -267386864; + this.drawGradientRect(var6 - 3, var7 - 4, var6 + var5 + 3, var7 - 3, + var10, var10); + this.drawGradientRect(var6 - 3, var7 + var9 + 3, var6 + var5 + 3, + var7 + var9 + 4, var10, var10); + this.drawGradientRect(var6 - 3, var7 - 3, var6 + var5 + 3, + var7 + var9 + 3, var10, var10); + this.drawGradientRect(var6 - 4, var7 - 3, var6 - 3, var7 + var9 + 3, + var10, var10); + this.drawGradientRect(var6 + var5 + 3, var7 - 3, var6 + var5 + 4, + var7 + var9 + 3, var10, var10); + int var11 = 1347420415; + int var12 = (var11 & 16711422) >> 1 | var11 & -16777216; + this.drawGradientRect(var6 - 3, var7 - 3 + 1, var6 - 3 + 1, + var7 + var9 + 3 - 1, var11, var12); + this.drawGradientRect(var6 + var5 + 2, var7 - 3 + 1, var6 + var5 + 3, + var7 + var9 + 3 - 1, var11, var12); + this.drawGradientRect(var6 - 3, var7 - 3, var6 + var5 + 3, var7 - 3 + 1, + var11, var11); + this.drawGradientRect(var6 - 3, var7 + var9 + 2, var6 + var5 + 3, + var7 + var9 + 3, var12, var12); + + for (int var13 = 0; var13 < toolTips.length; ++var13) { + String var14 = toolTips[var13]; + this.fontRendererObj.drawStringWithShadow(var14, var6, var7, -1); + var7 += 10; + } + + super.zLevel = 0.0F; + GL11.glEnable(2929); + GL11.glEnable(2896); + RenderHelper.enableGUIStandardItemLighting(); + GL11.glEnable('\u803a'); + } + } + } + + protected void displayGauge(int j, int k, int line, int col, int squaled, + FluidStack liquid) { + if (liquid != null) { + int start = 0; + IIcon liquidIcon = liquid.getFluid().getIcon(); + + int x1; + do { + if (squaled > 16) { + x1 = 16; + squaled -= 16; + } else { + x1 = squaled; + squaled = 0; + } + + this.drawTexturedModelRectFromIcon(j + col, k + line + 58 - x1 - start, + liquidIcon, 16, 16 - (16 - x1)); + start += 16; + } while (x1 != 0 && squaled != 0); + } + } +} diff --git a/src/main/java/calclavia/lib/gui/GuiScreenBase.java b/src/main/java/calclavia/lib/gui/GuiScreenBase.java new file mode 100644 index 0000000..10e570a --- /dev/null +++ b/src/main/java/calclavia/lib/gui/GuiScreenBase.java @@ -0,0 +1,271 @@ +package calclavia.lib.gui; + +import calclavia.lib.Calclavia; +import java.util.HashMap; +import java.util.Map.Entry; +import net.minecraft.client.gui.GuiScreen; +import net.minecraft.client.renderer.RenderHelper; +import net.minecraft.util.IIcon; +import net.minecraft.util.ResourceLocation; +import net.minecraftforge.fluids.FluidStack; +import org.lwjgl.opengl.GL11; +import universalelectricity.core.vector.Vector2; +import universalelectricity.prefab.GuiBase; +import universalelectricity.prefab.TranslationHelper; +import universalelectricity.prefab.vector.Region2; + +public class GuiScreenBase extends GuiBase { + + // private static final int METER_X = 54; + public static final int METER_HEIGHT = 49; + public static final int METER_WIDTH = 14; + public static final int METER_END = 68; + public String tooltip = ""; + protected HashMap tooltips = new HashMap<>(); + protected int containerWidth; + protected int containerHeight; + + public GuiScreenBase() { super.ySize = 217; } + + @Override + protected void drawForegroundLayer(int mouseX, int mouseY, float var1) { + for (Entry entry : this.tooltips.entrySet()) { + if (((Region2)entry.getKey()) + .isIn(new Vector2((double)(mouseX - this.guiLeft), + (double)(mouseY - this.guiTop)))) { + this.tooltip = (String)entry.getValue(); + break; + } + } + + if (this.tooltip != null && this.tooltip != "") { + this.drawTooltip(mouseX - this.guiLeft, mouseY - this.guiTop, + (String[])Calclavia.splitStringPerWord(this.tooltip, 5) + .toArray(new String[0])); + } + + this.tooltip = ""; + } + + @Override + protected void drawBackgroundLayer(int x, int y, float var1) { + this.containerWidth = (this.width - this.xSize) / 2; + this.containerHeight = (this.height - this.ySize) / 2; + this.mc.renderEngine.bindTexture( + new ResourceLocation("calclavia", "textures/gui/gui_base.png")); + GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F); + this.drawTexturedModalRect(this.containerWidth, this.containerHeight, 0, 0, + this.xSize, this.ySize); + } + + protected void drawBulb(int x, int y, boolean isOn) { + this.mc.renderEngine.bindTexture( + new ResourceLocation("calclavia", "textures/gui/gui_base.png")); + GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F); + if (isOn) { + this.drawTexturedModalRect(this.containerWidth + x, + this.containerHeight + y, 161, 0, 6, 6); + } else { + this.drawTexturedModalRect(this.containerWidth + x, + this.containerHeight + y, 161, 4, 6, 6); + } + } + + protected void drawTextWithTooltip(String textName, String format, int x, + int y, int mouseX, int mouseY) { + this.drawTextWithTooltip(textName, format, x, y, mouseX, mouseY, 4210752); + } + + protected void drawTextWithTooltip(String textName, String format, int x, + int y, int mouseX, int mouseY, int color) { + String name = TranslationHelper.getLocal("gui." + textName + ".name"); + String text = format.replaceAll("%1", name); + this.fontRendererObj.drawString(text, x, y, color); + String tooltip = TranslationHelper.getLocal("gui." + textName + ".tooltip"); + if (tooltip != null && tooltip != "" && + this.isPointInRegion(x, y, (int)((double)text.length() * 4.8D), 12, + mouseX, mouseY)) { + this.tooltip = tooltip; + } + } + + protected boolean isPointInRegion(int par1, int par2, int par3, int par4, + int par5, int par6) { + int k1 = super.guiLeft; + int l1 = super.guiTop; + par5 -= k1; + par6 -= l1; + return par5 >= par1 - 1 && par5 < par1 + par3 + 1 && par6 >= par2 - 1 && + par6 < par2 + par4 + 1; + } + + protected void drawTextWithTooltip(String textName, int x, int y, int mouseX, + int mouseY) { + this.drawTextWithTooltip(textName, "%1", x, y, mouseX, mouseY); + } + + protected void drawSlot(int x, int y, GuiSlotType type, float r, float g, + float b) { + this.mc.renderEngine.bindTexture( + new ResourceLocation("calclavia", "textures/gui/gui_empty.png")); + GL11.glColor4f(r, g, b, 1.0F); + this.drawTexturedModalRect(this.containerWidth + x, + this.containerHeight + y, 0, 0, 18, 18); + if (type != GuiSlotType.NONE) { + this.drawTexturedModalRect(this.containerWidth + x, + this.containerHeight + y, 0, + 18 * type.ordinal(), 18, 18); + } + } + + protected void drawSlot(int x, int y, GuiSlotType type) { + this.drawSlot(x, y, type, 1.0F, 1.0F, 1.0F); + } + + protected void drawSlot(int x, int y) { + this.drawSlot(x, y, GuiSlotType.NONE); + } + + protected void drawBar(int x, int y, float scale) { + this.mc.renderEngine.bindTexture( + new ResourceLocation("calclavia", "textures/gui/gui_empty.png")); + GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F); + this.drawTexturedModalRect(this.containerWidth + x, + this.containerHeight + y, 18, 0, 22, 15); + if (scale > 0.0F) { + this.drawTexturedModalRect(this.containerWidth + x, + this.containerHeight + y, 18, 15, + 22 - (int)(scale * 22.0F), 15); + } + } + + protected void drawForce(int x, int y, float scale) { + this.mc.renderEngine.bindTexture( + new ResourceLocation("calclavia", "textures/gui/gui_empty.png")); + GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F); + this.drawTexturedModalRect(this.containerWidth + x, + this.containerHeight + y, 54, 0, 107, 11); + if (scale > 0.0F) { + this.drawTexturedModalRect(this.containerWidth + x, + this.containerHeight + y, 54, 11, + (int)(scale * 107.0F), 11); + } + } + + protected void drawElectricity(int x, int y, float scale) { + this.mc.renderEngine.bindTexture( + new ResourceLocation("calclavia", "textures/gui/gui_empty.png")); + GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F); + this.drawTexturedModalRect(this.containerWidth + x, + this.containerHeight + y, 54, 0, 107, 11); + if (scale > 0.0F) { + this.drawTexturedModalRect(this.containerWidth + x, + this.containerHeight + y, 54, 22, + (int)(scale * 107.0F), 11); + } + } + + protected void drawMeter(int x, int y, float scale, FluidStack liquidStack) { + this.mc.renderEngine.bindTexture( + new ResourceLocation("calclavia", "textures/gui/gui_empty.png")); + GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F); + this.drawTexturedModalRect(this.containerWidth + x, + this.containerHeight + y, 40, 0, 14, 49); + this.displayGauge(this.containerWidth + x, this.containerHeight + y, 0, 0, + (int)(48.0F * scale), liquidStack); + this.mc.renderEngine.bindTexture( + new ResourceLocation("calclavia", "textures/gui/gui_empty.png")); + this.drawTexturedModalRect(this.containerWidth + x, + this.containerHeight + y, 40, 98, 14, 49); + } + + public void drawTooltip(int x, int y, String... toolTips) { + if (!GuiScreen.isShiftKeyDown()) { + GL11.glDisable('\u803a'); + RenderHelper.disableStandardItemLighting(); + GL11.glDisable(2896); + GL11.glDisable(2929); + if (toolTips != null) { + int var5 = 0; + + int var6; + int var7; + for (var6 = 0; var6 < toolTips.length; ++var6) { + var7 = this.fontRendererObj.getStringWidth(toolTips[var6]); + if (var7 > var5) { + var5 = var7; + } + } + + var6 = x + 12; + var7 = y - 12; + int var9 = 8; + if (toolTips.length > 1) { + var9 += 2 + (toolTips.length - 1) * 10; + } + + if (super.guiTop + var7 + var9 + 6 > this.height) { + var7 = this.height - var9 - super.guiTop - 6; + } + + super.zLevel = 300.0F; + int var10 = -267386864; + this.drawGradientRect(var6 - 3, var7 - 4, var6 + var5 + 3, var7 - 3, + var10, var10); + this.drawGradientRect(var6 - 3, var7 + var9 + 3, var6 + var5 + 3, + var7 + var9 + 4, var10, var10); + this.drawGradientRect(var6 - 3, var7 - 3, var6 + var5 + 3, + var7 + var9 + 3, var10, var10); + this.drawGradientRect(var6 - 4, var7 - 3, var6 - 3, var7 + var9 + 3, + var10, var10); + this.drawGradientRect(var6 + var5 + 3, var7 - 3, var6 + var5 + 4, + var7 + var9 + 3, var10, var10); + int var11 = 1347420415; + int var12 = (var11 & 16711422) >> 1 | var11 & -16777216; + this.drawGradientRect(var6 - 3, var7 - 3 + 1, var6 - 3 + 1, + var7 + var9 + 3 - 1, var11, var12); + this.drawGradientRect(var6 + var5 + 2, var7 - 3 + 1, var6 + var5 + 3, + var7 + var9 + 3 - 1, var11, var12); + this.drawGradientRect(var6 - 3, var7 - 3, var6 + var5 + 3, var7 - 3 + 1, + var11, var11); + this.drawGradientRect(var6 - 3, var7 + var9 + 2, var6 + var5 + 3, + var7 + var9 + 3, var12, var12); + + for (int var13 = 0; var13 < toolTips.length; ++var13) { + String var14 = toolTips[var13]; + this.fontRendererObj.drawStringWithShadow(var14, var6, var7, -1); + var7 += 10; + } + + super.zLevel = 0.0F; + GL11.glEnable(2929); + GL11.glEnable(2896); + RenderHelper.enableGUIStandardItemLighting(); + GL11.glEnable('\u803a'); + } + } + } + + protected void displayGauge(int j, int k, int line, int col, int squaled, + FluidStack liquid) { + if (liquid != null) { + int start = 0; + IIcon liquidIcon = liquid.getFluid().getIcon(); + + int x1; + do { + if (squaled > 16) { + x1 = 16; + squaled -= 16; + } else { + x1 = squaled; + squaled = 0; + } + + this.drawTexturedModelRectFromIcon(j + col, k + line + 58 - x1 - start, + liquidIcon, 16, 16 - (16 - x1)); + start += 16; + } while (x1 != 0 && squaled != 0); + } + } +} diff --git a/src/main/java/calclavia/lib/gui/GuiSlotType.java b/src/main/java/calclavia/lib/gui/GuiSlotType.java new file mode 100644 index 0000000..02757f0 --- /dev/null +++ b/src/main/java/calclavia/lib/gui/GuiSlotType.java @@ -0,0 +1,23 @@ +package calclavia.lib.gui; + + +public enum GuiSlotType { + + NONE("NONE", 0), + BATTERY("BATTERY", 1), + LIQUID("LIQUID", 2), + ARR_UP("ARR_UP", 3), + ARR_DOWN("ARR_DOWN", 4), + ARR_LEFT("ARR_LEFT", 5), + ARR_RIGHT("ARR_RIGHT", 6), + ARR_UP_RIGHT("ARR_UP_RIGHT", 7), + ARR_UP_LEFT("ARR_UP_LEFT", 8), + ARR_DOWN_LEFT("ARR_DOWN_LEFT", 9), + ARR_DOWN_RIGHT("ARR_DOWN_RIGHT", 10); + // $FF: synthetic field + private static final GuiSlotType[] $VALUES = new GuiSlotType[]{NONE, BATTERY, LIQUID, ARR_UP, ARR_DOWN, ARR_LEFT, ARR_RIGHT, ARR_UP_RIGHT, ARR_UP_LEFT, ARR_DOWN_LEFT, ARR_DOWN_RIGHT}; + + + private GuiSlotType(String var1, int var2) {} + +} diff --git a/src/main/java/calclavia/lib/render/CalclaviaRenderHelper.java b/src/main/java/calclavia/lib/render/CalclaviaRenderHelper.java new file mode 100644 index 0000000..120743d --- /dev/null +++ b/src/main/java/calclavia/lib/render/CalclaviaRenderHelper.java @@ -0,0 +1,111 @@ +package calclavia.lib.render; + +import net.minecraft.block.Block; +import net.minecraft.client.gui.FontRenderer; +import net.minecraft.client.renderer.OpenGlHelper; +import net.minecraft.client.renderer.RenderBlocks; +import net.minecraft.client.renderer.RenderHelper; +import net.minecraft.client.renderer.Tessellator; +import net.minecraft.client.renderer.entity.RenderManager; +import org.lwjgl.opengl.GL11; + +public class CalclaviaRenderHelper { + + public static void enableBlending() { + GL11.glShadeModel(7425); + GL11.glEnable(3042); + GL11.glBlendFunc(770, 771); + } + + public static void disableBlending() { + GL11.glShadeModel(7424); + GL11.glDisable(2848); + GL11.glDisable(2881); + GL11.glDisable(3042); + } + + public static void enableLighting() { + RenderHelper.enableStandardItemLighting(); + } + + public static void disableLighting() { + RenderHelper.disableStandardItemLighting(); + OpenGlHelper.setLightmapTextureCoords(OpenGlHelper.lightmapTexUnit, 240.0F, 240.0F); + } + + public static void renderNormalBlockAsItem(Block block, int metadata, RenderBlocks renderer) { + Tessellator tessellator = Tessellator.instance; + block.setBlockBoundsForItemRender(); + renderer.setRenderBoundsFromBlock(block); + GL11.glRotatef(90.0F, 0.0F, 1.0F, 0.0F); + GL11.glTranslatef(-0.5F, -0.5F, -0.5F); + tessellator.startDrawingQuads(); + tessellator.setNormal(0.0F, -1.0F, 0.0F); + renderer.renderFaceYNeg(block, 0.0D, 0.0D, 0.0D, renderer.getBlockIconFromSideAndMetadata(block, 0, metadata)); + tessellator.draw(); + tessellator.startDrawingQuads(); + tessellator.setNormal(0.0F, 1.0F, 0.0F); + renderer.renderFaceYPos(block, 0.0D, 0.0D, 0.0D, renderer.getBlockIconFromSideAndMetadata(block, 1, metadata)); + tessellator.draw(); + tessellator.startDrawingQuads(); + tessellator.setNormal(0.0F, 0.0F, -1.0F); + renderer.renderFaceZNeg(block, 0.0D, 0.0D, 0.0D, renderer.getBlockIconFromSideAndMetadata(block, 2, metadata)); + tessellator.draw(); + tessellator.startDrawingQuads(); + tessellator.setNormal(0.0F, 0.0F, 1.0F); + renderer.renderFaceZPos(block, 0.0D, 0.0D, 0.0D, renderer.getBlockIconFromSideAndMetadata(block, 3, metadata)); + tessellator.draw(); + tessellator.startDrawingQuads(); + tessellator.setNormal(-1.0F, 0.0F, 0.0F); + renderer.renderFaceXNeg(block, 0.0D, 0.0D, 0.0D, renderer.getBlockIconFromSideAndMetadata(block, 4, metadata)); + tessellator.draw(); + tessellator.startDrawingQuads(); + tessellator.setNormal(1.0F, 0.0F, 0.0F); + renderer.renderFaceXPos(block, 0.0D, 0.0D, 0.0D, renderer.getBlockIconFromSideAndMetadata(block, 5, metadata)); + tessellator.draw(); + GL11.glTranslatef(0.5F, 0.5F, 0.5F); + } + + public static void renderFloatingText(String text, float x, float y, float z) { + renderFloatingText(text, x, y, z, 16777215); + } + + public static void renderFloatingText(String text, float x, float y, float z, int color) { + RenderManager renderManager = RenderManager.instance; + FontRenderer fontRenderer = renderManager.getFontRenderer(); + float scale = 0.027F; + GL11.glColor4f(1.0F, 1.0F, 1.0F, 0.5F); + GL11.glPushMatrix(); + GL11.glTranslatef(x + 0.0F, y + 2.3F, z); + GL11.glNormal3f(0.0F, 1.0F, 0.0F); + GL11.glRotatef(-renderManager.playerViewY, 0.0F, 1.0F, 0.0F); + GL11.glRotatef(renderManager.playerViewX, 1.0F, 0.0F, 0.0F); + GL11.glScalef(-scale, -scale, scale); + GL11.glDisable(2896); + GL11.glDepthMask(false); + GL11.glDisable(2929); + GL11.glEnable(3042); + GL11.glBlendFunc(770, 771); + Tessellator tessellator = Tessellator.instance; + byte yOffset = 0; + GL11.glDisable(3553); + tessellator.startDrawingQuads(); + int stringMiddle = fontRenderer.getStringWidth(text) / 2; + tessellator.setColorRGBA_F(0.0F, 0.0F, 0.0F, 0.5F); + tessellator.addVertex((double)(-stringMiddle - 1), (double)(-1 + yOffset), 0.0D); + tessellator.addVertex((double)(-stringMiddle - 1), (double)(8 + yOffset), 0.0D); + tessellator.addVertex((double)(stringMiddle + 1), (double)(8 + yOffset), 0.0D); + tessellator.addVertex((double)(stringMiddle + 1), (double)(-1 + yOffset), 0.0D); + tessellator.draw(); + GL11.glEnable(3553); + GL11.glColor4f(1.0F, 1.0F, 1.0F, 0.5F); + fontRenderer.drawString(text, -fontRenderer.getStringWidth(text) / 2, yOffset, color); + GL11.glEnable(2929); + GL11.glDepthMask(true); + fontRenderer.drawString(text, -fontRenderer.getStringWidth(text) / 2, yOffset, color); + GL11.glEnable(2896); + GL11.glDisable(3042); + GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F); + GL11.glPopMatrix(); + } +} diff --git a/src/main/java/calclavia/lib/render/ITagRender.java b/src/main/java/calclavia/lib/render/ITagRender.java new file mode 100644 index 0000000..dad2bb7 --- /dev/null +++ b/src/main/java/calclavia/lib/render/ITagRender.java @@ -0,0 +1,9 @@ +package calclavia.lib.render; + +import java.util.HashMap; +import net.minecraft.entity.player.EntityPlayer; + +public interface ITagRender { + + float addInformation(HashMap var1, EntityPlayer var2); +} diff --git a/src/main/java/calclavia/lib/render/RenderTaggedTile.java b/src/main/java/calclavia/lib/render/RenderTaggedTile.java new file mode 100644 index 0000000..bd1c55c --- /dev/null +++ b/src/main/java/calclavia/lib/render/RenderTaggedTile.java @@ -0,0 +1,64 @@ +package calclavia.lib.render; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import java.util.HashMap; +import java.util.Iterator; +import java.util.Map.Entry; +import net.minecraft.client.Minecraft; +import net.minecraft.client.entity.EntityClientPlayerMP; +import net.minecraft.client.renderer.entity.RendererLivingEntity; +import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer; +import net.minecraft.entity.EntityLivingBase; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.MovingObjectPosition; + +@SideOnly(Side.CLIENT) +public abstract class RenderTaggedTile extends TileEntitySpecialRenderer { + @Override + public void renderTileEntityAt(TileEntity t, double x, double y, double z, + float f) { + if (t != null && t instanceof ITagRender && + this.getPlayer().getDistance((double)t.xCoord, (double)t.yCoord, + (double)t.zCoord) <= + (double)RendererLivingEntity.NAME_TAG_RANGE) { + HashMap tags = new HashMap(); + float height = ((ITagRender)t).addInformation(tags, this.getPlayer()); + EntityClientPlayerMP player = Minecraft.getMinecraft().thePlayer; + if (player.ridingEntity == null) { + MovingObjectPosition objectPosition = player.rayTrace(8.0D, 1.0F); + if (objectPosition != null) { + boolean isLooking = false; + + for (int it = 0; (float)it < height; ++it) { + if (objectPosition.blockX == t.xCoord && + objectPosition.blockY == t.yCoord + it && + objectPosition.blockZ == t.zCoord) { + isLooking = true; + } + } + + if (isLooking) { + Iterator var17 = tags.entrySet().iterator(); + + for (int i = 0; var17.hasNext(); ++i) { + Entry entry = (Entry)var17.next(); + if (entry.getKey() != null) { + CalclaviaRenderHelper.renderFloatingText( + (String)entry.getKey(), (float)x + 0.5F, + (float)y + (float)i * 0.25F - 2.0F + height, + (float)z + 0.5F, ((Integer)entry.getValue()).intValue()); + } + } + } + } + } + } + } + + public EntityPlayer getPlayer() { + EntityLivingBase entity = this.field_147501_a.field_147551_g; + return entity instanceof EntityPlayer ? (EntityPlayer)entity : null; + } +} diff --git a/src/main/java/icbm/api/IAmmunition.java b/src/main/java/icbm/api/IAmmunition.java new file mode 100644 index 0000000..34b3071 --- /dev/null +++ b/src/main/java/icbm/api/IAmmunition.java @@ -0,0 +1,10 @@ +package icbm.api; + +import net.minecraft.item.ItemStack; + +public interface IAmmunition { + + boolean hasAmmunition(ItemStack var1); + + boolean useAmmunition(ItemStack var1); +} diff --git a/src/main/java/icbm/api/IBlockFrequency.java b/src/main/java/icbm/api/IBlockFrequency.java new file mode 100644 index 0000000..d831270 --- /dev/null +++ b/src/main/java/icbm/api/IBlockFrequency.java @@ -0,0 +1,9 @@ +package icbm.api; + + +public interface IBlockFrequency { + + int getFrequency(); + + void setFrequency(int var1); +} diff --git a/src/main/java/icbm/api/ICBM.java b/src/main/java/icbm/api/ICBM.java new file mode 100644 index 0000000..5e8e014 --- /dev/null +++ b/src/main/java/icbm/api/ICBM.java @@ -0,0 +1,41 @@ +package icbm.api; + +import icbm.api.explosion.IExplosive; +import java.lang.reflect.Method; +import net.minecraft.entity.Entity; +import net.minecraft.world.World; + +public class ICBM { + + public static final String NAME = "ICBM"; + public static final String VERSION = "1.1.1"; + public static final int BLOCK_ID_PREFIX = 3880; + public static final int ITEM_ID_PREFIX = 3900; + public static Class explosionManager; + + + public static void createExplosion(World worldObj, double x, double y, double z, Entity entity, int explosiveID) { + try { + Method e = explosionManager.getMethod("createExplosion", new Class[]{World.class, Double.class, Double.class, Double.class, Entity.class, Integer.class}); + e.invoke((Object)null, new Object[]{worldObj, Double.valueOf(x), Double.valueOf(y), Double.valueOf(z), entity, Integer.valueOf(explosiveID)}); + } catch (Exception var10) { + System.out.println("ICBM: Failed to create an ICBM explosion with the ID: " + explosiveID); + var10.printStackTrace(); + } + + } + + public static IExplosive getExplosive(String name) { + if(name != null) { + try { + Method e = explosionManager.getMethod("getExplosiveByName", new Class[]{String.class}); + return (IExplosive)e.invoke((Object)null, new Object[]{name}); + } catch (Exception var2) { + System.out.println("ICBM: Failed to get explosive with the name: " + name); + var2.printStackTrace(); + } + } + + return null; + } +} diff --git a/src/main/java/icbm/api/ICBMFlags.java b/src/main/java/icbm/api/ICBMFlags.java new file mode 100644 index 0000000..03ab58c --- /dev/null +++ b/src/main/java/icbm/api/ICBMFlags.java @@ -0,0 +1,15 @@ +package icbm.api; + +public class ICBMFlags { + // TODO: WTF + // public static final String FLAG_BAN_GLOBAL = + // FlagRegistry.registerFlag("ban_icbm"); + // public static final String FLAG_BAN_EXPLOSIVE = + // FlagRegistry.registerFlag("ban_explosive"); + // public static final String FLAG_BAN_GRENADE = + // FlagRegistry.registerFlag("ban_grenade"); + // public static final String FLAG_BAN_MISSILE = + // FlagRegistry.registerFlag("ban_missile"); + // public static final String FLAG_BAN_MINECART = + // FlagRegistry.registerFlag("ban_minecart"); +} diff --git a/src/main/java/icbm/api/ICamouflageMaterial.java b/src/main/java/icbm/api/ICamouflageMaterial.java new file mode 100644 index 0000000..d47aebb --- /dev/null +++ b/src/main/java/icbm/api/ICamouflageMaterial.java @@ -0,0 +1,5 @@ +package icbm.api; + + +public interface ICamouflageMaterial { +} diff --git a/src/main/java/icbm/api/IHackable.java b/src/main/java/icbm/api/IHackable.java new file mode 100644 index 0000000..63d4909 --- /dev/null +++ b/src/main/java/icbm/api/IHackable.java @@ -0,0 +1,10 @@ +package icbm.api; + +import net.minecraft.entity.player.EntityPlayer; + +public interface IHackable { + + void generateNewKey(); + + boolean tryForAccess(EntityPlayer var1, String var2); +} diff --git a/src/main/java/icbm/api/IItemFrequency.java b/src/main/java/icbm/api/IItemFrequency.java new file mode 100644 index 0000000..3ac4618 --- /dev/null +++ b/src/main/java/icbm/api/IItemFrequency.java @@ -0,0 +1,10 @@ +package icbm.api; + +import net.minecraft.item.ItemStack; + +public interface IItemFrequency { + + int getFrequency(ItemStack var1); + + void setFrequency(int var1, ItemStack var2); +} diff --git a/src/main/java/icbm/api/ILauncherContainer.java b/src/main/java/icbm/api/ILauncherContainer.java new file mode 100644 index 0000000..a462a3b --- /dev/null +++ b/src/main/java/icbm/api/ILauncherContainer.java @@ -0,0 +1,13 @@ +package icbm.api; + +import icbm.api.ILauncherController; +import icbm.api.IMissile; + +public interface ILauncherContainer { + + IMissile getContainingMissile(); + + void setContainingMissile(IMissile var1); + + ILauncherController getController(); +} diff --git a/src/main/java/icbm/api/ILauncherController.java b/src/main/java/icbm/api/ILauncherController.java new file mode 100644 index 0000000..cdb9bb0 --- /dev/null +++ b/src/main/java/icbm/api/ILauncherController.java @@ -0,0 +1,28 @@ +package icbm.api; + +import icbm.api.IBlockFrequency; +import icbm.api.IMissile; +import icbm.api.LauncherType; +import net.minecraft.item.ItemStack; +import universalelectricity.core.block.IElectricityStorage; +import universalelectricity.core.vector.Vector3; +import universalelectricity.prefab.implement.IRedstoneReceptor; + +public interface ILauncherController extends IElectricityStorage, IRedstoneReceptor, IBlockFrequency { + + LauncherType getLauncherType(); + + void launch(); + + boolean canLaunch(); + + String getStatus(); + + Vector3 getTarget(); + + void setTarget(Vector3 var1); + + void placeMissile(ItemStack var1); + + IMissile getMissile(); +} diff --git a/src/main/java/icbm/api/IMissile.java b/src/main/java/icbm/api/IMissile.java new file mode 100644 index 0000000..6ea09cd --- /dev/null +++ b/src/main/java/icbm/api/IMissile.java @@ -0,0 +1,26 @@ +package icbm.api; + +import icbm.api.ILauncherContainer; +import icbm.api.explosion.IExplosiveContainer; +import universalelectricity.core.vector.Vector3; + +public interface IMissile extends IExplosiveContainer { + + void explode(); + + void setExplode(); + + void normalExplode(); + + void setNormalExplode(); + + void dropMissileAsItem(); + + int getTicksInAir(); + + ILauncherContainer getLauncher(); + + void launch(Vector3 var1); + + void launch(Vector3 var1, int var2); +} diff --git a/src/main/java/icbm/api/IMissileLockable.java b/src/main/java/icbm/api/IMissileLockable.java new file mode 100644 index 0000000..4474c02 --- /dev/null +++ b/src/main/java/icbm/api/IMissileLockable.java @@ -0,0 +1,11 @@ +package icbm.api; + +import icbm.api.IMissile; +import universalelectricity.core.vector.Vector3; + +public interface IMissileLockable { + + boolean canLock(IMissile var1); + + Vector3 getPredictedPosition(int var1); +} diff --git a/src/main/java/icbm/api/LauncherType.java b/src/main/java/icbm/api/LauncherType.java new file mode 100644 index 0000000..1c8d1c3 --- /dev/null +++ b/src/main/java/icbm/api/LauncherType.java @@ -0,0 +1,14 @@ +package icbm.api; + + +public enum LauncherType { + + TRADITIONAL("TRADITIONAL", 0), + CRUISE("CRUISE", 1); + // $FF: synthetic field + private static final LauncherType[] $VALUES = new LauncherType[]{TRADITIONAL, CRUISE}; + + + private LauncherType(String var1, int var2) {} + +} diff --git a/src/main/java/icbm/api/RadarRegistry.java b/src/main/java/icbm/api/RadarRegistry.java new file mode 100644 index 0000000..83b2bb9 --- /dev/null +++ b/src/main/java/icbm/api/RadarRegistry.java @@ -0,0 +1,110 @@ +package icbm.api; + +import java.util.ArrayList; +import java.util.HashSet; +import java.util.Iterator; +import java.util.List; +import java.util.Set; +import net.minecraft.entity.Entity; +import net.minecraft.tileentity.TileEntity; +import universalelectricity.core.vector.Vector2; +import universalelectricity.core.vector.Vector3; +import universalelectricity.prefab.vector.Region2; + +public class RadarRegistry { + private static Set detectableTileEntities = new HashSet<>(); + private static Set detectableEntities = new HashSet<>(); + + public static void register(TileEntity tileEntity) { + if (!detectableTileEntities.contains(tileEntity)) { + detectableTileEntities.add(tileEntity); + } + } + + public static void unregister(TileEntity tileEntity) { + if (detectableTileEntities.contains(tileEntity)) { + detectableTileEntities.remove(tileEntity); + } + } + + public static void register(Entity entity) { + if (!detectableEntities.contains(entity)) { + detectableEntities.add(entity); + } + } + + public static void unregister(Entity entity) { + if (detectableEntities.contains(entity)) { + detectableEntities.remove(entity); + } + } + + public static List getTileEntitiesInArea(Vector2 minVector, + Vector2 maxVector) { + ArrayList returnArray = new ArrayList<>(); + cleanUpArray(); + for (TileEntity tileEntity : detectableTileEntities) { + if ((new Region2(minVector, maxVector)) + .isIn((new Vector3(tileEntity)).toVector2())) { + returnArray.add(tileEntity); + } + } + + return returnArray; + } + + public static List getEntitiesWithinRadius(Vector2 vector, + int radius) { + cleanUpArray(); + ArrayList returnArray = new ArrayList<>(); + for (Entity entity : detectableEntities) { + if (Vector2.distance(vector, (new Vector3(entity)).toVector2()) <= + (double)radius) { + returnArray.add(entity); + } + } + + return returnArray; + } + + public static Set getTileEntities() { + cleanUpArray(); + return detectableTileEntities; + } + + public static Set getEntities() { + cleanUpArray(); + return detectableEntities; + } + + public static void cleanUpArray() { + try { + Iterator e = detectableTileEntities.iterator(); + + while (e.hasNext()) { + TileEntity it2 = e.next(); + if (it2 == null) { + e.remove(); + } else if (it2.isInvalid()) { + e.remove(); + } else if (it2.getWorldObj().getTileEntity(it2.xCoord, it2.yCoord, + it2.zCoord) != it2) { + e.remove(); + } + } + + Iterator it21 = detectableEntities.iterator(); + while (it21.hasNext()) { + Entity entity = (Entity)it21.next(); + if (entity == null) { + it21.remove(); + } else if (entity.isDead) { + it21.remove(); + } + } + } catch (Exception var3) { + System.out.println("Failed to clean up radar list properly."); + var3.printStackTrace(); + } + } +} diff --git a/src/main/java/icbm/api/explosion/ExplosionEvent.java b/src/main/java/icbm/api/explosion/ExplosionEvent.java new file mode 100644 index 0000000..b3fd936 --- /dev/null +++ b/src/main/java/icbm/api/explosion/ExplosionEvent.java @@ -0,0 +1,36 @@ +package icbm.api.explosion; + +import cpw.mods.fml.common.eventhandler.Event; +import net.minecraft.world.World; + +public class ExplosionEvent extends Event { + + public final World world; + public final double x; + public final double y; + public final double z; + public IExplosive explosive; + + + public ExplosionEvent(World world, double x, double y, double z, IExplosive explosive) { + this.world = world; + this.x = x; + this.y = y; + this.z = z; + this.explosive = explosive; + } + + public static class PostExplosionEvent extends ExplosionEvent { + + public PostExplosionEvent(World world, double x, double y, double z, IExplosive explosive) { + super(world, x, y, z, explosive); + } + } + + public static class PreExplosionEvent extends ExplosionEvent { + + public PreExplosionEvent(World world, double x, double y, double z, IExplosive explosive) { + super(world, x, y, z, explosive); + } + } +} diff --git a/src/main/java/icbm/api/explosion/IEMPBlock.java b/src/main/java/icbm/api/explosion/IEMPBlock.java new file mode 100644 index 0000000..c74d838 --- /dev/null +++ b/src/main/java/icbm/api/explosion/IEMPBlock.java @@ -0,0 +1,10 @@ +package icbm.api.explosion; + +import icbm.api.explosion.IExplosive; +import net.minecraft.world.World; +import universalelectricity.core.vector.Vector3; + +public interface IEMPBlock { + + void onEMP(World var1, Vector3 var2, IExplosive var3); +} diff --git a/src/main/java/icbm/api/explosion/IEMPItem.java b/src/main/java/icbm/api/explosion/IEMPItem.java new file mode 100644 index 0000000..32b4e4a --- /dev/null +++ b/src/main/java/icbm/api/explosion/IEMPItem.java @@ -0,0 +1,11 @@ +package icbm.api.explosion; + +import icbm.api.explosion.IExplosive; +import net.minecraft.entity.Entity; +import net.minecraft.item.ItemStack; +import universalelectricity.core.item.IItemElectric; + +public interface IEMPItem extends IItemElectric { + + void onEMP(ItemStack var1, Entity var2, IExplosive var3); +} diff --git a/src/main/java/icbm/api/explosion/IExplosive.java b/src/main/java/icbm/api/explosion/IExplosive.java new file mode 100644 index 0000000..d923615 --- /dev/null +++ b/src/main/java/icbm/api/explosion/IExplosive.java @@ -0,0 +1,23 @@ +package icbm.api.explosion; + + +public interface IExplosive { + + int getID(); + + String getUnlocalizedName(); + + String getExplosiveName(); + + String getGrenadeName(); + + String getMissileName(); + + String getMinecartName(); + + float getRadius(); + + int getTier(); + + double getEnergy(); +} diff --git a/src/main/java/icbm/api/explosion/IExplosiveContainer.java b/src/main/java/icbm/api/explosion/IExplosiveContainer.java new file mode 100644 index 0000000..72f54b6 --- /dev/null +++ b/src/main/java/icbm/api/explosion/IExplosiveContainer.java @@ -0,0 +1,8 @@ +package icbm.api.explosion; + +import icbm.api.explosion.IExplosive; + +public interface IExplosiveContainer { + + IExplosive getExplosiveType(); +} diff --git a/src/main/java/icbm/api/explosion/IExplosiveIgnore.java b/src/main/java/icbm/api/explosion/IExplosiveIgnore.java new file mode 100644 index 0000000..093a592 --- /dev/null +++ b/src/main/java/icbm/api/explosion/IExplosiveIgnore.java @@ -0,0 +1,8 @@ +package icbm.api.explosion; + +import icbm.api.explosion.ExplosionEvent; + +public interface IExplosiveIgnore { + + boolean canIgnore(ExplosionEvent var1); +} diff --git a/src/main/resources/assets/atomicscience/sounds.json b/src/main/resources/assets/atomicscience/sounds.json new file mode 100644 index 0000000..b0b46cf --- /dev/null +++ b/src/main/resources/assets/atomicscience/sounds.json @@ -0,0 +1,56 @@ +{ + "antimatter": { + "category": "master", + "sounds": [ + { + "name": "antimatter", + "stream": false + } + ] + }, + "strangematter": { + "category": "master", + "sounds": [ + { + "name": "strangematter", + "stream": false + } + ] + }, + "alarm": { + "category": "master", + "sounds": [ + { + "name": "alarm", + "stream": false + } + ] + }, + "accelerator": { + "category": "master", + "sounds": [ + { + "name": "accelerator", + "stream": false + } + ] + }, + "turbine": { + "category": "master", + "sounds": [ + { + "name": "turbine", + "stream": false + } + ] + }, + "assembler": { + "category": "master", + "sounds": [ + { + "name": "assembler", + "stream": false + } + ] + } +}