tilera/electrodynamics
1
0
Fork 0
Code Issues 1 Pull requests Projects Releases Wiki Activity

Removed most errors out of atomic module, moved electrical turbine to mech module

Browse source
This commit is contained in:
Robert S 2014-08-07 23:52:02 -04:00
parent 0474addef6
commit 00855a5d15
37 changed files with 995 additions and 1605 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

597
src/main/scala/resonantinduction/atomic/Atomic.java
View file

@ -1,597 +0,0 @@
package resonantinduction.atomic;
import cpw.mods.fml.common.eventhandler.Event;
import ic2.api.item.IC2Items;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.init.Blocks;
import net.minecraft.init.Items;
import net.minecraft.item.ItemArmor;
import net.minecraft.util.MovingObjectPosition;
import net.minecraftforge.common.util.EnumHelper;
import resonant.content.loader.ModManager;
import resonant.engine.content.debug.TileCreativeBuilder;
import resonant.lib.network.discriminator.PacketAnnotation;
import resonant.lib.network.discriminator.PacketAnnotationManager;
import resonantinduction.atomic.blocks.BlockToxicWaste;
import resonantinduction.atomic.blocks.BlockUraniumOre;
import resonantinduction.atomic.blocks.TileElectromagnet;
import resonantinduction.atomic.items.*;
import resonantinduction.atomic.machine.extractor.turbine.TileElectricTurbine;
import resonantinduction.atomic.machine.extractor.turbine.TileFunnel;
import resonantinduction.atomic.machine.plasma.BlockPlasmaHeater;
import resonantinduction.atomic.machine.plasma.TilePlasma;
import resonantinduction.atomic.machine.quantum.TileQuantumAssembler;
import resonantinduction.atomic.machine.reactor.TileReactorCell;
import resonantinduction.atomic.schematic.SchematicBreedingReactor;
import universalelectricity.core.transform.vector.VectorWorld;
import ic2.api.recipe.IRecipeInput;
import ic2.api.recipe.RecipeOutput;
import ic2.api.recipe.Recipes;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import net.minecraft.block.Block;
import net.minecraft.item.Item;
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;
import net.minecraftforge.common.ForgeChunkManager;
import net.minecraftforge.common.ForgeChunkManager.LoadingCallback;
import net.minecraftforge.common.ForgeChunkManager.Ticket;
import net.minecraftforge.common.ForgeChunkManager.Type;
import net.minecraftforge.common.MinecraftForge;
import net.minecraftforge.event.entity.player.FillBucketEvent;
import net.minecraftforge.fluids.Fluid;
import net.minecraftforge.fluids.FluidContainerRegistry;
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 resonant.api.IElectromagnet;
import resonant.api.event.PlasmaEvent.SpawnPlasmaEvent;
import resonant.api.recipe.QuantumAssemblerRecipes;
import resonant.core.content.debug.BlockCreativeBuilder;
import resonant.lib.prefab.block.BlockRadioactive;
import resonant.lib.prefab.ore.OreGenBase;
import resonant.lib.prefab.ore.OreGenReplaceStone;
import resonant.lib.prefab.ore.OreGenerator;
import resonant.lib.recipe.UniversalRecipe;
import resonant.lib.render.RenderUtility;
import resonantinduction.atomic.blocks.TileSiren;
import resonantinduction.atomic.machine.accelerator.EntityParticle;
import resonantinduction.atomic.machine.accelerator.TileAccelerator;
import resonantinduction.atomic.machine.centrifuge.TileCentrifuge;
import resonantinduction.atomic.machine.plasma.TilePlasmaHeater;
import resonantinduction.atomic.machine.reactor.TileControlRod;
import resonantinduction.atomic.machine.thermometer.TileThermometer;
import resonantinduction.atomic.schematic.SchematicAccelerator;
import resonantinduction.atomic.schematic.SchematicFissionReactor;
import resonantinduction.atomic.schematic.SchematicFusionReactor;
import resonantinduction.core.Reference;
import resonantinduction.core.ResonantInduction;
import resonantinduction.core.ResonantTab;
import resonantinduction.core.Settings;
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.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.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;
@Mod(modid = Atomic.ID, name = Atomic.NAME, version = Reference.VERSION, dependencies = "required-after:ResonantEngine;after:IC2;after:ResonantInduction|Electrical;required-after:" + ResonantInduction.ID)
public class Atomic
{
public static final String ID = "ResonantInduction|Atomic";
public static final String TEXTURE_DIRECTORY = "textures/";
public static final String GUI_TEXTURE_DIRECTORY = TEXTURE_DIRECTORY + "gui/";
public static final int ENTITY_ID_PREFIX = 49;
public static final int SECOND_IN_TICKS = 20;
public static final String BAN_ANTIMATTER_POWER = FlagRegistry.registerFlag("ban_antimatter_power");
public static final String NAME = Reference.name() + " Atomic";
public static final ModManager contentRegistry = new ModManager().setPrefix(Reference.prefix()).setTab(ResonantTab.tab());
private static final String[] SUPPORTED_LANGUAGES = new String[]
{ "en_US", "pl_PL", "de_DE", "ru_RU" };
@Instance(ID)
public static Atomic INSTANCE;
@SidedProxy(clientSide = "ClientProxy", serverSide = "CommonProxy")
public static CommonProxy proxy;
@Mod.Metadata(ID)
public static ModMetadata metadata;
/** Block and Items */
public static Block blockRadioactive;
public static Block blockCentrifuge;
public static Block blockElectricTurbine;
public static Block blockNuclearBoiler;
public static Block blockControlRod;
public static Block blockThermometer;
public static Block blockFusionCore;
public static Block blockPlasma;
public static Block blockElectromagnet;
public static Block blockChemicalExtractor;
public static Block blockSiren;
public static Block blockSteamFunnel;
public static Block blockAccelerator;
public static Block blockFulmination;
public static Block blockQuantumAssembler;
public static Block blockReactorCell;
public static Block blockUraniumOre;
//items
public static Item itemCell, itemFissileFuel, itemBreedingRod, itemDarkMatter, itemAntimatter, itemDeuteriumCell, itemTritiumCell, itemWaterCell;
public static Item itemBucketToxic;
public static Item itemYellowCake;
public static Item itemUranium;
public static Item itemHazmatTop;
public static Item itemHazmatBody;
public static Item itemHazmatLeggings;
public static Item itemHazmatBoots;
/** Fluids */
public static Block blockToxicWaste;
/** Water, Uranium Hexafluoride, Steam, Deuterium, Toxic waste */
public static FluidStack FLUIDSTACK_WATER, FLUIDSTACK_URANIUM_HEXAFLOURIDE, FLUIDSTACK_STEAM, FLUIDSTACK_DEUTERIUM, FLUIDSTACK_TRITIUM, FLUIDSTACK_TOXIC_WASTE;
public static Fluid FLUID_URANIUM_HEXAFLOURIDE, FLUID_PLASMA, FLUID_STEAM, FLUID_DEUTERIUM, FLUID_TRITIUM, FLUID_TOXIC_WASTE;
public static OreGenBase uraniumOreGeneration;
/** Is this ItemStack a cell?
*
* @param itemStack
* @return */
public static boolean isItemStackEmptyCell(ItemStack itemStack)
{
return isItemStackOreDictionaryCompatible(itemStack, "cellEmpty");
}
public static boolean isItemStackWaterCell(ItemStack itemStack)
{
return isItemStackOreDictionaryCompatible(itemStack, "cellWater");
}
public static boolean isItemStackUraniumOre(ItemStack itemStack)
{
return isItemStackOreDictionaryCompatible(itemStack, "dropUranium", "oreUranium");
}
public static boolean isItemStackDeuteriumCell(ItemStack itemStack)
{
return isItemStackOreDictionaryCompatible(itemStack, "molecule_1d", "molecule_1h2", "cellDeuterium");
}
public static boolean isItemStackTritiumCell(ItemStack itemStack)
{
return isItemStackOreDictionaryCompatible(itemStack, "molecule_h3", "cellTritium");
}
/** Compare to Ore Dict
*
* @param itemStack
* @return */
public static boolean isItemStackOreDictionaryCompatible(ItemStack itemStack, String... names)
{
if (itemStack != null && names != null && names.length > 0)
{
String name = OreDictionary.getOreName(OreDictionary.getOreID(itemStack));
for (String compareName : names)
{
if (name.equals(compareName))
{
return true;
}
}
}
return false;
}
public static int getFluidAmount(FluidStack fluid)
{
if (fluid != null)
{
return fluid.amount;
}
return 0;
}
@EventHandler
public void preInit(FMLPreInitializationEvent event)
{
INSTANCE = this;
MinecraftForge.EVENT_BUS.register(this);
NetworkRegistry.INSTANCE.registerGuiHandler(this, proxy);
TileCreativeBuilder.register(new SchematicAccelerator());
TileCreativeBuilder.register(new SchematicBreedingReactor());
TileCreativeBuilder.register(new SchematicFissionReactor());
TileCreativeBuilder.register(new SchematicFusionReactor());
Settings.config.load();
/** Registers Gases & Fluids */
FLUID_URANIUM_HEXAFLOURIDE = new Fluid("uraniumhexafluoride").setGaseous(true);
FLUID_STEAM = new Fluid("steam").setGaseous(true);
FLUID_DEUTERIUM = new Fluid("deuterium").setGaseous(true);
FLUID_TRITIUM = new Fluid("tritium").setGaseous(true);
FLUID_TOXIC_WASTE = new Fluid("toxicwaste");
FLUID_PLASMA = new Fluid("plasma").setGaseous(true);
FluidRegistry.registerFluid(FLUID_URANIUM_HEXAFLOURIDE);
FluidRegistry.registerFluid(FLUID_STEAM);
FluidRegistry.registerFluid(FLUID_TRITIUM);
FluidRegistry.registerFluid(FLUID_DEUTERIUM);
FluidRegistry.registerFluid(FLUID_TOXIC_WASTE);
FluidRegistry.registerFluid(FLUID_PLASMA);
/** Fluid Stack Reference Initialization */
FLUIDSTACK_WATER = new FluidStack(FluidRegistry.WATER, 0);
FLUIDSTACK_URANIUM_HEXAFLOURIDE = new FluidStack(FLUID_URANIUM_HEXAFLOURIDE, 0);
FLUIDSTACK_STEAM = new FluidStack(FluidRegistry.getFluidID("steam"), 0);
FLUIDSTACK_DEUTERIUM = new FluidStack(FluidRegistry.getFluidID("deuterium"), 0);
FLUIDSTACK_TRITIUM = new FluidStack(FluidRegistry.getFluidID("tritium"), 0);
FLUIDSTACK_TOXIC_WASTE = new FluidStack(FluidRegistry.getFluidID("toxicwaste"), 0);
/** Block Initiation */
blockRadioactive = new BlockRadioactive().setUnlocalizedName(Reference.prefix() + "radioactive").setTextureName(Reference.prefix() + "radioactive").setCreativeTab(CreativeTabs.tabBlock);
blockUraniumOre = new BlockUraniumOre();
blockToxicWaste = new BlockToxicWaste().setCreativeTab(null);
blockElectricTurbine = contentRegistry.newBlock(TileElectricTurbine.class);
blockCentrifuge = contentRegistry.newBlock(TileCentrifuge.class);
blockReactorCell = contentRegistry.newBlock(TileReactorCell.class);
blockNuclearBoiler = contentRegistry.newBlock(TileNuclearBoiler.class);
blockChemicalExtractor = contentRegistry.newBlock(TileChemicalExtractor.class);
blockFusionCore = contentRegistry.newBlock(TilePlasmaHeater.class);
blockControlRod = contentRegistry.newBlock(TileControlRod.class);
blockThermometer = contentRegistry.newBlock(TileThermometer.class);
blockPlasma = contentRegistry.newBlock(TilePlasma.class);
blockElectromagnet = contentRegistry.newBlock(TileElectromagnet.class);
blockSiren = contentRegistry.newBlock(TileSiren.class);
blockSteamFunnel = contentRegistry.newBlock(TileFunnel.class);
blockAccelerator = contentRegistry.newBlock(TileAccelerator.class);
blockFulmination = contentRegistry.newBlock(TileFulmination.class);
blockQuantumAssembler = contentRegistry.newBlock(TileQuantumAssembler.class);
/** Items */
itemHazmatTop = new ItemHazmat("HazmatMask", 0);
itemHazmatBody = new ItemHazmat("HazmatBody", 1);
itemHazmatLeggings = new ItemHazmat("HazmatLeggings", 2);
itemHazmatBoots = new ItemHazmat("HazmatBoots", 3);
itemCell = new Item().setUnlocalizedName("cellEmpty");
itemFissileFuel = new ItemFissileFuel().setUnlocalizedName("rodFissileFuel");
itemDeuteriumCell = new ItemCell().setUnlocalizedName("cellDeuterium");
itemTritiumCell = new ItemCell().setUnlocalizedName("cellTritium");
itemWaterCell = new ItemCell().setUnlocalizedName("cellWater");
itemDarkMatter = new ItemDarkMatter().setUnlocalizedName("darkMatter");
itemAntimatter = new ItemAntimatter().setUnlocalizedName("antimatter");
itemBreedingRod = new ItemBreederFuel().setUnlocalizedName("rodBreederFuel");
itemYellowCake = new ItemRadioactive().setUnlocalizedName("yellowcake");
itemUranium = contentRegistry.newItem(ItemUranium.class);
/** Fluid Item Initialization */
FLUID_PLASMA.setBlockID(blockPlasma);
int bucketID = Settings.getNextItemID();
itemBucketToxic = (new ItemBucket(Settings.config.getItem("Toxic Waste Bucket", bucketID).getInt(bucketID), blockToxicWaste.blockID)).setCreativeTab(ResonantTab.DEFAULT).setUnlocalizedName(Reference.PREFIX + "bucketToxicWaste")
.setContainerItem(Item.bucketEmpty).setTextureName(Reference.PREFIX + "bucketToxicWaste");
FluidContainerRegistry.registerFluidContainer(FluidRegistry.getFluid("toxicwaste"), new ItemStack(itemBucketToxic), new ItemStack(Item.bucketEmpty));
FluidContainerRegistry.registerFluidContainer(FluidRegistry.WATER, new ItemStack(itemWaterCell), new ItemStack(itemCell));
FluidContainerRegistry.registerFluidContainer(new FluidStack(FluidRegistry.getFluid("deuterium"), 200), new ItemStack(itemDeuteriumCell), new ItemStack(itemCell));
FluidContainerRegistry.registerFluidContainer(new FluidStack(FluidRegistry.getFluid("tritium"), 200), new ItemStack(itemTritiumCell), new ItemStack(itemCell));
if (OreDictionary.getOres("oreUranium").size() > 1 && Settings.config.get(Configuration.CATEGORY_GENERAL, "Auto Disable Uranium If Exist", false).getBoolean(false))
{
ResonantInduction.LOGGER.fine("Disabled Uranium Generation. Detected another uranium being generated: " + OreDictionary.getOres("oreUranium").size());
}
else
{
uraniumOreGeneration = new OreGenReplaceStone("Uranium Ore", "oreUranium", new ItemStack(blockUraniumOre), 0, 25, 9, 3, "pickaxe", 2);
uraniumOreGeneration.enable(Settings.config);
OreGenerator.addOre(uraniumOreGeneration);
ResonantInduction.LOGGER.fine("Added Atomic Science uranium to ore generator.");
}
Settings.config.save();
MinecraftForge.EVENT_BUS.register(itemAntimatter);
MinecraftForge.EVENT_BUS.register(FulminationHandler.INSTANCE);
/** Cell registry. */
if (Settings.allowOreDictionaryCompatibility)
{
OreDictionary.registerOre("ingotUranium", itemUranium);
OreDictionary.registerOre("dustUranium", itemYellowCake);
}
OreDictionary.registerOre("breederUranium", new ItemStack(itemUranium, 1, 1));
OreDictionary.registerOre("blockRadioactive", blockRadioactive);
OreDictionary.registerOre("cellEmpty", itemCell);
OreDictionary.registerOre("cellUranium", itemFissileFuel);
OreDictionary.registerOre("cellTritium", itemTritiumCell);
OreDictionary.registerOre("cellDeuterium", itemDeuteriumCell);
OreDictionary.registerOre("cellWater", itemWaterCell);
OreDictionary.registerOre("strangeMatter", itemDarkMatter);
OreDictionary.registerOre("antimatterMilligram", new ItemStack(itemAntimatter, 1, 0));
OreDictionary.registerOre("antimatterGram", new ItemStack(itemAntimatter, 1, 1));
ForgeChunkManager.setForcedChunkLoadingCallback(this, new LoadingCallback() {
@Override
public void ticketsLoaded(List<Ticket> tickets, World world) {
for (Ticket ticket : tickets) {
if (ticket.getType() == Type.ENTITY) {
if (ticket.getEntity() != null) {
if (ticket.getEntity() instanceof EntityParticle) {
((EntityParticle) ticket.getEntity()).updateTicket = ticket;
}
}
}
}
}
});
Settings.config.save();
ResonantTab.ITEMSTACK = new ItemStack(blockReactorCell);
}
@EventHandler
public void init(FMLInitializationEvent evt)
{
Settings.setModMetadata(metadata, ID, NAME, ResonantInduction.ID);
proxy.init();
}
@EventHandler
public void postInit(FMLPostInitializationEvent event)
{
/** IC2 Recipes */
if (Loader.isModLoaded("IC2") && Settings.allowAlternateRecipes())
{
OreDictionary.registerOre("cellEmpty", IC2Items.getItem("cell"));
// Check to make sure we have actually registered the Ore, otherwise tell the user about
// it.
String cellEmptyName = OreDictionary.getOreName(OreDictionary.getOreID("cellEmpty"));
if (cellEmptyName == "Unknown")
{
ResonantInduction.logger().info("Unable to register cellEmpty in OreDictionary!");
}
// IC2 exchangeable recipes
GameRegistry.addRecipe(new ShapelessOreRecipe(itemYellowCake, IC2Items.getItem("reactorUraniumSimple")));
GameRegistry.addRecipe(new ShapelessOreRecipe(IC2Items.getItem("cell"), itemCell));
GameRegistry.addRecipe(new ShapelessOreRecipe(itemCell, "cellEmpty"));
}
// Antimatter
GameRegistry.addRecipe(new ShapelessOreRecipe(new ItemStack(itemAntimatter, 1, 1), new Object[]
{ itemAntimatter, itemAntimatter, itemAntimatter, itemAntimatter, itemAntimatter, itemAntimatter, itemAntimatter, itemAntimatter }));
GameRegistry.addRecipe(new ShapelessOreRecipe(new ItemStack(itemAntimatter, 8, 0), new Object[]
{ new ItemStack(itemAntimatter, 1, 1) }));
// Steam Funnel
GameRegistry.addRecipe(new ShapedOreRecipe(new ItemStack(blockSteamFunnel, 2), new Object[]
{ " B ", "B B", "B B", 'B', UniversalRecipe.SECONDARY_METAL.get() }));
GameRegistry.addRecipe(new ShapedOreRecipe(new ItemStack(blockSteamFunnel, 2), new Object[]
{ " B ", "B B", "B B", 'B', "ingotIron" }));
// Atomic Assembler
GameRegistry.addRecipe(new ShapedOreRecipe(blockQuantumAssembler, new Object[]
{ "CCC", "SXS", "SSS", 'X', blockCentrifuge, 'C', UniversalRecipe.CIRCUIT_T3.get(), 'S', UniversalRecipe.PRIMARY_PLATE.get() }));
// Fulmination Generator
GameRegistry.addRecipe(new ShapedOreRecipe(blockFulmination, new Object[]
{ "OSO", "SCS", "OSO", 'O', Blocks.obsidian, 'C', UniversalRecipe.CIRCUIT_T2.get(), 'S', UniversalRecipe.PRIMARY_PLATE.get() }));
// Particle Accelerator
GameRegistry.addRecipe(new ShapedOreRecipe(blockAccelerator, new Object[]
{ "SCS", "CMC", "SCS", 'M', UniversalRecipe.MOTOR.get(), 'C', UniversalRecipe.CIRCUIT_T3.get(), 'S', UniversalRecipe.PRIMARY_PLATE.get() }));
// Centrifuge
GameRegistry.addRecipe(new ShapedOreRecipe(blockCentrifuge, new Object[]
{ "BSB", "MCM", "BSB", 'C', UniversalRecipe.CIRCUIT_T2.get(), 'S', UniversalRecipe.PRIMARY_PLATE.get(), 'B', UniversalRecipe.SECONDARY_METAL.get(), 'M',
UniversalRecipe.MOTOR.get() }));
// Nuclear Boiler
GameRegistry.addRecipe(new ShapedOreRecipe(blockNuclearBoiler, new Object[]
{ "S S", "FBF", "SMS", 'F', Blocks.furnace, 'S', UniversalRecipe.PRIMARY_PLATE.get(), 'B', Items.bucket, 'M', UniversalRecipe.MOTOR.get() }));
// Chemical Extractor
GameRegistry.addRecipe(new ShapedOreRecipe(blockChemicalExtractor, new Object[]
{ "BSB", "MCM", "BSB", 'C', UniversalRecipe.CIRCUIT_T3.get(), 'S', UniversalRecipe.PRIMARY_PLATE.get(), 'B', UniversalRecipe.SECONDARY_METAL.get(), 'M',
UniversalRecipe.MOTOR.get() }));
// Siren
GameRegistry.addRecipe(new ShapedOreRecipe(new ItemStack(blockSiren, 2), new Object[]
{ "NPN", 'N', Blocks.noteblock, 'P', UniversalRecipe.SECONDARY_PLATE.get() }));
// Fission Reactor
GameRegistry
.addRecipe(new ShapedOreRecipe(blockReactorCell, new Object[]
{ "SCS", "MEM", "SCS", 'E', "cellEmpty", 'C', UniversalRecipe.CIRCUIT_T2.get(), 'S', UniversalRecipe.PRIMARY_PLATE.get(), 'M',
UniversalRecipe.MOTOR.get() }));
// Fusion Reactor
GameRegistry.addRecipe(new ShapedOreRecipe(blockFusionCore, new Object[]
{ "CPC", "PFP", "CPC", 'P', UniversalRecipe.PRIMARY_PLATE.get(), 'F', blockReactorCell, 'C', UniversalRecipe.CIRCUIT_T3.get() }));
// Turbine
GameRegistry.addRecipe(new ShapedOreRecipe(blockElectricTurbine, new Object[]
{ " B ", "BMB", " B ", 'B', UniversalRecipe.SECONDARY_PLATE.get(), 'M', UniversalRecipe.MOTOR.get() }));
// Empty Cell
GameRegistry.addRecipe(new ShapedOreRecipe(new ItemStack(itemCell, 16), new Object[]
{ " T ", "TGT", " T ", 'T', "ingotTin", 'G', Blocks.glass }));
// Water Cell
GameRegistry.addRecipe(new ShapelessOreRecipe(new ItemStack(itemWaterCell), new Object[]
{ "cellEmpty", Items.water_bucket }));
// Thermometer
GameRegistry.addRecipe(new ShapedOreRecipe(blockThermometer, new Object[]
{ "SSS", "GCG", "GSG", 'S', UniversalRecipe.PRIMARY_METAL.get(), 'G', Blocks.glass, 'C', UniversalRecipe.CIRCUIT_T1.get() }));
// Control Rod
GameRegistry.addRecipe(new ShapedOreRecipe(blockControlRod, new Object[]
{ "I", "I", "I", 'I', Items.iron_ingot }));
// Fuel Rod
GameRegistry.addRecipe(new ShapedOreRecipe(itemFissileFuel, new Object[]
{ "CUC", "CUC", "CUC", 'U', "ingotUranium", 'C', "cellEmpty" }));
// Breeder Rod
GameRegistry.addRecipe(new ShapedOreRecipe(itemBreedingRod, new Object[]
{ "CUC", "CUC", "CUC", 'U', "breederUranium", 'C', "cellEmpty" }));
// Electromagnet
GameRegistry.addRecipe(new ShapedOreRecipe(new ItemStack(blockElectromagnet, 2, 0), new Object[]
{ "BBB", "BMB", "BBB", 'B', UniversalRecipe.SECONDARY_METAL.get(), 'M', UniversalRecipe.MOTOR.get(S) }));
// Electromagnet Glass
GameRegistry.addRecipe(new ShapelessOreRecipe(new ItemStack(blockElectromagnet, 1, 1), new Object[]
{ blockElectromagnet, Blocks.glass }));
// Hazmat Suit
GameRegistry.addRecipe(new ShapedOreRecipe(itemHazmatTop, new Object[]
{ "SSS", "BAB", "SCS", 'A', Items.leather_helmet, 'C', UniversalRecipe.CIRCUIT_T1.get(), 'S', Blocks.wool }));
GameRegistry.addRecipe(new ShapedOreRecipe(itemHazmatBody, new Object[]
{ "SSS", "BAB", "SCS", 'A', Items.leather_chestplate, 'C', UniversalRecipe.CIRCUIT_T1.get(), 'S', Blocks.wool }));
GameRegistry.addRecipe(new ShapedOreRecipe(itemHazmatLeggings, new Object[]
{ "SSS", "BAB", "SCS", 'A', Items.leather_leggings, 'C', UniversalRecipe.CIRCUIT_T1.get(), 'S', Blocks.wool }));
GameRegistry.addRecipe(new ShapedOreRecipe(itemHazmatBoots, new Object[]
{ "SSS", "BAB", "SCS", 'A', Items.leather_boots, 'C', UniversalRecipe.CIRCUIT_T1.get(), 'S', Blocks.wool }));
EntityRegistry.registerGlobalEntityID(EntityParticle.class, "ASParticle", EntityRegistry.findGlobalUniqueEntityId());
EntityRegistry.registerModEntity(EntityParticle.class, "ASParticle", ENTITY_ID_PREFIX, this, 80, 3, true);
Atomic.proxy.init();
Settings.config.load();
for (String oreName : OreDictionary.getOreNames())
{
if (oreName.startsWith("ingot"))
{
for (ItemStack itemStack : OreDictionary.getOres(oreName))
{
if (itemStack != null)
{
QuantumAssemblerRecipes.addRecipe(itemStack);
}
}
}
}
Settings.config.save();
}
@EventHandler
public void thermalEventHandler(EventThermalUpdate evt)
{
VectorWorld pos = evt.position;
Block block = Block.blocksList[pos.getBlock()];
if (block == blockElectromagnet)
{
evt.heatLoss = evt.deltaTemperature * 0.6f;
}
}
@EventHandler
public void plasmaEvent(SpawnPlasmaEvent evt)
{
Block block = evt.world.getBlock(evt.x, evt.y, evt.z);
if (block != null && block.getBlockHardness(evt.world, evt.x, evt.y, evt.z) >= 0)
{
TileEntity tile = evt.world.getTileEntity(evt.x, evt.y, evt.z);
if (tile instanceof TilePlasma)
{
((TilePlasma) tile).setTemperature(evt.temperature);
return;
}else if (tile instanceof IElectromagnet)
{
return;
}
else
{
evt.world.setBlockToAir(evt.x, evt.y, evt.z);
evt.world.setBlock(evt.x, evt.y, evt.z, blockPlasma);
}
}
}
@EventHandler
@SideOnly(Side.CLIENT)
public void preTextureHook(TextureStitchEvent.Pre event)
{
if (event.map.getTextureType() == 0)
{
RenderUtility.registerIcon(Reference.prefix() + "uraniumHexafluoride", event.map);
RenderUtility.registerIcon(Reference.prefix() + "steam", event.map);
RenderUtility.registerIcon(Reference.prefix() + "deuterium", event.map);
RenderUtility.registerIcon(Reference.prefix() + "tritium", event.map);
RenderUtility.registerIcon(Reference.prefix() + "atomic_edge", event.map);
RenderUtility.registerIcon(Reference.prefix() + "funnel_edge", event.map);
RenderUtility.registerIcon(Reference.prefix() + "glass", event.map);
}
}
@EventHandler
@SideOnly(Side.CLIENT)
public void postTextureHook(TextureStitchEvent.Post event)
{
FLUID_URANIUM_HEXAFLOURIDE.setIcons(RenderUtility.loadedIconMap.get(Reference.prefix() + "uraniumHexafluoride"));
FLUID_STEAM.setIcons(RenderUtility.loadedIconMap.get(Reference.prefix() + "steam"));
FLUID_DEUTERIUM.setIcons(RenderUtility.loadedIconMap.get(Reference.prefix() + "deuterium"));
FLUID_TRITIUM.setIcons(RenderUtility.loadedIconMap.get(Reference.prefix() + "tritium"));
FLUID_TOXIC_WASTE.setIcons(blockToxicWaste.getIcon(0, 0));
FLUID_PLASMA.setIcons(blockPlasma.getIcon(0, 0));
}
@EventHandler
public void fillBucketEvent(FillBucketEvent evt)
{
if (!evt.world.isRemote && evt.target != null && evt.target.typeOfHit == MovingObjectPosition.MovingObjectType.BLOCK)
{
VectorWorld pos = new VectorWorld(evt.world, evt.target);
if (pos.getBlock() == blockToxicWaste)
{
pos.setBlockToAir();
evt.result = new ItemStack(itemBucketToxic);
evt.setResult(Event.Result.ALLOW);
}
}
}
/** Recipes */
public static enum RecipeType
{
CHEMICAL_EXTRACTOR;
}
}

429
src/main/scala/resonantinduction/atomic/Atomic.scala Normal file
View file

@ -0,0 +1,429 @@
package resonantinduction.atomic
import cpw.mods.fml.common.eventhandler.Event
import cpw.mods.fml.common.eventhandler.SubscribeEvent
import ic2.api.item.IC2Items
import net.minecraft.block.material.Material
import net.minecraft.creativetab.CreativeTabs
import net.minecraft.init.Blocks
import net.minecraft.init.Items
import net.minecraft.item.ItemArmor
import net.minecraft.util.MovingObjectPosition
import net.minecraftforge.common.config.Configuration
import net.minecraftforge.common.util.EnumHelper
import resonant.api.event.PlasmaEvent
import resonant.content.loader.ModManager
import resonant.engine.content.debug.TileCreativeBuilder
import resonant.engine.grid.thermal.EventThermal
import resonant.lib.network.discriminator.PacketAnnotation
import resonant.lib.network.discriminator.PacketAnnotationManager
import resonant.lib.ore.OreGenReplaceStone
import resonant.lib.ore.OreGenerator
import resonantinduction.atomic.blocks._
import resonantinduction.atomic.items._
import resonantinduction.atomic.machine.TileFunnel
import resonantinduction.atomic.machine.boiler.TileNuclearBoiler
import resonantinduction.atomic.machine.extractor.TileChemicalExtractor
import resonantinduction.atomic.machine.fulmination.FulminationHandler
import resonantinduction.atomic.machine.fulmination.TileFulmination
import resonantinduction.atomic.machine.plasma.BlockPlasmaHeater
import resonantinduction.atomic.machine.plasma.TilePlasma
import resonantinduction.atomic.machine.quantum.TileQuantumAssembler
import resonantinduction.atomic.machine.reactor.TileReactorCell
import resonantinduction.atomic.schematic.SchematicBreedingReactor
import resonantinduction.mechanical.energy.turbine.TileElectricTurbine
import universalelectricity.core.transform.vector.VectorWorld
import ic2.api.recipe.IRecipeInput
import ic2.api.recipe.RecipeOutput
import ic2.api.recipe.Recipes
import java.util.Iterator
import java.util.List
import java.util.Map
import java.util.Map.Entry
import net.minecraft.block.Block
import net.minecraft.item.Item
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
import net.minecraftforge.common.ForgeChunkManager
import net.minecraftforge.common.ForgeChunkManager.LoadingCallback
import net.minecraftforge.common.ForgeChunkManager.Ticket
import net.minecraftforge.common.ForgeChunkManager.Type
import net.minecraftforge.common.MinecraftForge
import net.minecraftforge.event.entity.player.FillBucketEvent
import net.minecraftforge.fluids.Fluid
import net.minecraftforge.fluids.FluidContainerRegistry
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 resonant.api.IElectromagnet
import resonant.api.event.PlasmaEvent.SpawnPlasmaEvent
import resonant.api.recipe.QuantumAssemblerRecipes
import resonant.lib.recipe.UniversalRecipe
import resonant.lib.render.RenderUtility
import resonantinduction.atomic.machine.accelerator.EntityParticle
import resonantinduction.atomic.machine.accelerator.TileAccelerator
import resonantinduction.atomic.machine.centrifuge.TileCentrifuge
import resonantinduction.atomic.machine.plasma.TilePlasmaHeater
import resonantinduction.atomic.machine.reactor.TileControlRod
import resonantinduction.atomic.machine.thermometer.TileThermometer
import resonantinduction.atomic.schematic.SchematicAccelerator
import resonantinduction.atomic.schematic.SchematicFissionReactor
import resonantinduction.atomic.schematic.SchematicFusionReactor
import resonantinduction.core.Reference
import resonantinduction.core.ResonantInduction
import resonantinduction.core.ResonantTab
import resonantinduction.core.Settings
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.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.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
object Atomic {
/** Is this ItemStack a cell?
*
* @param itemStack
* @return*/
def isItemStackEmptyCell(itemStack: ItemStack): Boolean = {
return isItemStackOreDictionaryCompatible(itemStack, "cellEmpty")
}
def isItemStackWaterCell(itemStack: ItemStack): Boolean = {
return isItemStackOreDictionaryCompatible(itemStack, "cellWater")
}
def isItemStackUraniumOre(itemStack: ItemStack): Boolean = {
return isItemStackOreDictionaryCompatible(itemStack, "dropUranium", "oreUranium")
}
def isItemStackDeuteriumCell(itemStack: ItemStack): Boolean = {
return isItemStackOreDictionaryCompatible(itemStack, "molecule_1d", "molecule_1h2", "cellDeuterium")
}
def isItemStackTritiumCell(itemStack: ItemStack): Boolean = {
return isItemStackOreDictionaryCompatible(itemStack, "molecule_h3", "cellTritium")
}
/** Compare to Ore Dict
*
* @param itemStack
* @return*/
def isItemStackOreDictionaryCompatible(itemStack: ItemStack, names: String*): Boolean = {
if (itemStack != null && names != null && names.length > 0) {
val name: String = OreDictionary.getOreName(OreDictionary.getOreID(itemStack))
for (compareName <- names) {
if (name == compareName) {
return true
}
}
}
return false
}
def getFluidAmount(fluid: FluidStack): Int = {
if (fluid != null) {
return fluid.amount
}
return 0
}
final val ID: String = "ResonantInduction|Atomic"
final val TEXTURE_DIRECTORY: String = "textures/"
final val GUI_TEXTURE_DIRECTORY: String = TEXTURE_DIRECTORY + "gui/"
final val ENTITY_ID_PREFIX: Int = 49
final val SECOND_IN_TICKS: Int = 20
final val NAME: String = Reference.name + " Atomic"
final val contentRegistry: ModManager = new ModManager().setPrefix(Reference.prefix).setTab(ResonantTab.tab)
private final val SUPPORTED_LANGUAGES: Array[String] = Array[String]("en_US", "pl_PL", "de_DE", "ru_RU")
@Instance(ID) var INSTANCE: Atomic = null
@SidedProxy(clientSide = "ClientProxy", serverSide = "CommonProxy") var proxy: CommonProxy = null
@Mod.Metadata(ID) var metadata: ModMetadata = null
/** Block and Items */
var blockRadioactive: Block = null
var blockCentrifuge: Block = null
var blockNuclearBoiler: Block = null
var blockControlRod: Block = null
var blockThermometer: Block = null
var blockFusionCore: Block = null
var blockPlasma: Block = null
var blockElectromagnet: Block = null
var blockChemicalExtractor: Block = null
var blockSiren: Block = null
var blockSteamFunnel: Block = null
var blockAccelerator: Block = null
var blockFulmination: Block = null
var blockQuantumAssembler: Block = null
var blockReactorCell: Block = null
var blockUraniumOre: Block = null
var itemCell: Item = null
var itemFissileFuel: Item = null
var itemBreedingRod: Item = null
var itemDarkMatter: Item = null
var itemAntimatter: Item = null
var itemDeuteriumCell: Item = null
var itemTritiumCell: Item = null
var itemWaterCell: Item = null
var itemBucketToxic: Item = null
var itemYellowCake: Item = null
var itemUranium: Item = null
var itemHazmatTop: Item = null
var itemHazmatBody: Item = null
var itemHazmatLeggings: Item = null
var itemHazmatBoots: Item = null
/** Fluids */
var blockToxicWaste: Block = null
/** Water, Uranium Hexafluoride, Steam, Deuterium, Toxic waste */
var FLUIDSTACK_WATER: FluidStack = null
var FLUIDSTACK_URANIUM_HEXAFLOURIDE: FluidStack = null
var FLUIDSTACK_STEAM: FluidStack = null
var FLUIDSTACK_DEUTERIUM: FluidStack = null
var FLUIDSTACK_TRITIUM: FluidStack = null
var FLUIDSTACK_TOXIC_WASTE: FluidStack = null
var FLUID_URANIUM_HEXAFLOURIDE: Fluid = null
var FLUID_PLASMA: Fluid = null
var FLUID_STEAM: Fluid = null
var FLUID_DEUTERIUM: Fluid = null
var FLUID_TRITIUM: Fluid = null
var FLUID_TOXIC_WASTE: Fluid = null
var uraniumOreGeneration: OreGenerator = null
}
@Mod(modid = Atomic.ID, name = Atomic.NAME, version = Reference.version, dependencies = "required-after:ResonantEngine;after:IC2;after:ResonantInduction|Electrical;required-after:" + Reference.coreID)
class Atomic {
@EventHandler def preInit(event: FMLPreInitializationEvent) {
Atomic.INSTANCE = this
MinecraftForge.EVENT_BUS.register(this)
NetworkRegistry.INSTANCE.registerGuiHandler(this, Atomic.proxy)
TileCreativeBuilder.register(new SchematicAccelerator)
TileCreativeBuilder.register(new SchematicBreedingReactor)
TileCreativeBuilder.register(new SchematicFissionReactor)
TileCreativeBuilder.register(new SchematicFusionReactor)
Settings.config.load
Atomic.FLUID_URANIUM_HEXAFLOURIDE = new Fluid("uraniumhexafluoride").setGaseous(true)
Atomic.FLUID_STEAM = new Fluid("steam").setGaseous(true)
Atomic.FLUID_DEUTERIUM = new Fluid("deuterium").setGaseous(true)
Atomic.FLUID_TRITIUM = new Fluid("tritium").setGaseous(true)
Atomic.FLUID_TOXIC_WASTE = new Fluid("toxicwaste")
Atomic.FLUID_PLASMA = new Fluid("plasma").setGaseous(true)
FluidRegistry.registerFluid(Atomic.FLUID_URANIUM_HEXAFLOURIDE)
FluidRegistry.registerFluid(Atomic.FLUID_STEAM)
FluidRegistry.registerFluid(Atomic.FLUID_TRITIUM)
FluidRegistry.registerFluid(Atomic.FLUID_DEUTERIUM)
FluidRegistry.registerFluid(Atomic.FLUID_TOXIC_WASTE)
FluidRegistry.registerFluid(Atomic.FLUID_PLASMA)
Atomic.FLUIDSTACK_WATER = new FluidStack(FluidRegistry.WATER, 0)
Atomic.FLUIDSTACK_URANIUM_HEXAFLOURIDE = new FluidStack(Atomic.FLUID_URANIUM_HEXAFLOURIDE, 0)
Atomic.FLUIDSTACK_STEAM = new FluidStack(FluidRegistry.getFluidID("steam"), 0)
Atomic.FLUIDSTACK_DEUTERIUM = new FluidStack(FluidRegistry.getFluidID("deuterium"), 0)
Atomic.FLUIDSTACK_TRITIUM = new FluidStack(FluidRegistry.getFluidID("tritium"), 0)
Atomic.FLUIDSTACK_TOXIC_WASTE = new FluidStack(FluidRegistry.getFluidID("toxicwaste"), 0)
Atomic.blockRadioactive = new BlockRadioactive(Material.rock).setBlockName(Reference.prefix + "radioactive").setBlockTextureName(Reference.prefix + "radioactive").setCreativeTab(CreativeTabs.tabBlock)
Atomic.blockUraniumOre = new BlockUraniumOre
Atomic.blockToxicWaste = new BlockToxicWaste().setCreativeTab(null)
Atomic.blockCentrifuge = Atomic.contentRegistry.newBlock(classOf[TileCentrifuge])
Atomic.blockReactorCell = Atomic.contentRegistry.newBlock(classOf[TileReactorCell])
Atomic.blockNuclearBoiler = Atomic.contentRegistry.newBlock(classOf[TileNuclearBoiler])
Atomic.blockChemicalExtractor =Atomic. contentRegistry.newBlock(classOf[TileChemicalExtractor])
Atomic.blockFusionCore = Atomic.contentRegistry.newBlock(classOf[TilePlasmaHeater])
Atomic.blockControlRod = Atomic.contentRegistry.newBlock(classOf[TileControlRod])
Atomic.blockThermometer = Atomic.contentRegistry.newBlock(classOf[TileThermometer])
Atomic.blockPlasma = Atomic.contentRegistry.newBlock(classOf[TilePlasma])
Atomic.blockElectromagnet = Atomic.contentRegistry.newBlock(classOf[TileElectromagnet])
Atomic.blockSiren = Atomic.contentRegistry.newBlock(classOf[TileSiren])
Atomic.blockSteamFunnel = Atomic.contentRegistry.newBlock(classOf[TileFunnel])
Atomic.blockAccelerator = Atomic.contentRegistry.newBlock(classOf[TileAccelerator])
Atomic.blockFulmination = Atomic.contentRegistry.newBlock(classOf[TileFulmination])
Atomic.blockQuantumAssembler = Atomic.contentRegistry.newBlock(classOf[TileQuantumAssembler])
Atomic.itemHazmatTop = new ItemHazmat("HazmatMask", 0)
Atomic.itemHazmatBody = new ItemHazmat("HazmatBody", 1)
Atomic.itemHazmatLeggings = new ItemHazmat("HazmatLeggings", 2)
Atomic.itemHazmatBoots = new ItemHazmat("HazmatBoots", 3)
Atomic.itemCell = new Item().setUnlocalizedName("cellEmpty")
Atomic.itemFissileFuel = new ItemFissileFuel().setUnlocalizedName("rodFissileFuel")
Atomic.itemDeuteriumCell = new ItemCell().setUnlocalizedName("cellDeuterium")
Atomic.itemTritiumCell = new ItemCell().setUnlocalizedName("cellTritium")
Atomic.itemWaterCell = new ItemCell().setUnlocalizedName("cellWater")
Atomic.itemDarkMatter = new ItemDarkMatter().setUnlocalizedName("darkMatter")
Atomic.itemAntimatter = new ItemAntimatter().setUnlocalizedName("antimatter")
Atomic.itemBreedingRod = new ItemBreederFuel().setUnlocalizedName("rodBreederFuel")
Atomic.itemYellowCake = new ItemRadioactive().setUnlocalizedName("yellowcake")
Atomic.itemUranium = Atomic.contentRegistry.newItem(classOf[ItemUranium])
Atomic.FLUID_PLASMA.setBlock(Atomic.blockPlasma)
Atomic.itemBucketToxic = new ItemBucket(Atomic.blockPlasma).setCreativeTab(ResonantTab.tab).setUnlocalizedName(Reference.prefix + "bucketToxicWaste").setContainerItem(Items.bucket).setTextureName(Reference.prefix + "bucketToxicWaste")
FluidContainerRegistry.registerFluidContainer(FluidRegistry.getFluid("toxicwaste"), new ItemStack(Atomic.itemBucketToxic), new ItemStack(Items.bucket))
FluidContainerRegistry.registerFluidContainer(FluidRegistry.WATER, new ItemStack(Atomic.itemWaterCell), new ItemStack(Atomic.itemCell))
FluidContainerRegistry.registerFluidContainer(new FluidStack(FluidRegistry.getFluid("deuterium"), 200), new ItemStack(Atomic.itemDeuteriumCell), new ItemStack(Atomic.itemCell))
FluidContainerRegistry.registerFluidContainer(new FluidStack(FluidRegistry.getFluid("tritium"), 200), new ItemStack(Atomic.itemTritiumCell), new ItemStack(Atomic.itemCell))
if (OreDictionary.getOres("oreUranium").size > 1 && Settings.config.get(Configuration.CATEGORY_GENERAL, "Auto Disable Uranium If Exist", false).getBoolean(false)) {
}
else {
Atomic.uraniumOreGeneration = new OreGenReplaceStone("Uranium Ore", new ItemStack(Atomic.blockUraniumOre), 25, 9, 3)
Atomic.uraniumOreGeneration.enable(Settings.config)
OreGenerator.addOre(Atomic.uraniumOreGeneration)
}
Settings.config.save
MinecraftForge.EVENT_BUS.register(Atomic.itemAntimatter)
MinecraftForge.EVENT_BUS.register(FulminationHandler.INSTANCE)
if (Settings.allowOreDictionaryCompatibility) {
OreDictionary.registerOre("ingotUranium", Atomic.itemUranium)
OreDictionary.registerOre("dustUranium", Atomic.itemYellowCake)
}
OreDictionary.registerOre("breederUranium", new ItemStack(Atomic.itemUranium, 1, 1))
OreDictionary.registerOre("blockRadioactive", Atomic.blockRadioactive)
OreDictionary.registerOre("cellEmpty", Atomic.itemCell)
OreDictionary.registerOre("cellUranium", Atomic.itemFissileFuel)
OreDictionary.registerOre("cellTritium", Atomic.itemTritiumCell)
OreDictionary.registerOre("cellDeuterium", Atomic.itemDeuteriumCell)
OreDictionary.registerOre("cellWater", Atomic.itemWaterCell)
OreDictionary.registerOre("strangeMatter", Atomic.itemDarkMatter)
OreDictionary.registerOre("antimatterMilligram", new ItemStack(Atomic.itemAntimatter, 1, 0))
OreDictionary.registerOre("antimatterGram", new ItemStack(Atomic.itemAntimatter, 1, 1))
ForgeChunkManager.setForcedChunkLoadingCallback(this, new ForgeChunkManager.LoadingCallback {
def ticketsLoaded(tickets: List[ForgeChunkManager.Ticket], world: World) {
import scala.collection.JavaConversions._
for (ticket <- tickets) {
if (ticket.getType eq Type.ENTITY) {
if (ticket.getEntity != null) {
if (ticket.getEntity.isInstanceOf[EntityParticle]) {
(ticket.getEntity.asInstanceOf[EntityParticle]).updateTicket = ticket
}
}
}
}
}
})
Settings.config.save
ResonantTab.itemStack(new ItemStack(Atomic.blockReactorCell))
}
@EventHandler def init(evt: FMLInitializationEvent) {
Atomic.proxy.init
}
@EventHandler def postInit(event: FMLPostInitializationEvent) {
if (Loader.isModLoaded("IC2") && Settings.allowAlternateRecipes) {
OreDictionary.registerOre("cellEmpty", IC2Items.getItem("cell"))
val cellEmptyName: String = OreDictionary.getOreName(OreDictionary.getOreID("cellEmpty"))
if (cellEmptyName eq "Unknown") {
}
GameRegistry.addRecipe(new ShapelessOreRecipe(Atomic.itemYellowCake, IC2Items.getItem("reactorUraniumSimple")))
GameRegistry.addRecipe(new ShapelessOreRecipe(IC2Items.getItem("cell"), Atomic.itemCell))
GameRegistry.addRecipe(new ShapelessOreRecipe(Atomic.itemCell, "cellEmpty"))
}
GameRegistry.addRecipe(new ShapelessOreRecipe(new ItemStack(Atomic.itemAntimatter, 1, 1), Array[AnyRef](Atomic.itemAntimatter, Atomic.itemAntimatter, Atomic.itemAntimatter, Atomic.itemAntimatter, Atomic.itemAntimatter, Atomic.itemAntimatter, Atomic.itemAntimatter, Atomic.itemAntimatter)))
GameRegistry.addRecipe(new ShapelessOreRecipe(new ItemStack(Atomic.itemAntimatter, 8, 0), Array[AnyRef](new ItemStack(Atomic.itemAntimatter, 1, 1))))
GameRegistry.addRecipe(new ShapedOreRecipe(new ItemStack(Atomic.blockSteamFunnel, 2), Array[AnyRef](" B ", "B B", "B B", 'B', UniversalRecipe.SECONDARY_METAL.get)))
GameRegistry.addRecipe(new ShapedOreRecipe(new ItemStack(Atomic.blockSteamFunnel, 2), Array[AnyRef](" B ", "B B", "B B", 'B', "ingotIron")))
GameRegistry.addRecipe(new ShapedOreRecipe(Atomic.blockQuantumAssembler, Array[AnyRef]("CCC", "SXS", "SSS", 'X', Atomic.blockCentrifuge, 'C', UniversalRecipe.CIRCUIT_T3.get, 'S', UniversalRecipe.PRIMARY_PLATE.get)))
GameRegistry.addRecipe(new ShapedOreRecipe(Atomic.blockFulmination, Array[AnyRef]("OSO", "SCS", "OSO", 'O', Blocks.obsidian, 'C', UniversalRecipe.CIRCUIT_T2.get, 'S', UniversalRecipe.PRIMARY_PLATE.get)))
GameRegistry.addRecipe(new ShapedOreRecipe(Atomic.blockAccelerator, Array[AnyRef]("SCS", "CMC", "SCS", 'M', UniversalRecipe.MOTOR.get, 'C', UniversalRecipe.CIRCUIT_T3.get, 'S', UniversalRecipe.PRIMARY_PLATE.get)))
GameRegistry.addRecipe(new ShapedOreRecipe(Atomic.blockCentrifuge, Array[AnyRef]("BSB", "MCM", "BSB", 'C', UniversalRecipe.CIRCUIT_T2.get, 'S', UniversalRecipe.PRIMARY_PLATE.get, 'B', UniversalRecipe.SECONDARY_METAL.get, 'M', UniversalRecipe.MOTOR.get)))
GameRegistry.addRecipe(new ShapedOreRecipe(Atomic.blockNuclearBoiler, Array[AnyRef]("S S", "FBF", "SMS", 'F', Blocks.furnace, 'S', UniversalRecipe.PRIMARY_PLATE.get, 'B', Items.bucket, 'M', UniversalRecipe.MOTOR.get)))
GameRegistry.addRecipe(new ShapedOreRecipe(Atomic.blockChemicalExtractor, Array[AnyRef]("BSB", "MCM", "BSB", 'C', UniversalRecipe.CIRCUIT_T3.get, 'S', UniversalRecipe.PRIMARY_PLATE.get, 'B', UniversalRecipe.SECONDARY_METAL.get, 'M', UniversalRecipe.MOTOR.get)))
GameRegistry.addRecipe(new ShapedOreRecipe(new ItemStack(Atomic.blockSiren, 2), Array[AnyRef]("NPN", 'N', Blocks.noteblock, 'P', UniversalRecipe.SECONDARY_PLATE.get)))
GameRegistry.addRecipe(new ShapedOreRecipe(Atomic.blockReactorCell, Array[AnyRef]("SCS", "MEM", "SCS", 'E', "cellEmpty", 'C', UniversalRecipe.CIRCUIT_T2.get, 'S', UniversalRecipe.PRIMARY_PLATE.get, 'M', UniversalRecipe.MOTOR.get)))
GameRegistry.addRecipe(new ShapedOreRecipe(Atomic.blockFusionCore, Array[AnyRef]("CPC", "PFP", "CPC", 'P', UniversalRecipe.PRIMARY_PLATE.get, 'F', Atomic.blockReactorCell, 'C', UniversalRecipe.CIRCUIT_T3.get)))
GameRegistry.addRecipe(new ShapedOreRecipe(new ItemStack(Atomic.itemCell, 16), Array[AnyRef](" T ", "TGT", " T ", 'T', "ingotTin", 'G', Blocks.glass)))
GameRegistry.addRecipe(new ShapelessOreRecipe(new ItemStack(Atomic.itemWaterCell), Array[AnyRef]("cellEmpty", Items.water_bucket)))
GameRegistry.addRecipe(new ShapedOreRecipe(Atomic.blockThermometer, Array[AnyRef]("SSS", "GCG", "GSG", 'S', UniversalRecipe.PRIMARY_METAL.get, 'G', Blocks.glass, 'C', UniversalRecipe.CIRCUIT_T1.get)))
GameRegistry.addRecipe(new ShapedOreRecipe(Atomic.blockControlRod, Array[AnyRef]("I", "I", "I", 'I', Items.iron_ingot)))
GameRegistry.addRecipe(new ShapedOreRecipe(Atomic.itemFissileFuel, Array[AnyRef]("CUC", "CUC", "CUC", 'U', "ingotUranium", 'C', "cellEmpty")))
GameRegistry.addRecipe(new ShapedOreRecipe(Atomic.itemBreedingRod, Array[AnyRef]("CUC", "CUC", "CUC", 'U', "breederUranium", 'C', "cellEmpty")))
GameRegistry.addRecipe(new ShapedOreRecipe(new ItemStack(Atomic.blockElectromagnet, 2, 0), Array[AnyRef]("BBB", "BMB", "BBB", 'B', UniversalRecipe.SECONDARY_METAL.get, 'M', UniversalRecipe.MOTOR.get)))
GameRegistry.addRecipe(new ShapelessOreRecipe(new ItemStack(Atomic.blockElectromagnet, 1, 1), Array[AnyRef](Atomic.blockElectromagnet, Blocks.glass)))
GameRegistry.addRecipe(new ShapedOreRecipe(Atomic.itemHazmatTop, Array[AnyRef]("SSS", "BAB", "SCS", 'A', Items.leather_helmet, 'C', UniversalRecipe.CIRCUIT_T1.get, 'S', Blocks.wool)))
GameRegistry.addRecipe(new ShapedOreRecipe(Atomic.itemHazmatBody, Array[AnyRef]("SSS", "BAB", "SCS", 'A', Items.leather_chestplate, 'C', UniversalRecipe.CIRCUIT_T1.get, 'S', Blocks.wool)))
GameRegistry.addRecipe(new ShapedOreRecipe(Atomic.itemHazmatLeggings, Array[AnyRef]("SSS", "BAB", "SCS", 'A', Items.leather_leggings, 'C', UniversalRecipe.CIRCUIT_T1.get, 'S', Blocks.wool)))
GameRegistry.addRecipe(new ShapedOreRecipe(Atomic.itemHazmatBoots, Array[AnyRef]("SSS", "BAB", "SCS", 'A', Items.leather_boots, 'C', UniversalRecipe.CIRCUIT_T1.get, 'S', Blocks.wool)))
EntityRegistry.registerGlobalEntityID(classOf[EntityParticle], "ASParticle", EntityRegistry.findGlobalUniqueEntityId)
EntityRegistry.registerModEntity(classOf[EntityParticle], "ASParticle", Atomic.ENTITY_ID_PREFIX, this, 80, 3, true)
Atomic.proxy.init
Settings.config.load
for (oreName <- OreDictionary.getOreNames) {
if (oreName.startsWith("ingot")) {
import scala.collection.JavaConversions._
for (itemStack <- OreDictionary.getOres(oreName)) {
if (itemStack != null) {
QuantumAssemblerRecipes.addRecipe(itemStack)
}
}
}
}
Settings.config.save
}
@SubscribeEvent def thermalEventHandler(evt: EventThermal.EventThermalUpdate) {
val pos: VectorWorld = evt.position
val block: Block = pos.getBlock
if (block == Atomic.blockElectromagnet) {
evt.heatLoss = evt.deltaTemperature * 0.6f
}
}
@EventHandler def plasmaEvent(evt: PlasmaEvent.SpawnPlasmaEvent) {
val block: Block = evt.world.getBlock(evt.x, evt.y, evt.z)
if (block != null && block.getBlockHardness(evt.world, evt.x, evt.y, evt.z) >= 0) {
val tile: TileEntity = evt.world.getTileEntity(evt.x, evt.y, evt.z)
if (tile.isInstanceOf[TilePlasma]) {
(tile.asInstanceOf[TilePlasma]).setTemperature(evt.temperature)
return
}
else if (tile.isInstanceOf[IElectromagnet]) {
return
}
else {
evt.world.setBlockToAir(evt.x, evt.y, evt.z)
evt.world.setBlock(evt.x, evt.y, evt.z, Atomic.blockPlasma)
}
}
}
@EventHandler
@SideOnly(Side.CLIENT) def preTextureHook(event: TextureStitchEvent.Pre) {
if (event.map.getTextureType == 0) {
RenderUtility.registerIcon(Reference.prefix + "uraniumHexafluoride", event.map)
RenderUtility.registerIcon(Reference.prefix + "steam", event.map)
RenderUtility.registerIcon(Reference.prefix + "deuterium", event.map)
RenderUtility.registerIcon(Reference.prefix + "tritium", event.map)
RenderUtility.registerIcon(Reference.prefix + "atomic_edge", event.map)
RenderUtility.registerIcon(Reference.prefix + "funnel_edge", event.map)
RenderUtility.registerIcon(Reference.prefix + "glass", event.map)
}
}
@EventHandler
@SideOnly(Side.CLIENT) def postTextureHook(event: TextureStitchEvent.Post) {
Atomic.FLUID_URANIUM_HEXAFLOURIDE.setIcons(RenderUtility.loadedIconMap.get(Reference.prefix + "uraniumHexafluoride"))
Atomic.FLUID_STEAM.setIcons(RenderUtility.loadedIconMap.get(Reference.prefix + "steam"))
Atomic.FLUID_DEUTERIUM.setIcons(RenderUtility.loadedIconMap.get(Reference.prefix + "deuterium"))
Atomic.FLUID_TRITIUM.setIcons(RenderUtility.loadedIconMap.get(Reference.prefix + "tritium"))
Atomic.FLUID_TOXIC_WASTE.setIcons(Atomic.blockToxicWaste.getIcon(0, 0))
Atomic.FLUID_PLASMA.setIcons(Atomic.blockPlasma.getIcon(0, 0))
}
@EventHandler def fillBucketEvent(evt: FillBucketEvent) {
if (!evt.world.isRemote && evt.target != null && evt.target.typeOfHit == MovingObjectPosition.MovingObjectType.BLOCK) {
val pos: VectorWorld = new VectorWorld(evt.world, evt.target)
if (pos.getBlock eq Atomic.blockToxicWaste) {
pos.setBlockToAir
evt.result = new ItemStack(Atomic.itemBucketToxic)
evt.setResult(Event.Result.ALLOW)
}
}
}
}

116
src/main/scala/resonantinduction/atomic/ClientProxy.java
View file

@ -1,116 +0,0 @@
package resonantinduction.atomic;
import resonantinduction.atomic.machine.accelerator.EntityParticle;
import resonantinduction.atomic.machine.accelerator.RenderParticle;
import atomic.machine.boiler.GuiNuclearBoiler;
import resonantinduction.atomic.machine.boiler.RenderNuclearBoiler;
import atomic.machine.boiler.TileNuclearBoiler;
import resonantinduction.atomic.machine.centrifuge.GuiCentrifuge;
import atomic.machine.centrifuge.RenderCentrifuge;
import resonantinduction.atomic.machine.extractor.RenderChemicalExtractor;
import atomic.machine.extractor.TileChemicalExtractor;
import resonantinduction.atomic.machine.extractor.turbine.TileElectricTurbine;
import atomic.machine.plasma.RenderPlasmaHeater;
import resonantinduction.atomic.machine.quantum.TileQuantumAssembler;
import atomic.machine.reactor.GuiReactorCell;
import resonantinduction.atomic.machine.reactor.RenderReactorCell;
import resonantinduction.atomic.machine.thermometer.RenderThermometer;
import resonantinduction.atomic.machine.thermometer.TileThermometer;
import net.minecraft.block.Block;
import net.minecraft.client.Minecraft;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.world.World;
import net.minecraftforge.common.MinecraftForge;
import resonant.lib.render.block.BlockRenderingHandler;
import atomic.machine.accelerator.GuiAccelerator;
import atomic.machine.accelerator.TileAccelerator;
import atomic.machine.boiler.GuiChemicalExtractor;
import atomic.machine.centrifuge.TileCentrifuge;
import atomic.machine.extractor.turbine.RenderElectricTurbine;
import atomic.machine.plasma.TilePlasmaHeater;
import atomic.machine.quantum.GuiQuantumAssembler;
import atomic.machine.reactor.TileReactorCell;
import cpw.mods.fml.client.registry.ClientRegistry;
import cpw.mods.fml.client.registry.RenderingRegistry;
import resonantinduction.atomic.machine.accelerator.EntityParticle;
import resonantinduction.atomic.machine.accelerator.RenderParticle;
import resonantinduction.atomic.machine.boiler.RenderNuclearBoiler;
import resonantinduction.atomic.machine.centrifuge.GuiCentrifuge;
import resonantinduction.atomic.machine.extractor.RenderChemicalExtractor;
import resonantinduction.atomic.machine.extractor.turbine.TileElectricTurbine;
import resonantinduction.atomic.machine.quantum.TileQuantumAssembler;
import resonantinduction.atomic.machine.reactor.RenderReactorCell;
import resonantinduction.atomic.machine.thermometer.RenderThermometer;
import resonantinduction.atomic.machine.thermometer.TileThermometer;
public class ClientProxy extends CommonProxy
{
@Override
public void preInit()
{
RenderingRegistry.registerBlockHandler(new BlockRenderingHandler());
}
@Override
public int getArmorIndex(String armor)
{
return RenderingRegistry.addNewArmourRendererPrefix(armor);
}
@Override
public void init()
{
super.init();
ClientRegistry.bindTileEntitySpecialRenderer(TileCentrifuge.class, new RenderCentrifuge());
ClientRegistry.bindTileEntitySpecialRenderer(TilePlasmaHeater.class, new RenderPlasmaHeater());
ClientRegistry.bindTileEntitySpecialRenderer(TileNuclearBoiler.class, new RenderNuclearBoiler());
ClientRegistry.bindTileEntitySpecialRenderer(TileElectricTurbine.class, new RenderElectricTurbine());
ClientRegistry.bindTileEntitySpecialRenderer(TileThermometer.class, new RenderThermometer());
ClientRegistry.bindTileEntitySpecialRenderer(TileChemicalExtractor.class, new RenderChemicalExtractor());
ClientRegistry.bindTileEntitySpecialRenderer(TileReactorCell.class, new RenderReactorCell());
RenderingRegistry.registerEntityRenderingHandler(EntityParticle.class, new RenderParticle());
}
@Override
public Object getClientGuiElement(int ID, EntityPlayer player, World world, int x, int y, int z)
{
TileEntity tileEntity = world.getTileEntity(x, y, z);
Block block = Block.blocksList[world.getBlockId(x, y, z)];
if (tileEntity instanceof TileCentrifuge)
{
return new GuiCentrifuge(player.inventory, ((TileCentrifuge) tileEntity));
}
else if (tileEntity instanceof TileChemicalExtractor)
{
return new GuiChemicalExtractor(player.inventory, ((TileChemicalExtractor) tileEntity));
}
else if (tileEntity instanceof TileAccelerator)
{
return new GuiAccelerator(player.inventory, ((TileAccelerator) tileEntity));
}
else if (tileEntity instanceof TileQuantumAssembler)
{
return new GuiQuantumAssembler(player.inventory, ((TileQuantumAssembler) tileEntity));
}
else if (tileEntity instanceof TileNuclearBoiler)
{
return new GuiNuclearBoiler(player.inventory, ((TileNuclearBoiler) tileEntity));
}
else if (tileEntity instanceof TileReactorCell)
{
return new GuiReactorCell(player.inventory, (TileReactorCell) tileEntity);
}
return null;
}
@Override
public boolean isFancyGraphics()
{
return Minecraft.getMinecraft().gameSettings.fancyGraphics;
}
}

83
src/main/scala/resonantinduction/atomic/ClientProxy.scala Normal file
View file

@ -0,0 +1,83 @@
package resonantinduction.atomic
import resonantinduction.atomic.machine.accelerator.EntityParticle
import resonantinduction.atomic.machine.accelerator.GuiAccelerator
import resonantinduction.atomic.machine.accelerator.RenderParticle
import resonantinduction.atomic.machine.accelerator.TileAccelerator
import resonantinduction.atomic.machine.boiler.GuiNuclearBoiler
import resonantinduction.atomic.machine.boiler.RenderNuclearBoiler
import resonantinduction.atomic.machine.boiler.TileNuclearBoiler
import resonantinduction.atomic.machine.centrifuge.GuiCentrifuge
import resonantinduction.atomic.machine.centrifuge.RenderCentrifuge
import resonantinduction.atomic.machine.centrifuge.TileCentrifuge
import resonantinduction.atomic.machine.extractor.GuiChemicalExtractor
import resonantinduction.atomic.machine.extractor.RenderChemicalExtractor
import resonantinduction.atomic.machine.extractor.TileChemicalExtractor
import resonantinduction.atomic.machine.plasma.RenderPlasmaHeater
import resonantinduction.atomic.machine.plasma.TilePlasmaHeater
import resonantinduction.atomic.machine.quantum.GuiQuantumAssembler
import resonantinduction.atomic.machine.quantum.TileQuantumAssembler
import resonantinduction.atomic.machine.reactor.GuiReactorCell
import resonantinduction.atomic.machine.reactor.RenderReactorCell
import resonantinduction.atomic.machine.reactor.TileReactorCell
import resonantinduction.atomic.machine.thermometer.RenderThermometer
import resonantinduction.atomic.machine.thermometer.TileThermometer
import net.minecraft.block.Block
import net.minecraft.client.Minecraft
import net.minecraft.entity.player.EntityPlayer
import net.minecraft.tileentity.TileEntity
import net.minecraft.world.World
import cpw.mods.fml.client.registry.ClientRegistry
import cpw.mods.fml.client.registry.RenderingRegistry
import resonantinduction.electrical.em.laser.BlockRenderingHandler
import resonantinduction.mechanical.energy.turbine.{TileElectricTurbine, RenderElectricTurbine}
class ClientProxy extends CommonProxy {
override def preInit {
RenderingRegistry.registerBlockHandler(new BlockRenderingHandler.type)
}
override def getArmorIndex(armor: String): Int = {
return RenderingRegistry.addNewArmourRendererPrefix(armor)
}
override def init {
super.init
ClientRegistry.bindTileEntitySpecialRenderer(classOf[TileCentrifuge], new RenderCentrifuge)
ClientRegistry.bindTileEntitySpecialRenderer(classOf[TilePlasmaHeater], new RenderPlasmaHeater)
ClientRegistry.bindTileEntitySpecialRenderer(classOf[TileNuclearBoiler], new RenderNuclearBoiler)
ClientRegistry.bindTileEntitySpecialRenderer(classOf[TileElectricTurbine], new RenderElectricTurbine)
ClientRegistry.bindTileEntitySpecialRenderer(classOf[TileThermometer], new RenderThermometer)
ClientRegistry.bindTileEntitySpecialRenderer(classOf[TileChemicalExtractor], new RenderChemicalExtractor)
ClientRegistry.bindTileEntitySpecialRenderer(classOf[TileReactorCell], new RenderReactorCell)
RenderingRegistry.registerEntityRenderingHandler(classOf[EntityParticle], new RenderParticle)
}
override def getClientGuiElement(ID: Int, player: EntityPlayer, world: World, x: Int, y: Int, z: Int): AnyRef = {
val tileEntity: TileEntity = world.getTileEntity(x, y, z)
val block: Block = world.getBlock(x, y, z)
if (tileEntity.isInstanceOf[TileCentrifuge]) {
return new GuiCentrifuge(player.inventory, (tileEntity.asInstanceOf[TileCentrifuge]))
}
else if (tileEntity.isInstanceOf[TileChemicalExtractor]) {
return new GuiChemicalExtractor(player.inventory, (tileEntity.asInstanceOf[TileChemicalExtractor]))
}
else if (tileEntity.isInstanceOf[TileAccelerator]) {
return new GuiAccelerator(player.inventory, (tileEntity.asInstanceOf[TileAccelerator]))
}
else if (tileEntity.isInstanceOf[TileQuantumAssembler]) {
return new GuiQuantumAssembler(player.inventory, (tileEntity.asInstanceOf[TileQuantumAssembler]))
}
else if (tileEntity.isInstanceOf[TileNuclearBoiler]) {
return new GuiNuclearBoiler(player, (tileEntity.asInstanceOf[TileNuclearBoiler]))
}
else if (tileEntity.isInstanceOf[TileReactorCell]) {
return new GuiReactorCell(player.inventory, tileEntity.asInstanceOf[TileReactorCell])
}
return null
}
override def isFancyGraphics: Boolean = {
return Minecraft.getMinecraft.gameSettings.fancyGraphics
}
}

63
src/main/scala/resonantinduction/atomic/CommonProxy.java
View file

@ -1,63 +0,0 @@
package resonantinduction.atomic;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.world.World;
import resonantinduction.atomic.machine.accelerator.TileAccelerator;
import resonantinduction.atomic.machine.centrifuge.TileCentrifuge;
import resonantinduction.atomic.machine.extractor.ContainerChemicalExtractor;
import resonantinduction.atomic.machine.plasma.ContainerNuclearBoiler;
import resonantinduction.atomic.machine.quantum.TileQuantumAssembler;
import resonantinduction.atomic.machine.reactor.ContainerReactorCell;
public class CommonProxy extends ProxyBase
{
public int getArmorIndex(String armor)
{
return 0;
}
@Override
public Object getClientGuiElement(int ID, EntityPlayer player, World world, int x, int y, int z)
{
return null;
}
@Override
public Object getServerGuiElement(int ID, EntityPlayer player, World world, int x, int y, int z)
{
TileEntity tileEntity = world.getTileEntity(x, y, z);
if (tileEntity instanceof TileCentrifuge)
{
return new ContainerCentrifuge(player.inventory, ((TileCentrifuge) tileEntity));
}
else if (tileEntity instanceof TileChemicalExtractor)
{
return new ContainerChemicalExtractor(player.inventory, ((TileChemicalExtractor) tileEntity));
}
else if (tileEntity instanceof TileAccelerator)
{
return new ContainerAccelerator(player.inventory, ((TileAccelerator) tileEntity));
}
else if (tileEntity instanceof TileQuantumAssembler)
{
return new ContainerQuantumAssembler(player.inventory, ((TileQuantumAssembler) tileEntity));
}
else if (tileEntity instanceof TileNuclearBoiler)
{
return new ContainerNuclearBoiler(player.inventory, ((TileNuclearBoiler) tileEntity));
}
else if (tileEntity instanceof TileReactorCell)
{
return new ContainerReactorCell(player, ((TileReactorCell) tileEntity));
}
return null;
}
public boolean isFancyGraphics()
{
return false;
}
}

64
src/main/scala/resonantinduction/atomic/CommonProxy.scala Normal file
View file

@ -0,0 +1,64 @@
package resonantinduction.atomic
import cpw.mods.fml.common.network.IGuiHandler
import net.minecraft.entity.player.EntityPlayer
import net.minecraft.tileentity.TileEntity
import net.minecraft.world.World
import resonantinduction.atomic.machine.accelerator.ContainerAccelerator
import resonantinduction.atomic.machine.accelerator.TileAccelerator
import resonantinduction.atomic.machine.boiler.TileNuclearBoiler
import resonantinduction.atomic.machine.centrifuge.ContainerCentrifuge
import resonantinduction.atomic.machine.centrifuge.TileCentrifuge
import resonantinduction.atomic.machine.extractor.ContainerChemicalExtractor
import resonantinduction.atomic.machine.boiler.ContainerNuclearBoiler
import resonantinduction.atomic.machine.extractor.TileChemicalExtractor
import resonantinduction.atomic.machine.quantum.ContainerQuantumAssembler
import resonantinduction.atomic.machine.quantum.TileQuantumAssembler
import resonantinduction.atomic.machine.reactor.ContainerReactorCell
import resonantinduction.atomic.machine.reactor.TileReactorCell
class CommonProxy extends IGuiHandler {
def preInit {
}
def init {
}
def postInit {
}
def getArmorIndex(armor: String): Int = {
return 0
}
def getClientGuiElement(ID: Int, player: EntityPlayer, world: World, x: Int, y: Int, z: Int): AnyRef = {
return null
}
def getServerGuiElement(ID: Int, player: EntityPlayer, world: World, x: Int, y: Int, z: Int): AnyRef = {
val tileEntity: TileEntity = world.getTileEntity(x, y, z)
if (tileEntity.isInstanceOf[TileCentrifuge]) {
return new ContainerCentrifuge(player.inventory, (tileEntity.asInstanceOf[TileCentrifuge]))
}
else if (tileEntity.isInstanceOf[TileChemicalExtractor]) {
return new ContainerChemicalExtractor(player.inventory, (tileEntity.asInstanceOf[TileChemicalExtractor]))
}
else if (tileEntity.isInstanceOf[TileAccelerator]) {
return new ContainerAccelerator(player, (tileEntity.asInstanceOf[TileAccelerator]))
}
else if (tileEntity.isInstanceOf[TileQuantumAssembler]) {
return new ContainerQuantumAssembler(player.inventory, (tileEntity.asInstanceOf[TileQuantumAssembler]))
}
else if (tileEntity.isInstanceOf[TileNuclearBoiler]) {
return new ContainerNuclearBoiler(player, (tileEntity.asInstanceOf[TileNuclearBoiler]))
}
else if (tileEntity.isInstanceOf[TileReactorCell]) {
return new ContainerReactorCell(player, (tileEntity.asInstanceOf[TileReactorCell]))
}
return null
}
def isFancyGraphics: Boolean = {
return false
}
}

22
src/main/scala/resonantinduction/atomic/machine/extractor/turbine/TileFunnel.java → src/main/scala/resonantinduction/atomic/machine/TileFunnel.java
View file

@ -1,4 +1,4 @@
package resonantinduction.atomic.machine.extractor.turbine;
package resonantinduction.atomic.machine;
import net.minecraft.block.material.Material;
import net.minecraft.client.renderer.texture.IIconRegister;
@ -13,15 +13,12 @@ import net.minecraftforge.fluids.FluidTank;
import net.minecraftforge.fluids.FluidTankInfo;
import net.minecraftforge.fluids.IFluidHandler;
import resonant.api.IBoilHandler;
import resonant.lib.content.module.TileBase;
import resonant.lib.content.module.TileRender;
import resonant.lib.utility.ConnectedTextureRenderer;
import resonantinduction.core.Reference;
import resonant.content.prefab.java.TileAdvanced;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
/** Funnel for gas. */
public class TileFunnel extends TileBase implements IBoilHandler
public class TileFunnel extends TileAdvanced implements IBoilHandler
{
private static IIcon iconTop;
private final FluidTank tank = new FluidTank(FluidContainerRegistry.BUCKET_VOLUME * 16);
@ -43,13 +40,13 @@ public class TileFunnel extends TileBase implements IBoilHandler
public void registerIcons(IIconRegister iconRegister)
{
super.registerIcons(iconRegister);
iconTop = iconRegister.registerIcon(domain + name + "_top");
iconTop = iconRegister.registerIcon(getTextureName() + "_top");
}
@Override
public void updateEntity()
public void update()
{
super.updateEntity();
super.update();
if (tank.getFluidAmount() > 0)
{
@ -139,11 +136,4 @@ public class TileFunnel extends TileBase implements IBoilHandler
return new FluidTankInfo[]
{ tank.getInfo() };
}
@SideOnly(Side.CLIENT)
@Override
protected TileRender newRenderer()
{
return new ConnectedTextureRenderer(this, Reference.PREFIX + "funnel_edge");
}
}

5
src/main/scala/resonantinduction/atomic/machine/accelerator/TileAccelerator.java
View file

@ -10,8 +10,6 @@ import resonantinduction.atomic.items.ItemAntimatter;
import resonantinduction.atomic.items.ItemDarkMatter;
import net.minecraft.block.Block;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.IInventory;
import net.minecraft.inventory.ISidedInventory;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraftforge.common.util.ForgeDirection;
@ -19,10 +17,7 @@ import resonant.api.IElectromagnet;
import resonant.api.IRotatable;
import resonant.lib.network.Synced;
import resonantinduction.core.Reference;
import resonantinduction.core.ResonantInduction;
import resonantinduction.core.Settings;
import universalelectricity.api.core.grid.INodeProvider;
import universalelectricity.api.core.grid.electric.IEnergyNode;
import universalelectricity.core.transform.vector.Vector3;
import resonant.lib.content.prefab.java.TileElectricInventory;

21
src/main/scala/resonantinduction/atomic/machine/plasma/ContainerNuclearBoiler.java → src/main/scala/resonantinduction/atomic/machine/boiler/ContainerNuclearBoiler.java
View file

@ -1,15 +1,15 @@
package resonantinduction.atomic.machine.plasma;
package resonantinduction.atomic.machine.boiler;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.entity.player.InventoryPlayer;
import net.minecraft.inventory.IInventory;
import net.minecraft.inventory.Slot;
import net.minecraft.item.ItemStack;
import net.minecraftforge.fluids.FluidContainerRegistry;
import resonant.lib.gui.ContainerBase;
import resonant.lib.prefab.slot.SlotEnergyItem;
import resonant.lib.prefab.slot.SlotSpecific;
import atomic.Atomic;
import atomic.machine.boiler.TileNuclearBoiler;
import resonantinduction.atomic.Atomic;
/** Nuclear boiler container */
public class ContainerNuclearBoiler extends ContainerBase
@ -17,20 +17,19 @@ public class ContainerNuclearBoiler extends ContainerBase
private static final int slotCount = 4;
private TileNuclearBoiler tileEntity;
public ContainerNuclearBoiler(InventoryPlayer par1InventoryPlayer, TileNuclearBoiler tileEntity)
public ContainerNuclearBoiler(EntityPlayer player, TileNuclearBoiler tileEntity)
{
super(tileEntity);
super(player, (IInventory)tileEntity);
this.tileEntity = tileEntity;
// Battery
this.addSlotToContainer(new SlotEnergyItem(tileEntity, 0, 56, 26));
this.addSlotToContainer(new SlotEnergyItem((IInventory)tileEntity, 0, 56, 26));
// Water Input
this.addSlotToContainer(new Slot(tileEntity, 1, 25, 50));
this.addSlotToContainer(new Slot((IInventory)tileEntity, 1, 25, 50));
// Gas Output
this.addSlotToContainer(new Slot(tileEntity, 2, 136, 50));
this.addSlotToContainer(new Slot((IInventory)tileEntity, 2, 136, 50));
// Yellowcake Input
this.addSlotToContainer(new SlotSpecific(tileEntity, 3, 81, 26, new ItemStack(Atomic.itemYellowCake), new ItemStack(Atomic.blockUraniumOre)));
this.addPlayerInventory(par1InventoryPlayer.player);
tileEntity.openChest();
this.addSlotToContainer(new SlotSpecific((IInventory)tileEntity, 3, 81, 26, new ItemStack(Atomic.itemYellowCake), new ItemStack(Atomic.blockUraniumOre)));
this.addPlayerInventory(player);
}
@Override

39
src/main/scala/resonantinduction/atomic/machine/boiler/GuiNuclearBoiler.java
View file

@ -1,19 +1,18 @@
package resonantinduction.atomic.machine.boiler;
import resonantinduction.atomic.machine.plasma.ContainerNuclearBoiler;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.entity.player.InventoryPlayer;
import net.minecraft.util.StatCollector;
import resonant.lib.gui.GuiContainerBase;
import resonantinduction.atomic.machine.plasma.ContainerNuclearBoiler;
import universalelectricity.api.energy.UnitDisplay.Unit;
import universalelectricity.api.UnitDisplay;
public class GuiNuclearBoiler extends GuiContainerBase
{
private TileNuclearBoiler tileEntity;
public GuiNuclearBoiler(InventoryPlayer par1InventoryPlayer, TileNuclearBoiler tileEntity)
public GuiNuclearBoiler(EntityPlayer player, TileNuclearBoiler tileEntity)
{
super(new ContainerNuclearBoiler(par1InventoryPlayer, tileEntity));
super(new ContainerNuclearBoiler(player, tileEntity));
this.tileEntity = tileEntity;
}
@ -21,26 +20,26 @@ public class GuiNuclearBoiler extends GuiContainerBase
@Override
public void drawGuiContainerForegroundLayer(int mouseX, int mouseY)
{
this.fontRenderer.drawString(tileEntity.getInvName(), 52, 6, 4210752);
this.fontRendererObj.drawString("Boiler", 52, 6, 4210752);
this.renderUniversalDisplay(8, 112, TileNuclearBoiler.DIAN * 20, mouseX, mouseY, Unit.WATT);
this.renderUniversalDisplay(110, 112, this.tileEntity.getVoltageInput(null), mouseX, mouseY, Unit.VOLTAGE);
this.renderUniversalDisplay(8, 112, TileNuclearBoiler.DIAN * 20, mouseX, mouseY, UnitDisplay.Unit.WATT);
this.renderUniversalDisplay(110, 112, tileEntity.electricNode().voltage(), mouseX, mouseY, UnitDisplay.Unit.VOLTAGE);
this.fontRenderer.drawString("The nuclear boiler can boil", 8, 75, 4210752);
this.fontRenderer.drawString("yellow cake into uranium", 8, 85, 4210752);
this.fontRenderer.drawString("hexafluoride gas to be refined.", 8, 95, 4210752);
this.fontRendererObj.drawString("The nuclear boiler can boil", 8, 75, 4210752);
this.fontRendererObj.drawString("yellow cake into uranium", 8, 85, 4210752);
this.fontRendererObj.drawString("hexafluoride gas to be refined.", 8, 95, 4210752);
this.fontRenderer.drawString(StatCollector.translateToLocal("container.inventory"), 8, this.ySize - 96 + 2, 4210752);
this.fontRendererObj.drawString(StatCollector.translateToLocal("container.inventory"), 8, this.ySize - 96 + 2, 4210752);
if (this.isPointInRegion(8, 18, this.meterWidth, this.meterHeight, mouseX, mouseY) && this.tileEntity.waterTank.getFluid() != null)
{
this.drawTooltip(mouseX - this.guiLeft, mouseY - this.guiTop + 10, this.tileEntity.waterTank.getFluid().getFluid().getLocalizedName(), this.tileEntity.waterTank.getFluid().amount + " L");
//if (this.isPointInRegion(8, 18, this.meterWidth, this.meterHeight, mouseX, mouseY) && this.tileEntity.waterTank.getFluid() != null)
//{
// this.drawTooltip(mouseX - this.guiLeft, mouseY - this.guiTop + 10, this.tileEntity.waterTank.getFluid().getFluid().getLocalizedName(), this.tileEntity.waterTank.getFluid().amount + " L");
}
else if (this.isPointInRegion(155, 18, this.meterWidth, this.meterHeight, mouseX, mouseY) && this.tileEntity.gasTank.getFluid() != null)
{
this.drawTooltip(mouseX - this.guiLeft, mouseY - this.guiTop + 10, this.tileEntity.gasTank.getFluid().getFluid().getLocalizedName(), this.tileEntity.gasTank.getFluid().amount + " L");
}
//}
//else if (this.isPointInRegion(155, 18, this.meterWidth, this.meterHeight, mouseX, mouseY) && this.tileEntity.gasTank.getFluid() != null)
//{
// this.drawTooltip(mouseX - this.guiLeft, mouseY - this.guiTop + 10, this.tileEntity.gasTank.getFluid().getFluid().getLocalizedName(), this.tileEntity.gasTank.getFluid().amount + " L");
//}
}
/** Draw the background layer for the GuiContainer (everything behind the items) */

61
src/main/scala/resonantinduction/atomic/machine/centrifuge/BlockCentrifuge.java
View file

@ -1,61 +0,0 @@
package resonantinduction.atomic.machine.centrifuge;
import atomic.Atomic;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.world.World;
import resonant.lib.prefab.block.BlockRotatable;
import resonant.lib.render.block.BlockRenderingHandler;
import universalelectricity.api.UniversalElectricity;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
/** Centrifuge block */
public class BlockCentrifuge extends BlockRotatable
{
public BlockCentrifuge(int ID)
{
super(ID, UniversalElectricity.machine);
}
/** Called when the block is right clicked by the player */
@Override
public boolean onMachineActivated(World world, int x, int y, int z, EntityPlayer par5EntityPlayer, int side, float hitX, float hitY, float hitZ)
{
int metadata = world.getBlockMetadata(x, y, z);
if (!world.isRemote)
{
par5EntityPlayer.openGui(Atomic.INSTANCE, 0, world, x, y, z);
return true;
}
return true;
}
@Override
public TileEntity createNewTileEntity(World var1)
{
return new TileCentrifuge();
}
@Override
public boolean renderAsNormalBlock()
{
return false;
}
@Override
public boolean isOpaqueCube()
{
return false;
}
@SideOnly(Side.CLIENT)
@Override
public int getRenderType()
{
return BlockRenderingHandler.ID;
}
}

2
src/main/scala/resonantinduction/atomic/machine/centrifuge/ContainerCentrifuge.java
View file

@ -36,7 +36,7 @@ public class ContainerCentrifuge extends ContainerBase
public void onContainerClosed(EntityPlayer entityplayer)
{
super.onContainerClosed(entityplayer);
this.tileEntity.getPlayersUsing().remove(entityplayer);
//this.tileEntity.getPlayersUsing().remove(entityplayer);
}
@Override

27
src/main/scala/resonantinduction/atomic/machine/centrifuge/GuiCentrifuge.java
View file

@ -3,8 +3,7 @@ package resonantinduction.atomic.machine.centrifuge;
import net.minecraft.entity.player.InventoryPlayer;
import net.minecraft.util.StatCollector;
import resonant.lib.gui.GuiContainerBase;
import atomic.machine.boiler.TileNuclearBoiler;
import universalelectricity.api.energy.UnitDisplay.Unit;
import universalelectricity.api.UnitDisplay;
public class GuiCentrifuge extends GuiContainerBase
{
@ -20,7 +19,7 @@ public class GuiCentrifuge extends GuiContainerBase
@Override
public void drawGuiContainerForegroundLayer(int mouseX, int mouseY)
{
this.fontRenderer.drawString(tileEntity.getInvName(), 60, 6, 4210752);
this.fontRendererObj.drawString("Centrifuge", 60, 6, 4210752);
String displayText = "";
@ -37,21 +36,21 @@ public class GuiCentrifuge extends GuiContainerBase
displayText = "Idle";
}
this.fontRenderer.drawString("Status: " + displayText, 70, 50, 4210752);
this.fontRendererObj.drawString("Status: " + displayText, 70, 50, 4210752);
this.renderUniversalDisplay(8, 112, TileNuclearBoiler.DIAN * 20, mouseX, mouseY, Unit.WATT);
this.renderUniversalDisplay(100, 112, this.tileEntity.getVoltageInput(null), mouseX, mouseY, Unit.VOLTAGE);
this.renderUniversalDisplay(8, 112, TileCentrifuge.DIAN * 20, mouseX, mouseY, UnitDisplay.Unit.WATT);
this.renderUniversalDisplay(100, 112, this.tileEntity.getVoltageInput(null), mouseX, mouseY, UnitDisplay.Unit.VOLTAGE);
this.fontRenderer.drawString("The centrifuge spins", 8, 75, 4210752);
this.fontRenderer.drawString("uranium hexafluoride gas into", 8, 85, 4210752);
this.fontRenderer.drawString("enriched uranium for fission.", 8, 95, 4210752);
this.fontRendererObj.drawString("The centrifuge spins", 8, 75, 4210752);
this.fontRendererObj.drawString("uranium hexafluoride gas into", 8, 85, 4210752);
this.fontRendererObj.drawString("enriched uranium for fission.", 8, 95, 4210752);
this.fontRenderer.drawString(StatCollector.translateToLocal("container.inventory"), 8, this.ySize - 96 + 2, 4210752);
this.fontRendererObj.drawString(StatCollector.translateToLocal("container.inventory"), 8, this.ySize - 96 + 2, 4210752);
if (this.isPointInRegion(8, 18, this.meterWidth, this.meterHeight, mouseX, mouseY) && this.tileEntity.gasTank.getFluid() != null)
{
this.drawTooltip(mouseX - this.guiLeft, mouseY - this.guiTop + 10, this.tileEntity.gasTank.getFluid().getFluid().getLocalizedName(), this.tileEntity.gasTank.getFluid().amount + " L");
}
//if (this.isPointInRegion(8, 18, this.meterWidth, this.meterHeight, mouseX, mouseY) && this.tileEntity.gasTank.getFluid() != null)
//{
// this.drawTooltip(mouseX - this.guiLeft, mouseY - this.guiTop + 10, this.tileEntity.gasTank.getFluid().getFluid().getLocalizedName(), this.tileEntity.gasTank.getFluid().amount + " L");
//}
}
/** Draw the background layer for the GuiContainer (everything behind the items) */

114
src/main/scala/resonantinduction/atomic/machine/centrifuge/TileCentrifuge.java
View file

@ -1,11 +1,13 @@
package resonantinduction.atomic.machine.centrifuge;
import atomic.Atomic;
import io.netty.buffer.ByteBuf;
import net.minecraft.block.material.Material;
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.packet.Packet;
import net.minecraft.network.Packet;
import net.minecraft.tileentity.TileEntity;
import net.minecraftforge.common.util.ForgeDirection;
import net.minecraftforge.fluids.Fluid;
@ -15,23 +17,21 @@ import net.minecraftforge.fluids.FluidTank;
import net.minecraftforge.fluids.FluidTankInfo;
import net.minecraftforge.fluids.IFluidHandler;
import resonant.api.IRotatable;
import resonant.lib.network.IPacketReceiver;
import resonant.lib.prefab.tile.TileElectricalInventory;
import resonant.engine.ResonantEngine;
import resonant.lib.network.discriminator.PacketTile;
import resonant.lib.network.discriminator.PacketType;
import resonant.lib.network.handle.IPacketReceiver;
import resonantinduction.atomic.Atomic;
import resonantinduction.core.ResonantInduction;
import resonantinduction.core.Settings;
import universalelectricity.api.CompatibilityModule;
import universalelectricity.api.electricity.IVoltageInput;
import universalelectricity.api.energy.EnergyStorageHandler;
import universalelectricity.compatibility.Compatibility;
import universalelectricity.core.transform.vector.Vector3;
import universalelectricity.api.vector.VectorHelper;
import com.google.common.io.ByteArrayDataInput;
import cpw.mods.fml.common.network.PacketDispatcher;
import cpw.mods.fml.common.network.Player;
import resonant.lib.content.prefab.java.TileElectricInventory;
/** Centrifuge TileEntity */
public class TileCentrifuge extends TileElectricalInventory implements ISidedInventory, IPacketReceiver, IFluidHandler, IRotatable, IVoltageInput
public class TileCentrifuge extends TileElectricInventory implements IPacketReceiver, IFluidHandler
{
public static final int SHI_JIAN = 20 * 60;
@ -42,14 +42,17 @@ public class TileCentrifuge extends TileElectricalInventory implements ISidedInv
public TileCentrifuge()
{
energy = new EnergyStorageHandler(DIAN * 2);
maxSlots = 4;
super(Material.iron);
isOpaqueCube(true);
normalRender(false);
electricNode().energy().setCapacity(DIAN * 2);
setSizeInventory(4);
}
@Override
public void updateEntity()
public void update()
{
super.updateEntity();
super.update();
if (timer > 0)
{
@ -59,12 +62,12 @@ public class TileCentrifuge extends TileElectricalInventory implements ISidedInv
if (!this.worldObj.isRemote)
{
/** Look for nearby tanks that contains uranium gas and try to extract it. */
if (this.ticks % 20 == 0)
if (this.ticks() % 20 == 0)
{
for (int i = 0; i < 6; i++)
{
ForgeDirection direction = ForgeDirection.getOrientation(i);
TileEntity tileEntity = VectorHelper.getTileEntityFromSide(this.worldObj, new Vector3(this), direction);
TileEntity tileEntity = new Vector3(this).add( direction).getTileEntity(world());
if (tileEntity instanceof IFluidHandler && tileEntity.getClass() != this.getClass())
{
@ -95,7 +98,7 @@ public class TileCentrifuge extends TileElectricalInventory implements ISidedInv
{
this.discharge(getStackInSlot(0));
if (this.energy.extractEnergy(TileCentrifuge.DIAN, false) >= DIAN)
if (electricNode().energy().extractEnergy(TileCentrifuge.DIAN, false) >= DIAN)
{
if (this.timer == 0)
{
@ -117,7 +120,7 @@ public class TileCentrifuge extends TileElectricalInventory implements ISidedInv
this.timer = 0;
}
this.energy.extractEnergy(DIAN, true);
electricNode().energy().extractEnergy(DIAN, true);
}
}
else
@ -125,31 +128,25 @@ public class TileCentrifuge extends TileElectricalInventory implements ISidedInv
this.timer = 0;
}
if (this.ticks % 10 == 0)
if (this.ticks() % 10 == 0)
{
for (EntityPlayer player : this.getPlayersUsing())
{
PacketDispatcher.sendPacketToPlayer(getDescriptionPacket(), (Player) player);
}
//for (EntityPlayer player : this.getPlayersUsing())
//{
// PacketDispatcher.sendPacketToPlayer(getDescriptionPacket(), (Player) player);
//}
}
}
}
@Override
public long onReceiveEnergy(ForgeDirection from, long receive, boolean doReceive)
public boolean use(EntityPlayer player, int side, Vector3 hit)
{
if (this.nengYong())
{
return super.onReceiveEnergy(from, receive, doReceive);
}
else
{
return 0;
}
openGui(player, Atomic.INSTANCE);
return true;
}
@Override
public void onReceivePacket(ByteArrayDataInput data, EntityPlayer player, Object... extra)
public void read(ByteBuf data, EntityPlayer player, PacketType type)
{
try
{
@ -165,24 +162,7 @@ public class TileCentrifuge extends TileElectricalInventory implements ISidedInv
@Override
public Packet getDescriptionPacket()
{
return ResonantInduction.PACKET_TILE.getPacket(this, this.timer, Atomic.getFluidAmount(this.gasTank.getFluid()));
}
@Override
public void openChest()
{
if (!this.worldObj.isRemote)
{
for (EntityPlayer player : this.getPlayersUsing())
{
PacketDispatcher.sendPacketToPlayer(getDescriptionPacket(), (Player) player);
}
}
}
@Override
public void closeChest()
{
return ResonantEngine.instance.packetHandler.toMCPacket(new PacketTile(this, this.timer, Atomic.getFluidAmount(this.gasTank.getFluid())));
}
/** @return If the machine can be used. */
@ -190,7 +170,7 @@ public class TileCentrifuge extends TileElectricalInventory implements ISidedInv
{
if (this.gasTank.getFluid() != null)
{
if (this.gasTank.getFluid().amount >= Settings.uraniumHexaflourideRatio)
if (this.gasTank.getFluid().amount >= Settings.uraniumHexaflourideRatio())
{
return isItemValidForSlot(2, new ItemStack(Atomic.itemUranium)) && isItemValidForSlot(3, new ItemStack(Atomic.itemUranium, 1, 1));
}
@ -204,7 +184,7 @@ public class TileCentrifuge extends TileElectricalInventory implements ISidedInv
{
if (this.nengYong())
{
this.gasTank.drain(Settings.uraniumHexaflourideRatio, true);
this.gasTank.drain(Settings.uraniumHexaflourideRatio(), true);
if (this.worldObj.rand.nextFloat() > 0.6)
{
@ -313,33 +293,15 @@ public class TileCentrifuge extends TileElectricalInventory implements ISidedInv
switch (i)
{
case 0:
return CompatibilityModule.isHandler(itemStack.getItem());
return Compatibility.isHandler(itemStack.getItem());
case 1:
return true;
case 2:
return itemStack.itemID == Atomic.itemUranium.itemID;
return itemStack.getItem() == Atomic.itemUranium;
case 3:
return itemStack.itemID == Atomic.itemUranium.itemID;
return itemStack.getItem() == Atomic.itemUranium;
}
return false;
}
@Override
public long onExtractEnergy(ForgeDirection from, long extract, boolean doExtract)
{
return 0;
}
@Override
public long getVoltageInput(ForgeDirection from)
{
return 1000;
}
@Override
public void onWrongVoltage(ForgeDirection direction, long voltage)
{
}
}

62
src/main/scala/resonantinduction/atomic/machine/extractor/BlockChemicalExtractor.java
View file

@ -1,62 +0,0 @@
package resonantinduction.atomic.machine.extractor;
import atomic.Atomic;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.world.World;
import resonant.lib.prefab.block.BlockRotatable;
import resonant.lib.render.block.BlockRenderingHandler;
import universalelectricity.api.UniversalElectricity;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
/** Chemical Extractor
*
* @author Calclavia */
public class BlockChemicalExtractor extends BlockRotatable
{
public BlockChemicalExtractor(int ID)
{
super(ID, UniversalElectricity.machine);
}
/** Called when the block is right clicked by the player */
@Override
public boolean onMachineActivated(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);
if (!par1World.isRemote)
{
par5EntityPlayer.openGui(Atomic.INSTANCE, 0, par1World, x, y, z);
return true;
}
return true;
}
@Override
public TileEntity createNewTileEntity(World var1)
{
return new TileChemicalExtractor();
}
@Override
public boolean renderAsNormalBlock()
{
return false;
}
@Override
public boolean isOpaqueCube()
{
return false;
}
@SideOnly(Side.CLIENT)
@Override
public int getRenderType()
{
return BlockRenderingHandler.ID;
}
}

74
src/main/scala/resonantinduction/atomic/machine/extractor/TileChemicalExtractor.java
View file

@ -1,12 +1,14 @@
package resonantinduction.atomic.machine.extractor;
import net.minecraft.block.material.Material;
import net.minecraft.network.Packet;
import resonant.engine.ResonantEngine;
import resonant.lib.network.discriminator.PacketAnnotation;
import resonantinduction.atomic.Atomic;
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.packet.Packet;
import net.minecraftforge.common.util.ForgeDirection;
import net.minecraftforge.fluids.Fluid;
import net.minecraftforge.fluids.FluidContainerRegistry;
@ -20,15 +22,12 @@ import resonant.lib.network.Synced;
import resonantinduction.atomic.Atomic;
import resonantinduction.core.ResonantInduction;
import resonantinduction.core.Settings;
import universalelectricity.api.CompatibilityModule;
import universalelectricity.api.electricity.IVoltageInput;
import universalelectricity.api.energy.EnergyStorageHandler;
import cpw.mods.fml.common.network.PacketDispatcher;
import cpw.mods.fml.common.network.Player;
import universalelectricity.compatibility.Compatibility;
import universalelectricity.core.transform.vector.Vector3;
/** Chemical extractor TileEntity */
public class TileChemicalExtractor extends TileProcess implements ISidedInventory, IFluidHandler, IRotatable, IVoltageInput
public class TileChemicalExtractor extends TileProcess implements IFluidHandler
{
public static final int TICK_TIME = 20 * 14;
public static final int EXTRACT_SPEED = 100;
@ -47,6 +46,8 @@ public class TileChemicalExtractor extends TileProcess implements ISidedInventor
super(Material.iron);
electricNode().energy().setCapacity(ENERGY * 2);
this.setSizeInventory(7);
this.isOpaqueCube(true);
this.normalRender(false);
inputSlot = 1;
outputSlot = 2;
tankInputFillSlot = 3;
@ -101,7 +102,7 @@ public class TileChemicalExtractor extends TileProcess implements ISidedInventor
}
}
energy.extractEnergy(ENERGY, true);
electricNode().energy().extractEnergy(ENERGY, true);
}
else
{
@ -121,9 +122,17 @@ public class TileChemicalExtractor extends TileProcess implements ISidedInventor
@Override
public Packet getDescriptionPacket()
{
return ResonantInduction.PACKET_ANNOTATION.getPacket(this);
return ResonantEngine.instance.packetHandler.toMCPacket(new PacketAnnotation(this));
}
@Override
public boolean use(EntityPlayer player, int side, Vector3 hit)
{
openGui(player, Atomic.INSTANCE);
return true;
}
public boolean canUse()
{
if (inputTank.getFluid() != null)
@ -138,7 +147,7 @@ public class TileChemicalExtractor extends TileProcess implements ISidedInventor
if (outputTank.getFluidAmount() < outputTank.getCapacity())
{
if (inputTank.getFluid().getFluid().getID() == Atomic.FLUID_DEUTERIUM.getID() && inputTank.getFluid().amount >= Settings.deutermiumPerTritium * EXTRACT_SPEED)
if (inputTank.getFluid().getFluid().getID() == Atomic.FLUID_DEUTERIUM.getID() && inputTank.getFluid().amount >= Settings.deutermiumPerTritium() * EXTRACT_SPEED)
{
if (outputTank.getFluid() == null || Atomic.FLUIDSTACK_TRITIUM.equals(outputTank.getFluid()))
{
@ -146,7 +155,7 @@ public class TileChemicalExtractor extends TileProcess implements ISidedInventor
}
}
if (inputTank.getFluid().getFluid().getID() == FluidRegistry.WATER.getID() && inputTank.getFluid().amount >= Settings.waterPerDeutermium * EXTRACT_SPEED)
if (inputTank.getFluid().getFluid().getID() == FluidRegistry.WATER.getID() && inputTank.getFluid().amount >= Settings.waterPerDeutermium() * EXTRACT_SPEED)
{
if (outputTank.getFluid() == null || Atomic.FLUIDSTACK_DEUTERIUM.equals(outputTank.getFluid()))
{
@ -180,13 +189,13 @@ public class TileChemicalExtractor extends TileProcess implements ISidedInventor
{
if (canUse())
{
FluidStack drain = inputTank.drain(Settings.waterPerDeutermium * EXTRACT_SPEED, false);
FluidStack drain = inputTank.drain(Settings.waterPerDeutermium() * EXTRACT_SPEED, false);
if (drain != null && drain.amount >= 1 && drain.getFluid().getID() == FluidRegistry.WATER.getID())
{
if (outputTank.fill(new FluidStack(Atomic.FLUIDSTACK_DEUTERIUM, EXTRACT_SPEED), true) >= EXTRACT_SPEED)
{
inputTank.drain(Settings.waterPerDeutermium * EXTRACT_SPEED, true);
inputTank.drain(Settings.waterPerDeutermium() * EXTRACT_SPEED, true);
return true;
}
}
@ -199,15 +208,15 @@ public class TileChemicalExtractor extends TileProcess implements ISidedInventor
{
if (canUse())
{
int waterUsage = Settings.deutermiumPerTritium;
int waterUsage = Settings.deutermiumPerTritium();
FluidStack drain = inputTank.drain(Settings.deutermiumPerTritium * EXTRACT_SPEED, false);
FluidStack drain = inputTank.drain(Settings.deutermiumPerTritium() * EXTRACT_SPEED, false);
if (drain != null && drain.amount >= 1 && drain.getFluid().getID() == Atomic.FLUID_DEUTERIUM.getID())
{
if (outputTank.fill(new FluidStack(Atomic.FLUIDSTACK_TRITIUM, EXTRACT_SPEED), true) >= EXTRACT_SPEED)
{
inputTank.drain(Settings.deutermiumPerTritium * EXTRACT_SPEED, true);
inputTank.drain(Settings.deutermiumPerTritium() * EXTRACT_SPEED, true);
return true;
}
}
@ -300,7 +309,7 @@ public class TileChemicalExtractor extends TileProcess implements ISidedInventor
// Water input for machine.
if (slotID == 0)
{
return CompatibilityModule.isHandler(itemStack.getItem());
return Compatibility.isHandler(itemStack.getItem());
}
if (slotID == 1)
@ -342,37 +351,6 @@ public class TileChemicalExtractor extends TileProcess implements ISidedInventor
return slotID == 2;
}
@Override
public long onExtractEnergy(ForgeDirection from, long extract, boolean doExtract)
{
return 0;
}
@Override
public long onReceiveEnergy(ForgeDirection from, long receive, boolean doReceive)
{
if (this.canUse())
{
return super.onReceiveEnergy(from, receive, doReceive);
}
else
{
return 0;
}
}
@Override
public long getVoltageInput(ForgeDirection from)
{
return 1000;
}
@Override
public void onWrongVoltage(ForgeDirection direction, long voltage)
{
}
@Override
public FluidTank getInputTank()
{

7
src/main/scala/resonantinduction/atomic/machine/fulmination/FulminationHandler.java
View file

@ -4,11 +4,10 @@ import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import cpw.mods.fml.common.eventhandler.SubscribeEvent;
import resonantinduction.atomic.Atomic;
import net.minecraft.util.Vec3;
import net.minecraftforge.event.ForgeSubscribe;
import resonant.api.explosion.ExplosionEvent.DoExplosionEvent;
import resonantinduction.atomic.Atomic;
import universalelectricity.core.transform.vector.Vector3;
/** Atomic Science Event Handling. */
@ -31,7 +30,7 @@ public class FulminationHandler
list.remove(tileEntity);
}
@ForgeSubscribe
@SubscribeEvent
public void BaoZha(DoExplosionEvent evt)
{
if (evt.iExplosion != null)
@ -73,7 +72,7 @@ public class FulminationHandler
long energy = (long) Math.min(maxEnergyPerGenerator, maxEnergyPerGenerator / (juLi / evt.iExplosion.getRadius()));
energy = (long) Math.max((1 - density) * energy, 0);
tileEntity.getEnergyHandler().receiveEnergy(energy, true);
tileEntity.electricNode().energy().receiveEnergy(energy, true);
}
}
}

52
src/main/scala/resonantinduction/atomic/machine/fulmination/TileFulmination.java
View file

@ -4,26 +4,22 @@ import java.util.EnumSet;
import net.minecraft.block.material.Material;
import net.minecraftforge.common.util.ForgeDirection;
import resonant.lib.utility.ConnectedTextureRenderer;
import resonant.lib.content.module.TileRender;
import resonant.lib.prefab.tile.TileElectrical;
import resonantinduction.core.Reference;
import universalelectricity.api.electricity.IVoltageOutput;
import universalelectricity.api.energy.EnergyStorageHandler;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
import resonant.lib.content.prefab.java.TileElectric;
/** Fulmination TileEntity */
public class TileFulmination extends TileElectrical implements IVoltageOutput
public class TileFulmination extends TileElectric
{
private static final long DIAN = 10000000000000L;
public TileFulmination()
{
super(Material.iron);
energy = new EnergyStorageHandler(DIAN);
blockHardness = 10;
blockResistance = 25000;
electricNode().energy().setCapacity(DIAN * 2);
this.blockHardness(10);
this.blockResistance(25000);
}
@Override
@ -34,12 +30,11 @@ public class TileFulmination extends TileElectrical implements IVoltageOutput
}
@Override
public void updateEntity()
public void update()
{
super.updateEntity();
produce();
super.update();
// Slowly lose energy.
energy.extractEnergy(1, true);
electricNode().energy().extractEnergy(10, true);
}
@Override
@ -48,35 +43,4 @@ public class TileFulmination extends TileElectrical implements IVoltageOutput
FulminationHandler.INSTANCE.unregister(this);
super.initiate();
}
@Override
public long onReceiveEnergy(ForgeDirection from, long receive, boolean doReceive)
{
return 0;
}
@Override
public EnumSet<ForgeDirection> getInputDirections()
{
return EnumSet.noneOf(ForgeDirection.class);
}
@Override
public EnumSet<ForgeDirection> getOutputDirections()
{
return EnumSet.allOf(ForgeDirection.class);
}
@Override
public long getVoltageOutput(ForgeDirection side)
{
return 10000000000L;
}
@SideOnly(Side.CLIENT)
@Override
protected TileRender newRenderer()
{
return new ConnectedTextureRenderer(this, Reference.PREFIX + "atomic_edge");
}
}

6
src/main/scala/resonantinduction/atomic/machine/plasma/RenderPlasmaHeater.java
View file

@ -15,15 +15,15 @@ import cpw.mods.fml.relauncher.SideOnly;
@SideOnly(Side.CLIENT)
public class RenderPlasmaHeater extends RenderTaggedTile
{
public static final IModelCustom MODEL = AdvancedModelLoader.loadModel(Reference.MODEL_DIRECTORY + "fusionReactor.tcn");
public static final ResourceLocation TEXTURE = new ResourceLocation(Reference.DOMAIN, Reference.MODEL_PATH + "fusionReactor.png");
public static final IModelCustom MODEL = AdvancedModelLoader.loadModel(new ResourceLocation(Reference.modelDirectory() + "fusionReactor.tcn"));
public static final ResourceLocation TEXTURE = new ResourceLocation(Reference.domain(), Reference.modelPath() + "fusionReactor.png");
@Override
public void renderTileEntityAt(TileEntity t, double x, double y, double z, float f)
{
TilePlasmaHeater tileEntity = (TilePlasmaHeater) t;
if (tileEntity.worldObj != null)
if (tileEntity.world() != null)
{
super.renderTileEntityAt(t, x, y, z, f);
}

28
src/main/scala/resonantinduction/atomic/machine/plasma/TilePlasma.java
View file

@ -5,6 +5,7 @@ import java.util.ArrayList;
import net.minecraft.block.Block;
import net.minecraft.block.material.Material;
import net.minecraft.entity.Entity;
import net.minecraft.init.Blocks;
import net.minecraft.item.ItemStack;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.DamageSource;
@ -12,14 +13,13 @@ import net.minecraft.world.IBlockAccess;
import net.minecraftforge.common.util.ForgeDirection;
import net.minecraftforge.common.MinecraftForge;
import resonant.api.event.PlasmaEvent.SpawnPlasmaEvent;
import resonant.content.prefab.java.TileAdvanced;
import resonant.engine.grid.thermal.ThermalGrid;
import resonant.lib.config.Config;
import resonant.lib.content.module.TileBase;
import resonant.lib.prefab.vector.Cuboid;
import resonant.lib.thermal.ThermalGrid;
import universalelectricity.core.transform.vector.Vector3;
import universalelectricity.api.vector.VectorWorld;
import universalelectricity.core.transform.vector.VectorWorld;
public class TilePlasma extends TileBase
public class TilePlasma extends TileAdvanced
{
@Config
public static int plasmaMaxTemperature = 1000000;
@ -28,8 +28,8 @@ public class TilePlasma extends TileBase
public TilePlasma()
{
super(Material.lava);
textureName = "plasma";
isOpaqueCube = false;
textureName_$eq("plasma");
isOpaqueCube(false);
}
@Override
@ -44,12 +44,6 @@ public class TilePlasma extends TileBase
return false;
}
@Override
public Iterable<Cuboid> getCollisionBoxes()
{
return new ArrayList();
}
@Override
public ArrayList<ItemStack> getDrops(int metadata, int fortune)
{
@ -69,18 +63,18 @@ public class TilePlasma extends TileBase
}
@Override
public void updateEntity()
public void update()
{
super.updateEntity();
super.update();
ThermalGrid.addTemperature(new VectorWorld(this), (temperature - ThermalGrid.getTemperature(new VectorWorld(this))) * 0.1f);
if (ticks % 20 == 0)
if (ticks() % 20 == 0)
{
temperature /= 1.5;
if (temperature <= plasmaMaxTemperature / 10)
{
worldObj.setBlock(xCoord, yCoord, zCoord, Block.fire.blockID, 0, 3);
worldObj.setBlock(xCoord, yCoord, zCoord, Blocks.fire, 0, 3);
return;
}

67
src/main/scala/resonantinduction/atomic/machine/plasma/TilePlasmaHeater.java
View file

@ -2,10 +2,12 @@ package resonantinduction.atomic.machine.plasma;
import java.util.HashMap;
import atomic.Atomic;
import cpw.mods.fml.common.network.ByteBufUtils;
import io.netty.buffer.ByteBuf;
import net.minecraft.block.material.Material;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.network.packet.Packet;
import net.minecraft.network.Packet;
import net.minecraftforge.common.util.ForgeDirection;
import net.minecraftforge.fluids.Fluid;
import net.minecraftforge.fluids.FluidContainerRegistry;
@ -14,20 +16,21 @@ import net.minecraftforge.fluids.FluidTank;
import net.minecraftforge.fluids.FluidTankInfo;
import net.minecraftforge.fluids.IFluidHandler;
import resonant.api.ITagRender;
import resonant.engine.ResonantEngine;
import resonant.lib.config.Config;
import resonant.lib.network.IPacketReceiver;
import resonant.lib.network.PacketHandler;
import resonant.lib.prefab.tile.TileElectrical;
import resonant.lib.network.discriminator.PacketTile;
import resonant.lib.network.discriminator.PacketType;
import resonant.lib.network.handle.IPacketReceiver;
import resonant.lib.utility.LanguageUtility;
import resonantinduction.atomic.Atomic;
import resonantinduction.core.ResonantInduction;
import universalelectricity.api.energy.EnergyStorageHandler;
import universalelectricity.api.energy.UnitDisplay;
import universalelectricity.api.energy.UnitDisplay.Unit;
import universalelectricity.api.UnitDisplay;
import universalelectricity.core.transform.vector.Vector3;
import com.google.common.io.ByteArrayDataInput;
import resonant.lib.content.prefab.java.TileElectric;
public class TilePlasmaHeater extends TileElectrical implements IPacketReceiver, ITagRender, IFluidHandler
public class TilePlasmaHeater extends TileElectric implements IPacketReceiver, ITagRender, IFluidHandler
{
public static long joules = 10000000000L;
@ -42,30 +45,21 @@ public class TilePlasmaHeater extends TileElectrical implements IPacketReceiver,
public TilePlasmaHeater()
{
energy = new EnergyStorageHandler(joules, joules / 20);
super(Material.iron);
electricNode().energy().setCapacity(joules);
electricNode().energy().setMaxTransfer(joules / 20);
}
@Override
public long onReceiveEnergy(ForgeDirection from, long receive, boolean doReceive)
public void update()
{
if (tankInputDeuterium.getFluidAmount() > 0 && tankInputTritium.getFluidAmount() > 0)
{
return super.onReceiveEnergy(from, receive, doReceive);
}
super.update();
return 0;
}
@Override
public void updateEntity()
{
super.updateEntity();
rotation += energy.getEnergy() / 10000f;
rotation += electricNode().energy().getEnergy() / 10000f;
if (!worldObj.isRemote)
{
if (energy.checkExtract())
if (electricNode().energy().checkExtract())
{
// Creates plasma if there is enough Deuterium, Tritium AND Plasma output is not full.
if (tankInputDeuterium.getFluidAmount() >= plasmaHeatAmount &&
@ -75,14 +69,15 @@ public class TilePlasmaHeater extends TileElectrical implements IPacketReceiver,
tankInputDeuterium.drain(plasmaHeatAmount, true);
tankInputTritium.drain(plasmaHeatAmount, true);
tankOutput.fill(new FluidStack(Atomic.FLUID_PLASMA, tankOutput.getCapacity()), true);
energy.extractEnergy();
electricNode().energy().extractEnergy();
}
}
}
if (ticks % 80 == 0)
if (ticks() % 80 == 0)
{
PacketHandler.sendPacketToClients(getDescriptionPacket(), worldObj, new Vector3(this), 25);
world().markBlockForUpdate(x(), y(), z());
//PacketHandler.sendPacketToClients(getDescriptionPacket(), worldObj, new Vector3(this), 25);
}
}
@ -91,15 +86,15 @@ public class TilePlasmaHeater extends TileElectrical implements IPacketReceiver,
{
NBTTagCompound nbt = new NBTTagCompound();
writeToNBT(nbt);
return ResonantInduction.PACKET_TILE.getPacket(this, nbt);
return ResonantEngine.instance.packetHandler.toMCPacket(new PacketTile(this, nbt));
}
@Override
public void onReceivePacket(ByteArrayDataInput data, EntityPlayer player, Object... extra)
public void read(ByteBuf data, EntityPlayer player, PacketType type)
{
try
{
readFromNBT(PacketHandler.readNBTTagCompound(data));
readFromNBT(ByteBufUtils.readTag(data));
}
catch (Exception e)
{
@ -149,9 +144,9 @@ public class TilePlasmaHeater extends TileElectrical implements IPacketReceiver,
@Override
public float addInformation(HashMap<String, Integer> map, EntityPlayer player)
{
if (energy != null)
if (electricNode().energy() != null)
{
map.put(LanguageUtility.getLocal("tooltip.energy") + ": " + UnitDisplay.getDisplay(energy.getEnergy(), Unit.JOULES), 0xFFFFFF);
map.put(LanguageUtility.getLocal("tooltip.energy") + ": " + new UnitDisplay(UnitDisplay.Unit.JOULES, electricNode().energy().getEnergy()), 0xFFFFFF);
}
if (tankInputDeuterium.getFluidAmount() > 0)
@ -172,12 +167,6 @@ public class TilePlasmaHeater extends TileElectrical implements IPacketReceiver,
return 1.5f;
}
@Override
public long onExtractEnergy(ForgeDirection from, long extract, boolean doExtract)
{
return 0;
}
@Override
public int fill(ForgeDirection from, FluidStack resource, boolean doFill)
{

23
src/main/scala/resonantinduction/atomic/machine/quantum/ContainerQuantumAssembler.java
View file

@ -1,5 +1,6 @@
package resonantinduction.atomic.machine.quantum;
import net.minecraft.inventory.IInventory;
import resonantinduction.atomic.Atomic;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.entity.player.InventoryPlayer;
@ -16,13 +17,13 @@ public class ContainerQuantumAssembler extends Container
public ContainerQuantumAssembler(InventoryPlayer par1InventoryPlayer, TileQuantumAssembler 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));
this.addSlotToContainer(new Slot((IInventory)tileEntity, 0, 80, 40));
this.addSlotToContainer(new Slot((IInventory)tileEntity, 1, 53, 56));
this.addSlotToContainer(new Slot((IInventory)tileEntity, 2, 107, 56));
this.addSlotToContainer(new Slot((IInventory)tileEntity, 3, 53, 88));
this.addSlotToContainer(new Slot((IInventory)tileEntity, 4, 107, 88));
this.addSlotToContainer(new Slot((IInventory)tileEntity, 5, 80, 103));
this.addSlotToContainer(new Slot((IInventory)tileEntity, 6, 80, 72));
int var3;
@ -39,15 +40,15 @@ public class ContainerQuantumAssembler extends Container
this.addSlotToContainer(new Slot(par1InventoryPlayer, var3, 8 + var3 * 18, 206));
}
this.tileEntity.getPlayersUsing().add(par1InventoryPlayer.player);
tileEntity.openChest();
//this.tileEntity.getPlayersUsing().add(par1InventoryPlayer.player);
//tileEntity.openChest();
}
@Override
public void onContainerClosed(EntityPlayer entityplayer)
{
super.onContainerClosed(entityplayer);
this.tileEntity.getPlayersUsing().remove(entityplayer);
//this.tileEntity.getPlayersUsing().remove(entityplayer);
}
@Override
@ -70,7 +71,7 @@ public class ContainerQuantumAssembler extends Container
if (par1 > 6)
{
if (itemStack.itemID == Atomic.itemDarkMatter.itemID)
if (itemStack.getItem() == Atomic.itemDarkMatter)
{
if (!this.mergeItemStack(itemStack, 0, 6, false))
{

12
src/main/scala/resonantinduction/atomic/machine/quantum/GuiQuantumAssembler.java
View file

@ -9,11 +9,11 @@ import org.lwjgl.opengl.GL11;
import resonant.lib.gui.GuiContainerBase;
import resonantinduction.atomic.Atomic;
import resonantinduction.core.Reference;
import universalelectricity.api.energy.UnitDisplay.Unit;
import universalelectricity.api.UnitDisplay;
public class GuiQuantumAssembler extends GuiContainerBase
{
public static final ResourceLocation TEXTURE = new ResourceLocation(Reference.DOMAIN, Atomic.GUI_TEXTURE_DIRECTORY + "gui_atomic_assembler.png");
public static final ResourceLocation TEXTURE = new ResourceLocation(Reference.domain(), Atomic.GUI_TEXTURE_DIRECTORY + "gui_atomic_assembler.png");
private TileQuantumAssembler tileEntity;
@ -31,7 +31,7 @@ public class GuiQuantumAssembler extends GuiContainerBase
@Override
public void drawGuiContainerForegroundLayer(int mouseX, int mouseY)
{
this.fontRenderer.drawString(this.tileEntity.getInvName(), 65 - this.tileEntity.getInvName().length(), 6, 4210752);
this.fontRendererObj.drawString("Assembler", 65 - "Assembler".length(), 6, 4210752);
String displayText = "";
if (this.tileEntity.time > 0)
@ -47,9 +47,9 @@ public class GuiQuantumAssembler extends GuiContainerBase
displayText = "Idle";
}
this.fontRenderer.drawString(displayText, 9, this.ySize - 106, 4210752);
this.renderUniversalDisplay(100, this.ySize - 94, this.tileEntity.getVoltageInput(null), mouseX, mouseY, Unit.VOLTAGE);
this.renderUniversalDisplay(8, this.ySize - 95, tileEntity.MAX_TIME, mouseX, mouseY, Unit.WATT);
this.fontRendererObj.drawString(displayText, 9, this.ySize - 106, 4210752);
this.renderUniversalDisplay(100, this.ySize - 94, this.tileEntity.electricNode().voltage(), mouseX, mouseY, UnitDisplay.Unit.VOLTAGE);
this.renderUniversalDisplay(8, this.ySize - 95, tileEntity.MAX_TIME, mouseX, mouseY, UnitDisplay.Unit.WATT);
}
/** Draw the background layer for the GuiContainer (everything behind the items) */

12
src/main/scala/resonantinduction/atomic/machine/quantum/RenderQuantumAssembler.java
View file

@ -20,8 +20,8 @@ import cpw.mods.fml.relauncher.SideOnly;
@SideOnly(Side.CLIENT)
public class RenderQuantumAssembler extends TileEntitySpecialRenderer
{
public static final IModelCustom MODEL = AdvancedModelLoader.loadModel(Reference.MODEL_DIRECTORY + "quantumAssembler.tcn");
public static final ResourceLocation TEXTURE = new ResourceLocation(Reference.DOMAIN, Reference.MODEL_PATH + "quantumAssembler.png");
public static final IModelCustom MODEL = AdvancedModelLoader.loadModel(new ResourceLocation(Reference.domain(), Reference.modelDirectory() + "quantumAssembler.tcn"));
public static final ResourceLocation TEXTURE = new ResourceLocation(Reference.domain(), Reference.modelPath() + "quantumAssembler.png");
private final RenderBlocks renderBlocks = new RenderBlocks();
@ -40,21 +40,21 @@ public class RenderQuantumAssembler extends TileEntitySpecialRenderer
bindTexture(TEXTURE);
GL11.glPushMatrix();
GL11.glRotatef(-tileEntity.rotation.floatX(), 0, 1f, 0);
GL11.glRotatef(-tileEntity.rotation.xf(), 0, 1f, 0);
MODEL.renderOnly(hands);
MODEL.renderOnly("Resonance_Crystal");
GL11.glPopMatrix();
/** Small Laser Arm */
GL11.glPushMatrix();
GL11.glRotatef(tileEntity.rotation.floatY(), 0, 1f, 0);
GL11.glRotatef(tileEntity.rotation.yf(), 0, 1f, 0);
MODEL.renderOnly(arms);
GL11.glPopMatrix();
/** Large Laser Arm */
GL11.glPushMatrix();
GL11.glRotatef(-tileEntity.rotation.floatZ(), 0, 1f, 0);
GL11.glRotatef(-tileEntity.rotation.zf(), 0, 1f, 0);
MODEL.renderOnly(largeArms);
GL11.glPopMatrix();
@ -68,7 +68,7 @@ public class RenderQuantumAssembler extends TileEntitySpecialRenderer
if (tileEntity.entityItem != null)
{
renderItem.doRenderItem(tileEntity.entityItem, x + 0.5, y + 0.4, z + 0.5, 0, 0);
renderItem.doRender(tileEntity.entityItem, x + 0.5, y + 0.4, z + 0.5, 0, 0);
}
GL11.glPopMatrix();

101
src/main/scala/resonantinduction/atomic/machine/quantum/TileQuantumAssembler.java
View file

@ -1,32 +1,29 @@
package resonantinduction.atomic.machine.quantum;
import io.netty.buffer.ByteBuf;
import net.minecraft.block.material.Material;
import net.minecraft.entity.item.EntityItem;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.network.packet.Packet;
import net.minecraft.network.Packet;
import net.minecraftforge.common.util.ForgeDirection;
import resonant.api.recipe.QuantumAssemblerRecipes;
import resonant.lib.network.IPacketReceiver;
import resonant.lib.prefab.tile.TileElectricalInventory;
import atomic.Atomic;
import resonant.lib.network.discriminator.PacketTile;
import resonant.lib.network.discriminator.PacketType;
import resonant.lib.network.handle.IPacketReceiver;
import resonantinduction.atomic.Atomic;
import resonantinduction.core.Reference;
import resonantinduction.core.ResonantInduction;
import universalelectricity.api.electricity.IVoltageInput;
import universalelectricity.api.energy.EnergyStorageHandler;
import universalelectricity.core.transform.vector.Vector3;
import com.google.common.io.ByteArrayDataInput;
import cpw.mods.fml.common.network.PacketDispatcher;
import cpw.mods.fml.common.network.Player;
import resonant.lib.content.prefab.java.TileElectricInventory;
/** Atomic assembler of items *
*
* @author Calclavia, Darkguardsman */
public class TileQuantumAssembler extends TileElectricalInventory implements IPacketReceiver, IVoltageInput
public class TileQuantumAssembler extends TileElectricInventory implements IPacketReceiver
{
long ENERGY = 1000000000L;
int MAX_TIME = 20 * 120;
@ -41,12 +38,13 @@ public class TileQuantumAssembler extends TileElectricalInventory implements IPa
public TileQuantumAssembler()
{
super(Material.iron);
energy = new EnergyStorageHandler(ENERGY, ENERGY / 10);
maxSlots = 7;
isOpaqueCube = false;
normalRender = false;
customItemRender = true;
textureName = "machine";
setSizeInventory(7);
electricNode().energy().setCapacity(ENERGY);
electricNode().energy().setMaxTransfer(ENERGY / 10);
isOpaqueCube(false);
normalRender(false);
customItemRender(true);
setTextureName("machine");
}
/** Called when the block is right clicked by the player */
@ -60,16 +58,16 @@ public class TileQuantumAssembler extends TileElectricalInventory implements IPa
}
@Override
public void updateEntity()
public void update()
{
super.updateEntity();
super.update();
//Server side processing of items
if (!this.worldObj.isRemote)
{
if (this.canProcess())
{
if (energy.checkExtract())
if (electricNode().energy().checkExtract())
{
if (this.time == 0)
{
@ -88,19 +86,19 @@ public class TileQuantumAssembler extends TileElectricalInventory implements IPa
{
this.time = 0;
}
this.energy.extractEnergy(ENERGY, true);
electricNode().energy().extractEnergy(ENERGY, true);
}
}
else
{
this.time = 0;
}
if (this.ticks % 10 == 0)
if (this.ticks() % 10 == 0)
{
for (EntityPlayer player : this.getPlayersUsing())
{
PacketDispatcher.sendPacketToPlayer(getDescriptionPacket(), (Player) player);
}
//for (EntityPlayer player : this.getPlayersUsing())
//{
// PacketDispatcher.sendPacketToPlayer(getDescriptionPacket(), (Player) player);
//}
}
} //Client side animation
else if (this.time > 0)
@ -126,9 +124,9 @@ public class TileQuantumAssembler extends TileElectricalInventory implements IPa
}
//Audio update
if (this.ticks % 600 == 0)
if (this.ticks() % 600 == 0)
{
this.worldObj.playSoundEffect(this.xCoord, this.yCoord, this.zCoord, Reference.PREFIX + "assembler", 0.7f, 1f);
this.worldObj.playSoundEffect(this.xCoord, this.yCoord, this.zCoord, Reference.prefix() + "assembler", 0.7f, 1f);
}
//Animation frame update
@ -137,17 +135,7 @@ public class TileQuantumAssembler extends TileElectricalInventory implements IPa
}
@Override
public long onReceiveEnergy(ForgeDirection from, long receive, boolean doReceive)
{
if (this.canProcess())
{
return super.onReceiveEnergy(from, receive, doReceive);
}
return 0;
}
@Override
public void onReceivePacket(ByteArrayDataInput data, EntityPlayer player, Object... obj)
public void read(ByteBuf data, EntityPlayer player, PacketType type)
{
try
{
@ -157,7 +145,7 @@ public class TileQuantumAssembler extends TileElectricalInventory implements IPa
int itemMeta = data.readInt();
if (itemID != -1 && itemAmount != -1 && itemMeta != -1)
{
this.setInventorySlotContents(6, new ItemStack(Item.itemsList[itemID], itemAmount, itemMeta));
this.setInventorySlotContents(6, new ItemStack(Item.getItemById(itemID), itemAmount, itemMeta));
}
}
catch (Exception e)
@ -167,25 +155,13 @@ public class TileQuantumAssembler extends TileElectricalInventory implements IPa
}
@Override
public Packet getDescriptionPacket()
public PacketTile getDescPacket()
{
if (this.getStackInSlot(6) != null)
{
return ResonantInduction.PACKET_TILE.getPacket(this, time, getStackInSlot(6).itemID, getStackInSlot(6).stackSize, getStackInSlot(6).getItemDamage());
}
return ResonantInduction.PACKET_TILE.getPacket(this, time, -1, -1, -1);
}
@Override
public void openChest()
{
if (!this.worldObj.isRemote)
{
for (EntityPlayer player : this.getPlayersUsing())
{
PacketDispatcher.sendPacketToPlayer(getDescriptionPacket(), (Player) player);
}
return new PacketTile(this, time, getStackInSlot(6));
}
return new PacketTile(this, time, -1, -1, -1);
}
/** Checks to see if the assembler can run */
@ -199,7 +175,7 @@ public class TileQuantumAssembler extends TileElectricalInventory implements IPa
{
if (getStackInSlot(i) == null)
return false;
if (getStackInSlot(i).itemID != Atomic.itemDarkMatter.itemID)
if (getStackInSlot(i).getItem() != Atomic.itemDarkMatter)
return false;
}
return getStackInSlot(6).stackSize < 64;
@ -249,17 +225,6 @@ public class TileQuantumAssembler extends TileElectricalInventory implements IPa
{
return true;
}
return itemStack.itemID == Atomic.itemDarkMatter.itemID;
}
@Override
public long getVoltageInput(ForgeDirection from)
{
return 1000;
}
@Override
public void onWrongVoltage(ForgeDirection d, long voltage)
{
return itemStack.getItem() == Atomic.itemDarkMatter;
}
}

72
src/main/scala/resonantinduction/atomic/machine/reactor/BlockReactorDrain.java
View file

@ -1,72 +0,0 @@
package resonantinduction.atomic.machine.reactor;
import net.minecraft.client.renderer.texture.IIconRegister;
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 resonant.lib.prefab.block.BlockRotatable;
import universalelectricity.api.UniversalElectricity;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
/** Reactor tap block */
public class BlockReactorDrain extends BlockRotatable
{
private IIcon frontIcon;
public BlockReactorDrain(int id)
{
super(id, UniversalElectricity.machine);
}
@Override
public void onBlockPlacedBy(World world, int x, int y, int z, EntityLivingBase entityLiving, ItemStack itemStack)
{
if (MathHelper.abs((float) entityLiving.posX - x) < 2.0F && MathHelper.abs((float) entityLiving.posZ - z) < 2.0F)
{
double d0 = entityLiving.posY + 1.82D - entityLiving.yOffset;
if (d0 - y > 2.0D)
{
world.setBlockMetadataWithNotify(x, y, z, 1, 3);
return;
}
if (y - d0 > 0.0D)
{
world.setBlockMetadataWithNotify(x, y, z, 0, 3);
return;
}
}
super.onBlockPlacedBy(world, x, y, z, entityLiving, itemStack);
}
@Override
public IIcon getIcon(int side, int metadata)
{
if (side == metadata)
{
return this.frontIcon;
}
return this.blockIcon;
}
@SideOnly(Side.CLIENT)
@Override
public void registerIcons(IIconRegister iconRegister)
{
super.registerIcons(iconRegister);
this.frontIcon = iconRegister.registerIcon(this.getUnlocalizedName().replace("tile.", "") + "_front");
}
@Override
public TileEntity createNewTileEntity(World var1)
{
return new TileReactorDrain();
}
}

22
src/main/scala/resonantinduction/atomic/machine/reactor/GuiReactorCell.java
View file

@ -8,8 +8,6 @@ import org.lwjgl.opengl.GL11;
import resonant.lib.gui.GuiContainerBase;
import resonant.lib.utility.LanguageUtility;
import universalelectricity.api.energy.UnitDisplay;
import universalelectricity.api.energy.UnitDisplay.Unit;
public class GuiReactorCell extends GuiContainerBase
{
@ -25,23 +23,23 @@ public class GuiReactorCell extends GuiContainerBase
@Override
public void drawGuiContainerForegroundLayer(int x, int y)
{
fontRenderer.drawString(tileEntity.getInvName(), xSize / 2 - fontRenderer.getStringWidth(tileEntity.getInvName()) / 2, 6, 4210752);
fontRendererObj.drawString(tileEntity.getInvName(), xSize / 2 - fontRendererObj.getStringWidth(tileEntity.getInvName()) / 2, 6, 4210752);
if (tileEntity.getStackInSlot(0) != null)
{
// Test field for actual heat inside of reactor cell.
fontRenderer.drawString(LanguageUtility.getLocal("tooltip.temperature"), 9, 45, 4210752);
fontRenderer.drawString(String.valueOf((int) tileEntity.getTemperature()) + "/" + String.valueOf(TileReactorCell.MELTING_POINT) + " K", 9, 58, 4210752);
fontRendererObj.drawString(LanguageUtility.getLocal("tooltip.temperature"), 9, 45, 4210752);
fontRendererObj.drawString(String.valueOf((int) tileEntity.getTemperature()) + "/" + String.valueOf(TileReactorCell.MELTING_POINT()) + " K", 9, 58, 4210752);
// Text field for total number of ticks remaining.
int secondsLeft = (tileEntity.getStackInSlot(0).getMaxDamage() - tileEntity.getStackInSlot(0).getItemDamage());
fontRenderer.drawString(LanguageUtility.getLocal("tooltip.remainingTime"), 100, 45, 4210752);
fontRenderer.drawString(secondsLeft + " seconds", 100, 58, 4210752);
fontRendererObj.drawString(LanguageUtility.getLocal("tooltip.remainingTime"), 100, 45, 4210752);
fontRendererObj.drawString(secondsLeft + " seconds", 100, 58, 4210752);
}
fontRenderer.drawString(LanguageUtility.getLocal("tooltip.remainingTime"), 100, 45, 4210752);
fontRendererObj.drawString(LanguageUtility.getLocal("tooltip.remainingTime"), 100, 45, 4210752);
if (isPointInRegion(80, 40, meterWidth, meterHeight, x, y))
/** if (isPointInRegion(80, 40, meterWidth, meterHeight, x, y))
{
if (tileEntity.tank.getFluid() != null)
{
@ -58,7 +56,7 @@ public class GuiReactorCell extends GuiContainerBase
for (int i = 0; i < desc.size(); i++)
{
fontRenderer.drawString(desc.get(i), 9, 85 + i * 9, 4210752);
}
} **/
}
/** Draw the background layer for the GuiContainer (everything behind the items) */
@ -67,7 +65,7 @@ public class GuiReactorCell extends GuiContainerBase
{
super.drawGuiContainerBackgroundLayer(par1, x, y);
drawSlot(78, 16);
drawMeter(80, 36, (float) tileEntity.tank.getFluidAmount() / (float) tileEntity.tank.getCapacity(), tileEntity.tank.getFluid());
drawMeter(80, 36, (float) tileEntity.tank().getFluidAmount() / (float) tileEntity.tank().getCapacity(), tileEntity.tank().getFluid());
if (tileEntity.getStackInSlot(0) != null)
{
@ -75,7 +73,7 @@ public class GuiReactorCell extends GuiContainerBase
GL11.glPushMatrix();
GL11.glTranslatef(32 * 2, 0, 0);
GL11.glScalef(0.5f, 1, 1);
drawForce(20, 70, (tileEntity.getTemperature()) / (TileReactorCell.MELTING_POINT));
drawForce(20, 70, (tileEntity.getTemperature()) / (TileReactorCell.MELTING_POINT()));
GL11.glPopMatrix();
// Progress bar of remaining burn time on reactor cell.

18
src/main/scala/resonantinduction/atomic/machine/reactor/RenderReactorCell.java
View file

@ -17,14 +17,14 @@ import cpw.mods.fml.relauncher.SideOnly;
@SideOnly(Side.CLIENT)
public class RenderReactorCell extends TileEntitySpecialRenderer
{
public static final IModelCustom MODEL_TOP = AdvancedModelLoader.loadModel(Reference.MODEL_DIRECTORY + "reactorCellTop.tcn");
public static final IModelCustom MODEL_MIDDLE = AdvancedModelLoader.loadModel(Reference.MODEL_DIRECTORY + "reactorCellMiddle.tcn");
public static final IModelCustom MODEL_BOTTOM = AdvancedModelLoader.loadModel(Reference.MODEL_DIRECTORY + "reactorCellBottom.tcn");
public static final IModelCustom MODEL_TOP = AdvancedModelLoader.loadModel(new ResourceLocation(Reference.domain(), Reference.modelDirectory() + "reactorCellTop.tcn"));
public static final IModelCustom MODEL_MIDDLE = AdvancedModelLoader.loadModel(new ResourceLocation(Reference.domain(), Reference.modelDirectory() + "reactorCellMiddle.tcn"));
public static final IModelCustom MODEL_BOTTOM = AdvancedModelLoader.loadModel(new ResourceLocation(Reference.domain(), Reference.modelDirectory() + "reactorCellBottom.tcn"));
public static final ResourceLocation TEXTURE_TOP = new ResourceLocation(Reference.DOMAIN, Reference.MODEL_PATH + "reactorCellTop.png");
public static final ResourceLocation TEXTURE_MIDDLE = new ResourceLocation(Reference.DOMAIN, Reference.MODEL_PATH + "reactorCellMiddle.png");
public static final ResourceLocation TEXTURE_BOTTOM = new ResourceLocation(Reference.DOMAIN, Reference.MODEL_PATH + "reactorCellBottom.png");
public static final ResourceLocation TEXTURE_FISSILE = new ResourceLocation(Reference.DOMAIN, Reference.MODEL_PATH + "fissileMaterial.png");
public static final ResourceLocation TEXTURE_TOP = new ResourceLocation(Reference.domain(), Reference.modelPath() + "reactorCellTop.png");
public static final ResourceLocation TEXTURE_MIDDLE = new ResourceLocation(Reference.domain(), Reference.modelPath() + "reactorCellMiddle.png");
public static final ResourceLocation TEXTURE_BOTTOM = new ResourceLocation(Reference.domain(), Reference.modelPath() + "reactorCellBottom.png");
public static final ResourceLocation TEXTURE_FISSILE = new ResourceLocation(Reference.domain(), Reference.modelPath() + "fissileMaterial.png");
@Override
public void renderTileEntityAt(TileEntity t, double x, double y, double z, float f)
@ -37,12 +37,12 @@ public class RenderReactorCell extends TileEntitySpecialRenderer
int meta = 2;
if (tileEntity.worldObj != null)
if (tileEntity.world() != null)
{
meta = tileEntity.getBlockMetadata();
}
boolean hasBelow = tileEntity.worldObj != null && t.worldObj.getTileEntity(t.xCoord, t.yCoord - 1, t.zCoord) instanceof TileReactorCell;
boolean hasBelow = tileEntity.world() != null && t.getWorldObj().getTileEntity(t.xCoord, t.yCoord - 1, t.zCoord) instanceof TileReactorCell;
switch (meta)
{

65
src/main/scala/resonantinduction/atomic/machine/reactor/TileReactorDrain.java
View file

@ -5,9 +5,16 @@ import java.util.HashSet;
import java.util.List;
import java.util.Set;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
import net.minecraft.block.Block;
import net.minecraft.block.BlockFluid;
import net.minecraft.block.material.Material;
import net.minecraft.client.renderer.texture.IIconRegister;
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;
import net.minecraftforge.fluids.Fluid;
@ -16,9 +23,10 @@ import net.minecraftforge.fluids.FluidTankInfo;
import net.minecraftforge.fluids.IFluidBlock;
import net.minecraftforge.fluids.IFluidHandler;
import net.minecraftforge.fluids.IFluidTank;
import resonant.content.prefab.java.TileAdvanced;
import resonant.content.spatial.block.SpatialBlock;
import resonant.lib.path.IPathCallBack;
import resonant.lib.path.Pathfinder;
import resonant.lib.prefab.tile.TileAdvanced;
import universalelectricity.core.transform.vector.Vector3;
/** Reactor Drain
@ -29,6 +37,12 @@ public class TileReactorDrain extends TileAdvanced implements IFluidHandler
private final Set<IFluidTank> tanks = new HashSet<IFluidTank>();
private long lastFindTime = -1;
public TileReactorDrain()
{
super(Material.iron);
}
public void find()
{
this.tanks.clear();
@ -46,9 +60,9 @@ public class TileReactorDrain extends TileAdvanced implements IFluidHandler
{
ForgeDirection direction = ForgeDirection.getOrientation(i);
Vector3 position = currentNode.clone().add(direction);
int connectedBlockID = position.getBlock(world);
Block block = position.getBlock(world);
if (connectedBlockID == 0 || Block.blocksList[connectedBlockID] instanceof BlockFluid || Block.blocksList[connectedBlockID] instanceof IFluidBlock || position.getTileEntity(world) instanceof TileReactorCell)
if (block == null || block instanceof IFluidBlock || position.getTileEntity(world) instanceof TileReactorCell)
{
neighbors.add(position);
}
@ -80,7 +94,7 @@ public class TileReactorDrain extends TileAdvanced implements IFluidHandler
if (tileEntity instanceof TileReactorCell)
{
this.tanks.add(((TileReactorCell) tileEntity).tank);
this.tanks.add(((TileReactorCell) tileEntity).tank());
}
}
@ -179,4 +193,45 @@ public class TileReactorDrain extends TileAdvanced implements IFluidHandler
return tankInfoList.toArray(new FluidTankInfo[0]);
}
@SideOnly(Side.CLIENT)
@Override
public void registerIcons(IIconRegister iconRegister)
{
super.registerIcons(iconRegister);
SpatialBlock.icon().put("ReactorDrain_front", iconRegister.registerIcon("ReactorDrain_front"));
}
@Override
public IIcon getIcon(int side, int metadata)
{
if (side == metadata)
{
return SpatialBlock.icon().get("ReactorDrain_front");
}
return super.getIcon(side, metadata);
}
@Override
public void onPlaced(EntityLivingBase entityLiving, ItemStack itemStack)
{
if (MathHelper.abs((float) entityLiving.posX - x()) < 2.0F && MathHelper.abs((float) entityLiving.posZ - z()) < 2.0F)
{
double d0 = entityLiving.posY + 1.82D - entityLiving.yOffset;
if (d0 - y() > 2.0D)
{
world().setBlockMetadataWithNotify(x(), y(), z(), 1, 3);
return;
}
if (y() - d0 > 0.0D)
{
world().setBlockMetadataWithNotify(x(), y(), z(), 0, 3);
return;
}
}
super.onPlaced(entityLiving, itemStack);
}
}

96
src/main/scala/resonantinduction/atomic/machine/thermometer/ItemBlockThermometer.java
View file

@ -1,96 +0,0 @@
package resonantinduction.atomic.machine.thermometer;
import java.util.List;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.world.World;
import resonant.lib.prefab.item.ItemBlockSaved;
import resonant.lib.utility.LanguageUtility;
import resonant.lib.utility.nbt.NBTUtility;
import universalelectricity.core.transform.vector.Vector3;
/** Handheld thermometer */
public class ItemBlockThermometer extends ItemBlockSaved
{
public static final int ENERGY_CONSUMPTION = 1000;
public ItemBlockThermometer(int id)
{
super(id);
}
@Override
public void addInformation(ItemStack itemStack, EntityPlayer player, List par3List, boolean par4)
{
super.addInformation(itemStack, player, par3List, par4);
Vector3 coord = getSavedCoord(itemStack);
if (coord != null)
{
par3List.add("\uaa74" + LanguageUtility.getLocal("tooltip.trackingTemperature"));
par3List.add("X: " + coord.xi() + ", Y: " + coord.yi() + ", Z: " + coord.zi());
// TODO: Add client side temperature.
}
else
{
par3List.add("\u00a74" + LanguageUtility.getLocal("tooltip.notTrackingTemperature"));
}
}
public void setSavedCoords(ItemStack itemStack, Vector3 position)
{
NBTTagCompound nbt = NBTUtility.getNBTTagCompound(itemStack);
if (position != null)
{
nbt.setCompoundTag("trackCoordinate", position.writeToNBT(new NBTTagCompound()));
}
else
{
nbt.removeTag("trackCoordinate");
}
}
public Vector3 getSavedCoord(ItemStack itemStack)
{
NBTTagCompound nbt = NBTUtility.getNBTTagCompound(itemStack);
if (nbt.hasKey("trackCoordinate"))
{
return new Vector3(nbt.getCompoundTag("trackCoordinate"));
}
return null;
}
@Override
public ItemStack onItemRightClick(ItemStack itemStack, World world, EntityPlayer player)
{
setSavedCoords(itemStack, null);
if (!world.isRemote)
{
player.addChatMessage("Cleared tracking coordinate.");
}
return itemStack;
}
@Override
public boolean onItemUse(ItemStack itemStack, EntityPlayer player, World world, int x, int y, int z, int par7, float par8, float par9, float par10)
{
if (player.isSneaking())
{
if (!world.isRemote)
{
setSavedCoords(itemStack, new Vector3(x, y, z));
player.addChatMessage("Tracking coordinate: " + x + ", " + y + ", " + z);
}
return true;
}
return super.onItemUse(itemStack, player, world, x, y, z, par7, par8, par9, par10);
}
}

72
src/main/scala/resonantinduction/atomic/machine/thermometer/ItemBlockThermometer.scala Normal file
View file

@ -0,0 +1,72 @@
package resonantinduction.atomic.machine.thermometer
import java.util.List
import net.minecraft.block.Block
import net.minecraft.entity.player.EntityPlayer
import net.minecraft.item.ItemStack
import net.minecraft.nbt.NBTTagCompound
import net.minecraft.util.ChatComponentText
import net.minecraft.world.World
import resonant.content.prefab.itemblock.ItemBlockSaved
import resonant.lib.utility.LanguageUtility
import resonant.lib.utility.nbt.NBTUtility
import resonant.lib.wrapper.WrapList._
import universalelectricity.core.transform.vector.Vector3
/** Handheld thermometer */
object ItemBlockThermometer {
final val ENERGY_CONSUMPTION: Int = 1000
}
class ItemBlockThermometer(block: Block) extends ItemBlockSaved(block: Block) {
override def addInformation(itemStack: ItemStack, player: EntityPlayer, par3List: List[_], par4: Boolean) {
super.addInformation(itemStack, player, par3List, par4)
val coord: Vector3 = getSavedCoord(itemStack)
if (coord != null) {
par3List.add("\uaa74" + LanguageUtility.getLocal("tooltip.trackingTemperature"))
par3List.add("X: " + coord.xi + ", Y: " + coord.yi + ", Z: " + coord.zi)
}
else {
par3List.add("\u00a74" + LanguageUtility.getLocal("tooltip.notTrackingTemperature"))
}
}
def setSavedCoords(itemStack: ItemStack, position: Vector3) {
val nbt: NBTTagCompound = NBTUtility.getNBTTagCompound(itemStack)
if (position != null) {
nbt.setTag("trackCoordinate", position.writeNBT(new NBTTagCompound))
}
else {
nbt.removeTag("trackCoordinate")
}
}
def getSavedCoord(itemStack: ItemStack): Vector3 = {
val nbt: NBTTagCompound = NBTUtility.getNBTTagCompound(itemStack)
if (nbt.hasKey("trackCoordinate")) {
return new Vector3(nbt.getCompoundTag("trackCoordinate"))
}
return null
}
override def onItemRightClick(itemStack: ItemStack, world: World, player: EntityPlayer): ItemStack = {
setSavedCoords(itemStack, null)
if (!world.isRemote) {
player.addChatMessage(new ChatComponentText("Cleared tracking coordinate."))
}
return itemStack
}
override def onItemUse(itemStack: ItemStack, player: EntityPlayer, world: World, x: Int, y: Int, z: Int, par7: Int, par8: Float, par9: Float, par10: Float): Boolean = {
if (player.isSneaking) {
if (!world.isRemote) {
setSavedCoords(itemStack, new Vector3(x, y, z))
player.addChatMessage(new ChatComponentText("Tracking coordinate: " + x + ", " + y + ", " + z))
}
return true
}
return super.onItemUse(itemStack, player, world, x, y, z, par7, par8, par9, par10)
}
}

133
src/main/scala/resonantinduction/atomic/machine/thermometer/TileThermometer.java
View file

@ -6,34 +6,33 @@ import li.cil.oc.api.network.Arguments;
import li.cil.oc.api.network.Callback;
import li.cil.oc.api.network.Context;
import li.cil.oc.api.network.SimpleComponent;
import net.minecraft.block.Block;
import net.minecraft.block.material.Material;
import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.network.packet.Packet;
import net.minecraft.util.IIcon;
import net.minecraft.world.IBlockAccess;
import resonant.lib.content.module.TileBase;
import resonant.lib.network.PacketHandler;
import resonant.content.prefab.itemblock.ItemBlockSaved;
import resonant.content.prefab.java.TileAdvanced;
import resonant.engine.grid.thermal.ThermalGrid;
import resonant.lib.network.Synced;
import resonant.lib.prefab.item.ItemBlockSaved;
import resonant.lib.thermal.ThermalGrid;
import resonant.lib.network.discriminator.PacketAnnotation;
import resonant.lib.network.discriminator.PacketTile;
import resonant.lib.utility.inventory.InventoryUtility;
import resonantinduction.core.Reference;
import resonantinduction.core.ResonantInduction;
import resonantinduction.electrical.em.laser.TileBase;
import universalelectricity.core.transform.vector.Vector3;
import universalelectricity.api.vector.VectorWorld;
import cpw.mods.fml.common.Optional;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
import dan200.computercraft.api.lua.ILuaContext;
import dan200.computercraft.api.peripheral.IComputerAccess;
import dan200.computercraft.api.peripheral.IPeripheral;
import universalelectricity.core.transform.vector.VectorWorld;
/** Thermometer TileEntity */
@Optional.Interface(iface = "li.cil.oc.api.network.SimpleComponent", modid = "OpenComputers")
public class TileThermometer extends TileBase implements IPeripheral, SimpleComponent
public class TileThermometer extends TileAdvanced implements SimpleComponent
{
public static final int MAX_THRESHOLD = 5000;
private static IIcon iconSide;
@ -56,10 +55,10 @@ public class TileThermometer extends TileBase implements IPeripheral, SimpleComp
public TileThermometer()
{
super(Material.piston);
canProvidePower = true;
normalRender = false;
forceStandardRender = true;
itemBlock = ItemBlockThermometer.class;
canProvidePower(true);
normalRender(false);
forceStandardRender(true);
itemBlock(ItemBlockThermometer.class);
}
@Override
@ -73,11 +72,11 @@ public class TileThermometer extends TileBase implements IPeripheral, SimpleComp
public void registerIcons(IIconRegister iconRegister)
{
super.registerIcons(iconRegister);
iconSide = iconRegister.registerIcon(Reference.PREFIX + "machine");
iconSide = iconRegister.registerIcon(Reference.prefix() + "machine");
}
@Override
protected boolean use(EntityPlayer player, int side, Vector3 hit)
public boolean use(EntityPlayer player, int side, Vector3 hit)
{
if (player.isSneaking())
{
@ -92,7 +91,7 @@ public class TileThermometer extends TileBase implements IPeripheral, SimpleComp
}
@Override
protected boolean configure(EntityPlayer player, int side, Vector3 hit)
public boolean configure(EntityPlayer player, int side, Vector3 hit)
{
if (player.isSneaking())
{
@ -118,14 +117,14 @@ public class TileThermometer extends TileBase implements IPeripheral, SimpleComp
}
@Override
public void onRemove(int par5, int par6)
public void onRemove(Block block, int par6)
{
ItemStack stack = ItemBlockSaved.getItemStackWithNBT(getBlockType(), world(), x(), y(), z());
InventoryUtility.dropItemStack(world(), center(), stack);
}
@Override
public void updateEntity()
public void update()
{
super.updateEntity();
@ -133,7 +132,7 @@ public class TileThermometer extends TileBase implements IPeripheral, SimpleComp
if (!worldObj.isRemote)
{
// Every ten ticks.
if (ticks % 10 == 0)
if (ticks() % 10 == 0)
{
// Grab temperature from target or from ourselves.
if (trackCoordinate != null)
@ -151,16 +150,16 @@ public class TileThermometer extends TileBase implements IPeripheral, SimpleComp
previousDetectedTemperature = detectedTemperature;
isProvidingPower = isOverThreshold();
notifyChange();
PacketHandler.sendPacketToClients(getDescriptionPacket(), this.worldObj, new Vector3(this), 25);
sendPacket(getDescPacket());
}
}
}
}
@Override
public Packet getDescriptionPacket()
public PacketAnnotation getDescPacket()
{
return ResonantInduction.PACKET_ANNOTATION.getPacket(this);
return new PacketAnnotation(this);
}
public void setTrack(Vector3 track)
@ -194,7 +193,7 @@ public class TileThermometer extends TileBase implements IPeripheral, SimpleComp
if (trackCoordinate != null)
{
nbt.setCompoundTag("trackCoordinate", this.trackCoordinate.writeToNBT(new NBTTagCompound()));
nbt.setTag("trackCoordinate", this.trackCoordinate.writeNBT(new NBTTagCompound()));
}
}
@ -220,87 +219,6 @@ public class TileThermometer extends TileBase implements IPeripheral, SimpleComp
return detectedTemperature >= getThershold();
}
/** ComputerCraft */
@Override
public String getType()
{
return "AS Thermometer";
}
@Override
public String[] getMethodNames()
{
return new String[]
{ "getTemperature", "getWarningTemperature", "setWarningTemperature", "isAboveWarningTemperature" };
}
@Override
public Object[] callMethod(IComputerAccess computer, ILuaContext context, int method, Object[] arguments) throws Exception
{
final int getTemperature = 0;
final int getWarningTemperature = 1;
final int setWarningTemperature = 2;
final int isAboveWarningTemperature = 3;
switch (method)
{
case getTemperature:
return new Object[]
{ this.detectedTemperature };
case getWarningTemperature:
return new Object[]
{ this.getThershold() };
case isAboveWarningTemperature:
return new Object[]
{ this.isOverThreshold() };
case setWarningTemperature:
{
if (arguments.length <= 0)
{
throw new IllegalArgumentException("Not enough Arguments. Must provide one argument");
}
if (arguments.length >= 2)
{
throw new IllegalArgumentException("Too many Arguments. Must provide one argument");
}
if (!(arguments[0] instanceof Number))
{
throw new IllegalArgumentException("Invalid Argument. Must provide a number");
}
synchronized (this)
{
this.setThreshold((Integer) arguments[0]);
}
return new Object[]
{ this.threshold == (Integer) arguments[0] };
}
default:
return null;
}
}
@Override
public void attach(IComputerAccess computer)
{
}
@Override
public void detach(IComputerAccess computer)
{
}
@Override
public boolean equals(IPeripheral other)
{
return equals(this);
}
@Override
public String getComponentName()
{
return "AS_Thermometer";
}
@Callback
@Optional.Method(modid = "OpenComputers")
public Object[] getTemperature(Context context, Arguments args)
@ -348,4 +266,9 @@ public class TileThermometer extends TileBase implements IPeripheral, SimpleComp
return new Object[]
{ this.threshold == args.checkInteger(0) };
}
@Override
public String getComponentName() {
return "AS Thermometer";
}
}

14
src/main/scala/resonantinduction/mechanical/Mechanical.java
View file

@ -8,6 +8,7 @@ import resonant.engine.content.debug.TileCreativeBuilder;
import resonant.lib.network.discriminator.PacketAnnotationManager;
import resonantinduction.core.ResonantTab;
import resonantinduction.mechanical.energy.grid.MechanicalNode;
import resonantinduction.mechanical.energy.turbine.*;
import resonantinduction.mechanical.fluid.pipe.EnumPipeMaterial;
import resonantinduction.mechanical.fluid.pipe.ItemPipe;
import resonantinduction.mechanical.fluid.transport.TilePump;
@ -29,12 +30,6 @@ import resonantinduction.core.Reference;
import resonantinduction.core.ResonantInduction;
import resonantinduction.core.Settings;
import resonantinduction.core.interfaces.IMechanicalNode;
import resonantinduction.mechanical.energy.turbine.BlockWaterTurbine;
import resonantinduction.mechanical.energy.turbine.BlockWindTurbine;
import resonantinduction.mechanical.energy.turbine.SchematicWaterTurbine;
import resonantinduction.mechanical.energy.turbine.SchematicWindTurbine;
import resonantinduction.mechanical.energy.turbine.TileWaterTurbine;
import resonantinduction.mechanical.energy.turbine.TileWindTurbine;
import resonantinduction.mechanical.process.mixer.TileMixer;
import cpw.mods.fml.common.Mod;
import cpw.mods.fml.common.Mod.EventHandler;
@ -76,6 +71,7 @@ public class Mechanical
public static Item itemGearShaft;
public static Block blockWindTurbine;
public static Block blockWaterTurbine;
public static Block blockElectricTurbine;
// Transport
public static Block blockConveyorBelt;
@ -125,6 +121,9 @@ public class Mechanical
blockTileBreaker = contentRegistry.newBlock(TileBreaker.class);
blockTilePlacer = contentRegistry.newBlock(TilePlacer.class);
//TODO disable if electrical module is not enabled
blockElectricTurbine = contentRegistry.newBlock(TileElectricTurbine.class);
proxy.preInit();
ResonantTab.itemStack(new ItemStack(blockGrinderWheel));
@ -161,8 +160,9 @@ public class Mechanical
GameRegistry.addRecipe(new ShapedOreRecipe(new ItemStack(blockWaterTurbine, 1, 0), "SWS", "WGW", "SWS", 'G', itemGear, 'W', "plankWood", 'S', Items.stick));
GameRegistry.addRecipe(new ShapedOreRecipe(new ItemStack(blockWaterTurbine, 1, 1), "SWS", "WGW", "SWS", 'G', new ItemStack(blockWaterTurbine, 1, 0), 'W', Blocks.stone, 'S', Items.stick));
GameRegistry.addRecipe(new ShapedOreRecipe(new ItemStack(blockWaterTurbine, 1, 2), "SWS", "WGW", "SWS", 'G', new ItemStack(blockWaterTurbine, 1, 1), 'W', UniversalRecipe.PRIMARY_METAL.get(), 'S', Items.stick));
GameRegistry.addRecipe(new ShapedOreRecipe(blockElectricTurbine, " B ", "BMB", " B ", 'B', UniversalRecipe.SECONDARY_PLATE.get(), 'M', UniversalRecipe.MOTOR.get()));
GameRegistry.addRecipe(new ShapedOreRecipe(blockPump, "PPP", "GGG", "PPP", 'P', itemPipe, 'G', new ItemStack(itemGear, 1, 2)));
GameRegistry.addRecipe(new ShapedOreRecipe(blockPump, "PPP", "GGG", "PPP", 'P', itemPipe, 'G', new ItemStack(itemGear, 1, 2)));
GameRegistry.addRecipe(new ShapedOreRecipe(new ItemStack(itemPipe, 3, EnumPipeMaterial.CERAMIC.ordinal()), "BBB", " ", "BBB", 'B', Items.brick));
GameRegistry.addRecipe(new ShapedOreRecipe(new ItemStack(itemPipe, 3, EnumPipeMaterial.BRONZE.ordinal()), "BBB", " ", "BBB", 'B', "ingotBronze"));

2
src/main/scala/resonantinduction/atomic/machine/extractor/turbine/BlockElectricTurbine.java → src/main/scala/resonantinduction/mechanical/energy/turbine/BlockElectricTurbine.java
View file

@ -1,4 +1,4 @@
package resonantinduction.atomic.machine.extractor.turbine;
package resonantinduction.mechanical.energy.turbine;
import net.minecraft.block.material.Material;
import net.minecraft.tileentity.TileEntity;

2
src/main/scala/resonantinduction/atomic/machine/extractor/turbine/RenderElectricTurbine.java → src/main/scala/resonantinduction/mechanical/energy/turbine/RenderElectricTurbine.java
View file

@ -1,4 +1,4 @@
package resonantinduction.atomic.machine.extractor.turbine;
package resonantinduction.mechanical.energy.turbine;
import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer;
import net.minecraft.tileentity.TileEntity;

5
src/main/scala/resonantinduction/atomic/machine/extractor/turbine/TileElectricTurbine.java → src/main/scala/resonantinduction/mechanical/energy/turbine/TileElectricTurbine.java
View file

@ -1,12 +1,11 @@
package resonantinduction.atomic.machine.extractor.turbine;
package resonantinduction.mechanical.energy.turbine;
import net.minecraftforge.common.util.ForgeDirection;
import net.minecraftforge.fluids.Fluid;
import resonant.api.IBoilHandler;
import resonant.lib.prefab.turbine.TileTurbine;
import atomic.Atomic;
import resonantinduction.core.Reference;
import resonantinduction.core.Settings;
import resonantinduction.mechanical.energy.turbine.TileTurbine;
public class TileElectricTurbine extends TileTurbine implements IBoilHandler
{

12
src/main/scala/resonantinduction/mechanical/energy/turbine/TileTurbine.java
View file

@ -3,21 +3,21 @@ package resonantinduction.mechanical.energy.turbine;
import java.util.HashSet;
import java.util.Set;
import resonant.lib.multiblock.reference.IMultiBlockStructure;
import resonant.lib.network.handle.IPacketIDReceiver;
import resonantinduction.mechanical.energy.grid.TileMechanical;
import net.minecraft.block.material.Material;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.util.AxisAlignedBB;
import net.minecraft.world.World;
import net.minecraftforge.common.util.ForgeDirection;
import resonant.api.grid.INodeProvider;
import resonant.lib.multiblock.IMultiBlockStructure;
import resonant.lib.network.IPacketReceiverWithID;
import universalelectricity.api.core.grid.INodeProvider;
import universalelectricity.core.transform.vector.Vector3;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
/** Reduced version of the main turbine class */
public class TileTurbine extends TileMechanical implements IMultiBlockStructure<TileTurbine>, INodeProvider, IPacketReceiverWithID
public class TileTurbine extends TileMechanical implements IMultiBlockStructure<TileTurbine>, INodeProvider, IPacketIDReceiver
{
/** Tier of the tile */
public int tier = 0;
@ -43,9 +43,9 @@ public class TileTurbine extends TileMechanical implements IMultiBlockStructure<
}
@Override
public void updateEntity()
public void update()
{
super.updateEntity();
super.update();
getMultiBlock().update();
if (getMultiBlock().isPrimary())