Merge pull request #2 from Universal-Electricity/development

Massive refactoring, merged Atomic Science into Resonant Induction as At...
This commit is contained in:
Maxwolf Goodliffe 2014-05-14 18:30:32 -07:00
commit 3da711f20e
166 changed files with 9785 additions and 292 deletions

2
.gitignore vendored
View file

@ -44,3 +44,5 @@ Thumbs.db
build/
eclipse/
.project
output/
.cache

File diff suppressed because it is too large Load diff

View file

@ -0,0 +1,743 @@
package resonantinduction.atomic;
import ic2.api.item.Items;
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.EnumArmorMaterial;
import net.minecraft.item.Item;
import net.minecraft.item.ItemBucket;
import net.minecraft.item.ItemStack;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.EnumMovingObjectType;
import net.minecraft.world.World;
import net.minecraftforge.client.event.TextureStitchEvent;
import net.minecraftforge.common.Configuration;
import net.minecraftforge.common.EnumHelper;
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.Event.Result;
import net.minecraftforge.event.ForgeSubscribe;
import net.minecraftforge.event.entity.player.FillBucketEvent;
import net.minecraftforge.event.world.WorldEvent.Save;
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.content.ContentRegistry;
import resonant.lib.flag.FlagRegistry;
import resonant.lib.modproxy.ProxyHandler;
import resonant.lib.network.PacketAnnotation;
import resonant.lib.network.PacketHandler;
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 resonant.lib.thermal.EventThermal.EventThermalUpdate;
import resonant.lib.utility.nbt.NBTUtility;
import resonantinduction.atomic.base.ItemCell;
import resonantinduction.atomic.fission.BlockUraniumOre;
import resonantinduction.atomic.fission.ItemBreederFuel;
import resonantinduction.atomic.fission.ItemFissileFuel;
import resonantinduction.atomic.fission.ItemRadioactive;
import resonantinduction.atomic.fission.ItemUranium;
import resonantinduction.atomic.fission.reactor.BlockToxicWaste;
import resonantinduction.atomic.fission.reactor.TileControlRod;
import resonantinduction.atomic.fission.reactor.TileReactorCell;
import resonantinduction.atomic.fusion.BlockPlasmaHeater;
import resonantinduction.atomic.fusion.TileElectromagnet;
import resonantinduction.atomic.fusion.TilePlasma;
import resonantinduction.atomic.fusion.TilePlasmaHeater;
import resonantinduction.atomic.particle.accelerator.BlockAccelerator;
import resonantinduction.atomic.particle.accelerator.EntityParticle;
import resonantinduction.atomic.particle.accelerator.ItemDarkMatter;
import resonantinduction.atomic.particle.accelerator.TileAccelerator;
import resonantinduction.atomic.particle.fulmination.FulminationHandler;
import resonantinduction.atomic.particle.fulmination.ItemAntimatter;
import resonantinduction.atomic.particle.fulmination.TileFulmination;
import resonantinduction.atomic.particle.quantum.TileQuantumAssembler;
import resonantinduction.atomic.process.BlockChemicalExtractor;
import resonantinduction.atomic.process.ItemHazmat;
import resonantinduction.atomic.process.TileChemicalExtractor;
import resonantinduction.atomic.process.fission.BlockCentrifuge;
import resonantinduction.atomic.process.fission.BlockNuclearBoiler;
import resonantinduction.atomic.process.fission.TileCentrifuge;
import resonantinduction.atomic.process.fission.TileNuclearBoiler;
import resonantinduction.atomic.process.sensor.TileSiren;
import resonantinduction.atomic.process.sensor.TileThermometer;
import resonantinduction.atomic.process.turbine.BlockElectricTurbine;
import resonantinduction.atomic.process.turbine.TileElectricTurbine;
import resonantinduction.atomic.process.turbine.TileFunnel;
import resonantinduction.atomic.schematic.SchematicAccelerator;
import resonantinduction.atomic.schematic.SchematicBreedingReactor;
import resonantinduction.atomic.schematic.SchematicFissionReactor;
import resonantinduction.atomic.schematic.SchematicFusionReactor;
import resonantinduction.core.Reference;
import resonantinduction.core.ResonantInduction;
import resonantinduction.core.Settings;
import resonantinduction.core.TabRI;
import universalelectricity.api.vector.Vector3;
import universalelectricity.api.vector.VectorWorld;
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.NetworkMod;
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)
@NetworkMod(channels =
{ Reference.CHANNEL }, clientSideRequired = true, serverSideRequired = false, packetHandler = PacketHandler.class)
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 EnumArmorMaterial hazmatArmorMaterial = EnumHelper.addArmorMaterial("HAZMAT", 0, new int[]
{ 0, 0, 0, 0 }, 0);
public static final String BAN_ANTIMATTER_POWER = FlagRegistry.registerFlag("ban_antimatter_power");
public static final String NAME = Reference.NAME + " Atomic";
public static final ContentRegistry contentRegistry = new ContentRegistry(Settings.CONFIGURATION, Settings.idManager, ID).setPrefix(Reference.PREFIX).setTab(TabRI.DEFAULT);
private static final String[] SUPPORTED_LANGUAGES = new String[]
{ "en_US", "pl_PL", "de_DE" };
@Instance(ID)
public static Atomic INSTANCE;
@SidedProxy(clientSide = "resonantinduction.atomic.ClientProxy", serverSide = "resonantinduction.atomic.CommonProxy")
public static CommonProxy proxy;
public ProxyHandler modproxies;
@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;
/** Cells */
public static Item itemCell, itemFissileFuel, itemBreedingRod, itemDarkMatter, itemAntimatter, itemDeuteriumCell, itemTritiumCell, itemWaterCell;
public static Item itemBucketToxic;
/** Uranium Related Items */
public static Block blockUraniumOre;
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)
{
modproxies = new ProxyHandler();
INSTANCE = this;
MinecraftForge.EVENT_BUS.register(this);
NetworkRegistry.instance().registerGuiHandler(this, proxy);
PacketAnnotation.register(TileElectricTurbine.class);
PacketAnnotation.register(TileReactorCell.class);
PacketAnnotation.register(TileThermometer.class);
BlockCreativeBuilder.register(new SchematicAccelerator());
BlockCreativeBuilder.register(new SchematicBreedingReactor());
BlockCreativeBuilder.register(new SchematicFissionReactor());
BlockCreativeBuilder.register(new SchematicFusionReactor());
Settings.CONFIGURATION.load();
/** Register Packets */
PacketAnnotation.register(TileAccelerator.class);
PacketAnnotation.register(TileChemicalExtractor.class);
PacketAnnotation.register(TileNuclearBoiler.class);
PacketAnnotation.register(TileElectricTurbine.class);
/** 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 = contentRegistry.createBlock(BlockRadioactive.class).setUnlocalizedName(Reference.PREFIX + "radioactive").setTextureName(Reference.PREFIX + "radioactive").setCreativeTab(TabRI.DEFAULT);
blockUraniumOre = contentRegistry.createBlock(BlockUraniumOre.class);
blockElectricTurbine = contentRegistry.createTile(BlockElectricTurbine.class, TileElectricTurbine.class);
blockCentrifuge = contentRegistry.createTile(BlockCentrifuge.class, TileCentrifuge.class);
blockReactorCell = contentRegistry.newBlock(TileReactorCell.class);
blockNuclearBoiler = contentRegistry.createTile(BlockNuclearBoiler.class, TileNuclearBoiler.class);
blockChemicalExtractor = contentRegistry.createTile(BlockChemicalExtractor.class, TileChemicalExtractor.class);
blockFusionCore = contentRegistry.createTile(BlockPlasmaHeater.class, 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.createTile(BlockAccelerator.class, TileAccelerator.class);
blockFulmination = contentRegistry.newBlock(TileFulmination.class);
blockQuantumAssembler = contentRegistry.newBlock(TileQuantumAssembler.class);
blockToxicWaste = contentRegistry.createBlock(BlockToxicWaste.class).setCreativeTab(null);
/** Items */
itemHazmatTop = new ItemHazmat(Settings.CONFIGURATION.getItem("HazmatTop", Settings.getNextItemID()).getInt(), hazmatArmorMaterial, proxy.getArmorIndex("hazmat"), 0).setUnlocalizedName(Reference.PREFIX + "hazmatMask");
itemHazmatBody = new ItemHazmat(Settings.CONFIGURATION.getItem("HazmatBody", Settings.getNextItemID()).getInt(), hazmatArmorMaterial, proxy.getArmorIndex("hazmat"), 1).setUnlocalizedName(Reference.PREFIX + "hazmatBody");
itemHazmatLeggings = new ItemHazmat(Settings.CONFIGURATION.getItem("HazmatBottom", Settings.getNextItemID()).getInt(), hazmatArmorMaterial, proxy.getArmorIndex("hazmat"), 2).setUnlocalizedName(Reference.PREFIX + "hazmatLeggings");
itemHazmatBoots = new ItemHazmat(Settings.CONFIGURATION.getItem("HazmatBoots", Settings.getNextItemID()).getInt(), hazmatArmorMaterial, proxy.getArmorIndex("hazmat"), 3).setUnlocalizedName(Reference.PREFIX + "hazmatBoots");
itemCell = contentRegistry.createItem("cellEmpty", Item.class);
itemFissileFuel = contentRegistry.createItem("rodFissileFuel", ItemFissileFuel.class);
itemDeuteriumCell = contentRegistry.createItem("cellDeuterium", ItemCell.class);
itemTritiumCell = contentRegistry.createItem("cellTritium", ItemCell.class);
itemWaterCell = contentRegistry.createItem("cellWater", ItemCell.class);
itemDarkMatter = contentRegistry.createItem("darkMatter", ItemDarkMatter.class);
itemAntimatter = contentRegistry.createItem("antimatter", ItemAntimatter.class);
itemBreedingRod = contentRegistry.createItem("rodBreederFuel", ItemBreederFuel.class);
itemYellowCake = contentRegistry.createItem("yellowcake", ItemRadioactive.class);
itemUranium = contentRegistry.createItem(ItemUranium.class);
/** Fluid Item Initialization */
FLUID_PLASMA.setBlockID(blockPlasma);
int bucketID = Settings.getNextItemID();
itemBucketToxic = (new ItemBucket(Settings.CONFIGURATION.getItem("Toxic Waste Bucket", bucketID).getInt(bucketID), blockToxicWaste.blockID)).setCreativeTab(TabRI.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.CONFIGURATION.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.CONFIGURATION);
OreGenerator.addOre(uraniumOreGeneration);
ResonantInduction.LOGGER.fine("Added Atomic Science uranium to ore generator.");
}
Settings.CONFIGURATION.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;
}
}
}
}
}
});
proxy.preInit();
Settings.CONFIGURATION.save();
TabRI.ITEMSTACK = new ItemStack(blockReactorCell);
}
@EventHandler
public void init(FMLInitializationEvent evt)
{
Settings.setModMetadata(metadata, ID, NAME, ResonantInduction.ID);
proxy.init();
modproxies.init();
}
@EventHandler
public void postInit(FMLPostInitializationEvent event)
{
/** IC2 Recipes */
if (Loader.isModLoaded("IC2") && Settings.allowAlternateRecipes)
{
OreDictionary.registerOre("cellEmpty", Items.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, Items.getItem("reactorUraniumSimple")));
GameRegistry.addRecipe(new ShapelessOreRecipe(Items.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(Settings.allowAlternateRecipes) }));
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(Settings.allowAlternateRecipes), 'S', UniversalRecipe.PRIMARY_PLATE.get(Settings.allowAlternateRecipes) }));
// Fulmination Generator
GameRegistry.addRecipe(new ShapedOreRecipe(blockFulmination, new Object[]
{ "OSO", "SCS", "OSO", 'O', Block.obsidian, 'C', UniversalRecipe.CIRCUIT_T2.get(Settings.allowAlternateRecipes), 'S', UniversalRecipe.PRIMARY_PLATE.get(Settings.allowAlternateRecipes) }));
// Particle Accelerator
GameRegistry.addRecipe(new ShapedOreRecipe(blockAccelerator, new Object[]
{ "SCS", "CMC", "SCS", 'M', UniversalRecipe.MOTOR.get(Settings.allowAlternateRecipes), 'C', UniversalRecipe.CIRCUIT_T3.get(Settings.allowAlternateRecipes), 'S', UniversalRecipe.PRIMARY_PLATE.get(Settings.allowAlternateRecipes) }));
// Centrifuge
GameRegistry.addRecipe(new ShapedOreRecipe(blockCentrifuge, new Object[]
{ "BSB", "MCM", "BSB", 'C', UniversalRecipe.CIRCUIT_T2.get(Settings.allowAlternateRecipes), 'S', UniversalRecipe.PRIMARY_PLATE.get(Settings.allowAlternateRecipes), 'B', UniversalRecipe.SECONDARY_METAL.get(Settings.allowAlternateRecipes), 'M',
UniversalRecipe.MOTOR.get(Settings.allowAlternateRecipes) }));
// Nuclear Boiler
GameRegistry.addRecipe(new ShapedOreRecipe(blockNuclearBoiler, new Object[]
{ "S S", "FBF", "SMS", 'F', Block.furnaceIdle, 'S', UniversalRecipe.PRIMARY_PLATE.get(Settings.allowAlternateRecipes), 'B', Item.bucketEmpty, 'M', UniversalRecipe.MOTOR.get(Settings.allowAlternateRecipes) }));
// Chemical Extractor
GameRegistry.addRecipe(new ShapedOreRecipe(blockChemicalExtractor, new Object[]
{ "BSB", "MCM", "BSB", 'C', UniversalRecipe.CIRCUIT_T3.get(Settings.allowAlternateRecipes), 'S', UniversalRecipe.PRIMARY_PLATE.get(Settings.allowAlternateRecipes), 'B', UniversalRecipe.SECONDARY_METAL.get(Settings.allowAlternateRecipes), 'M',
UniversalRecipe.MOTOR.get(Settings.allowAlternateRecipes) }));
// Siren
GameRegistry.addRecipe(new ShapedOreRecipe(new ItemStack(blockSiren, 2), new Object[]
{ "NPN", 'N', Block.music, 'P', UniversalRecipe.SECONDARY_PLATE.get(Settings.allowAlternateRecipes) }));
// Fission Reactor
GameRegistry
.addRecipe(new ShapedOreRecipe(blockReactorCell, new Object[]
{ "SCS", "MEM", "SCS", 'E', "cellEmpty", 'C', UniversalRecipe.CIRCUIT_T2.get(Settings.allowAlternateRecipes), 'S', UniversalRecipe.PRIMARY_PLATE.get(Settings.allowAlternateRecipes), 'M',
UniversalRecipe.MOTOR.get(Settings.allowAlternateRecipes) }));
// Fusion Reactor
GameRegistry.addRecipe(new ShapedOreRecipe(blockFusionCore, new Object[]
{ "CPC", "PFP", "CPC", 'P', UniversalRecipe.PRIMARY_PLATE.get(Settings.allowAlternateRecipes), 'F', blockReactorCell, 'C', UniversalRecipe.CIRCUIT_T3.get(Settings.allowAlternateRecipes) }));
// Turbine
GameRegistry.addRecipe(new ShapedOreRecipe(blockElectricTurbine, new Object[]
{ " B ", "BMB", " B ", 'B', UniversalRecipe.SECONDARY_PLATE.get(Settings.allowAlternateRecipes), 'M', UniversalRecipe.MOTOR.get(Settings.allowAlternateRecipes) }));
// Empty Cell
GameRegistry.addRecipe(new ShapedOreRecipe(new ItemStack(itemCell, 16), new Object[]
{ " T ", "TGT", " T ", 'T', "ingotTin", 'G', Block.glass }));
// Water Cell
GameRegistry.addRecipe(new ShapelessOreRecipe(new ItemStack(itemWaterCell), new Object[]
{ "cellEmpty", Item.bucketWater }));
// Thermometer
GameRegistry.addRecipe(new ShapedOreRecipe(blockThermometer, new Object[]
{ "SSS", "GCG", "GSG", 'S', UniversalRecipe.PRIMARY_METAL.get(Settings.allowAlternateRecipes), 'G', Block.glass, 'C', UniversalRecipe.CIRCUIT_T1.get(Settings.allowAlternateRecipes) }));
// Control Rod
GameRegistry.addRecipe(new ShapedOreRecipe(blockControlRod, new Object[]
{ "I", "I", "I", 'I', Item.ingotIron }));
// 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(Settings.allowAlternateRecipes), 'M', UniversalRecipe.MOTOR.get(Settings.allowAlternateRecipes) }));
// Electromagnet Glass
GameRegistry.addRecipe(new ShapelessOreRecipe(new ItemStack(blockElectromagnet, 1, 1), new Object[]
{ blockElectromagnet, Block.glass }));
// Hazmat Suit
GameRegistry.addRecipe(new ShapedOreRecipe(itemHazmatTop, new Object[]
{ "SSS", "BAB", "SCS", 'A', Item.helmetLeather, 'C', UniversalRecipe.CIRCUIT_T1.get(Settings.allowAlternateRecipes), 'S', Block.cloth }));
GameRegistry.addRecipe(new ShapedOreRecipe(itemHazmatBody, new Object[]
{ "SSS", "BAB", "SCS", 'A', Item.plateLeather, 'C', UniversalRecipe.CIRCUIT_T1.get(Settings.allowAlternateRecipes), 'S', Block.cloth }));
GameRegistry.addRecipe(new ShapedOreRecipe(itemHazmatLeggings, new Object[]
{ "SSS", "BAB", "SCS", 'A', Item.legsLeather, 'C', UniversalRecipe.CIRCUIT_T1.get(Settings.allowAlternateRecipes), 'S', Block.cloth }));
GameRegistry.addRecipe(new ShapedOreRecipe(itemHazmatBoots, new Object[]
{ "SSS", "BAB", "SCS", 'A', Item.bootsLeather, 'C', UniversalRecipe.CIRCUIT_T1.get(Settings.allowAlternateRecipes), 'S', Block.cloth }));
EntityRegistry.registerGlobalEntityID(EntityParticle.class, "ASParticle", EntityRegistry.findGlobalUniqueEntityId());
EntityRegistry.registerModEntity(EntityParticle.class, "ASParticle", ENTITY_ID_PREFIX, this, 80, 3, true);
Atomic.proxy.init();
Settings.CONFIGURATION.load();
if (Loader.isModLoaded("IC2") && Settings.allowAlternateRecipes)
{
if (Settings.allowIC2UraniumCompression)
{
try
{
if (Recipes.compressor != null)
{
Map<IRecipeInput, RecipeOutput> compressorRecipes = Recipes.compressor.getRecipes();
Iterator<Entry<IRecipeInput, RecipeOutput>> it = compressorRecipes.entrySet().iterator();
int i = 0;
while (it.hasNext())
{
Map.Entry<IRecipeInput, RecipeOutput> entry = it.next();
for (ItemStack checkStack : entry.getKey().getInputs())
{
if (isItemStackUraniumOre(checkStack))
{
i++;
it.remove();
}
}
}
ResonantInduction.LOGGER.fine("Removed " + i + " IC2 uranium compression recipe, use centrifuge instead.");
}
}
catch (Exception e)
{
ResonantInduction.LOGGER.fine("Failed to remove IC2 compressor recipes.");
e.printStackTrace();
}
}
}
/** Atomic Assembler Recipes */
if (Settings.quantumAssemblerGenerateMode > 0)
{
for (Item item : Item.itemsList)
{
if (item != null)
{
if (item.itemID > 256 || Settings.quantumAssemblerGenerateMode == 2)
{
ItemStack itemStack = new ItemStack(item);
if (itemStack != null)
{
QuantumAssemblerRecipes.addRecipe(itemStack);
}
}
}
}
if (Settings.quantumAssemblerGenerateMode == 2)
{
for (Block block : Block.blocksList)
{
if (block != null)
{
ItemStack itemStack = new ItemStack(block);
if (itemStack != null)
{
QuantumAssemblerRecipes.addRecipe(itemStack);
}
}
}
}
for (String oreName : OreDictionary.getOreNames())
{
if (oreName.startsWith("ingot"))
{
for (ItemStack itemStack : OreDictionary.getOres(oreName))
{
if (itemStack != null)
{
QuantumAssemblerRecipes.addRecipe(itemStack);
}
}
}
}
}
Settings.CONFIGURATION.save();
}
@ForgeSubscribe
public void thermalEventHandler(EventThermalUpdate evt)
{
VectorWorld pos = evt.position;
Block block = Block.blocksList[pos.getBlockID()];
if (block == blockElectromagnet)
{
evt.heatLoss = evt.deltaTemperature * 0.6f;
}
}
@ForgeSubscribe
public void plasmaEvent(SpawnPlasmaEvent evt)
{
World world = evt.world;
Vector3 position = new Vector3(evt.x, evt.y, evt.z);
int blockID = position.getBlockID(world);
Block block = Block.blocksList[blockID];
if (block != null)
{
if (block.blockID == Block.bedrock.blockID || block.blockID == Block.blockIron.blockID)
{
return;
}
TileEntity tile = position.getTileEntity(world);
if (tile instanceof TilePlasma)
{
((TilePlasma) tile).setTemperature(evt.temperature);
return;
}
if (tile instanceof IElectromagnet)
{
return;
}
}
position.setBlock(world, blockPlasma.blockID);
TileEntity tile = position.getTileEntity(world);
if (tile instanceof TilePlasma)
{
((TilePlasma) tile).setTemperature(evt.temperature);
}
}
@ForgeSubscribe
@SideOnly(Side.CLIENT)
public void preTextureHook(TextureStitchEvent.Pre event)
{
if (event.map.textureType == 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);
}
}
@ForgeSubscribe
@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));
}
@ForgeSubscribe
public void worldSave(Save evt)
{
if (!evt.world.isRemote)
{
if (FlagRegistry.getModFlag(FlagRegistry.DEFAULT_NAME) != null)
{
NBTUtility.saveData(FlagRegistry.DEFAULT_NAME, FlagRegistry.getModFlag(FlagRegistry.DEFAULT_NAME).getNBT());
}
}
}
@ForgeSubscribe
public void fillBucketEvent(FillBucketEvent evt)
{
if (!evt.world.isRemote && evt.target != null && evt.target.typeOfHit == EnumMovingObjectType.TILE)
{
Vector3 blockPos = new Vector3(evt.target);
int blockID = blockPos.getBlockID(evt.world);
if (blockID == blockToxicWaste.blockID)
{
blockPos.setBlock(evt.world, 0);
evt.result = new ItemStack(itemBucketToxic);
evt.setResult(Result.ALLOW);
}
}
}
/** Recipes */
public static enum RecipeType
{
CHEMICAL_EXTRACTOR;
}
}

View file

@ -0,0 +1,107 @@
package resonantinduction.atomic;
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 resonantinduction.atomic.fission.reactor.GuiReactorCell;
import resonantinduction.atomic.fission.reactor.RenderReactorCell;
import resonantinduction.atomic.fission.reactor.TileReactorCell;
import resonantinduction.atomic.fusion.RenderPlasmaHeater;
import resonantinduction.atomic.fusion.TilePlasmaHeater;
import resonantinduction.atomic.particle.accelerator.EntityParticle;
import resonantinduction.atomic.particle.accelerator.GuiAccelerator;
import resonantinduction.atomic.particle.accelerator.RenderParticle;
import resonantinduction.atomic.particle.accelerator.TileAccelerator;
import resonantinduction.atomic.particle.quantum.GuiQuantumAssembler;
import resonantinduction.atomic.particle.quantum.TileQuantumAssembler;
import resonantinduction.atomic.process.RenderChemicalExtractor;
import resonantinduction.atomic.process.TileChemicalExtractor;
import resonantinduction.atomic.process.fission.GuiCentrifuge;
import resonantinduction.atomic.process.fission.GuiChemicalExtractor;
import resonantinduction.atomic.process.fission.GuiNuclearBoiler;
import resonantinduction.atomic.process.fission.RenderCentrifuge;
import resonantinduction.atomic.process.fission.RenderNuclearBoiler;
import resonantinduction.atomic.process.fission.TileCentrifuge;
import resonantinduction.atomic.process.fission.TileNuclearBoiler;
import resonantinduction.atomic.process.sensor.RenderThermometer;
import resonantinduction.atomic.process.sensor.TileThermometer;
import resonantinduction.atomic.process.turbine.RenderElectricTurbine;
import resonantinduction.atomic.process.turbine.TileElectricTurbine;
import cpw.mods.fml.client.registry.ClientRegistry;
import cpw.mods.fml.client.registry.RenderingRegistry;
public class ClientProxy extends CommonProxy
{
@Override
public void preInit()
{
MinecraftForge.EVENT_BUS.register(SoundHandler.INSTANCE);
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.getBlockTileEntity(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;
}
}

View file

@ -0,0 +1,70 @@
package resonantinduction.atomic;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.world.World;
import resonant.lib.prefab.ProxyBase;
import resonantinduction.atomic.fission.reactor.ContainerReactorCell;
import resonantinduction.atomic.fission.reactor.TileReactorCell;
import resonantinduction.atomic.fusion.ContainerNuclearBoiler;
import resonantinduction.atomic.particle.accelerator.ContainerAccelerator;
import resonantinduction.atomic.particle.accelerator.TileAccelerator;
import resonantinduction.atomic.particle.quantum.ContainerQuantumAssembler;
import resonantinduction.atomic.particle.quantum.TileQuantumAssembler;
import resonantinduction.atomic.process.ContainerChemicalExtractor;
import resonantinduction.atomic.process.TileChemicalExtractor;
import resonantinduction.atomic.process.fission.ContainerCentrifuge;
import resonantinduction.atomic.process.fission.TileCentrifuge;
import resonantinduction.atomic.process.fission.TileNuclearBoiler;
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.getBlockTileEntity(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;
}
}

View file

@ -0,0 +1,50 @@
package resonantinduction.atomic;
import java.util.Iterator;
import java.util.Random;
import net.minecraft.block.Block;
import net.minecraft.entity.Entity;
import net.minecraft.world.ChunkPosition;
import net.minecraft.world.Explosion;
import net.minecraft.world.World;
/** Creates a reactor explosion.
*
* @author Calclavia */
public class ReactorExplosion extends Explosion
{
private Random explosionRAND = new Random();
private World worldObj;
public ReactorExplosion(World world, Entity par2Entity, double par3, double par5, double par7, float par9)
{
super(world, par2Entity, par3, par5, par7, par9);
this.worldObj = world;
this.isFlaming = true;
}
/** Does the second part of the explosion (sound, particles, drop spawn) */
@Override
public void doExplosionB(boolean par1)
{
super.doExplosionB(par1);
Iterator iterator = this.affectedBlockPositions.iterator();
while (iterator.hasNext())
{
ChunkPosition chunkposition = (ChunkPosition) iterator.next();
int x = chunkposition.x;
int y = chunkposition.y;
int z = chunkposition.z;
int id = this.worldObj.getBlockId(x, y, z);
int i1 = this.worldObj.getBlockId(x, y - 1, z);
if (id == 0 && Block.opaqueCubeLookup[i1] && this.explosionRAND.nextInt(3) == 0)
{
this.worldObj.setBlock(x, y, z, Atomic.blockRadioactive.blockID);
}
}
}
}

View file

@ -0,0 +1,25 @@
package resonantinduction.atomic;
import net.minecraftforge.client.event.sound.SoundLoadEvent;
import net.minecraftforge.event.ForgeSubscribe;
import resonantinduction.core.Reference;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
@SideOnly(Side.CLIENT)
public class SoundHandler
{
public static final SoundHandler INSTANCE = new SoundHandler();
public static final String[] SOUND_FILES =
{ "antimatter.ogg", "strangematter.ogg", "alarm.ogg", "accelerator.ogg", "turbine.ogg", "assembler.ogg", "reactorcell.ogg" };
@ForgeSubscribe
public void loadSoundEvents(SoundLoadEvent event)
{
for (int i = 0; i < SOUND_FILES.length; i++)
{
event.manager.addSound(Reference.PREFIX + SOUND_FILES[i]);
}
}
}

View file

@ -0,0 +1,15 @@
package resonantinduction.atomic.base;
import resonant.lib.prefab.item.ItemBase;
import resonantinduction.core.Reference;
import resonantinduction.core.Settings;
import resonantinduction.core.TabRI;
public class ItASBase extends ItemBase
{
/** Must be called while in mod init phase. */
public ItASBase(int itemID, String name)
{
super(itemID, name, Settings.CONFIGURATION, Reference.PREFIX, TabRI.DEFAULT);
}
}

View file

@ -0,0 +1,21 @@
package resonantinduction.atomic.base;
import resonantinduction.core.Reference;
import resonantinduction.core.Settings;
import resonantinduction.core.TabRI;
import universalelectricity.api.UniversalClass;
import universalelectricity.api.item.IEnergyItem;
import universalelectricity.api.item.ItemElectric;
@UniversalClass
public abstract class ItElectricAS extends ItemElectric implements IEnergyItem
{
public ItElectricAS(int itemID, String name)
{
super(Settings.CONFIGURATION.getItem(name, itemID).getInt());
this.setUnlocalizedName(Reference.PREFIX + name);
this.setCreativeTab(TabRI.DEFAULT);
this.setTextureName(Reference.PREFIX + name);
}
}

View file

@ -0,0 +1,51 @@
package resonantinduction.atomic.base;
import java.util.List;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import org.lwjgl.input.Keyboard;
import resonant.lib.render.EnumColor;
import resonant.lib.utility.LanguageUtility;
import resonantinduction.atomic.Atomic;
public class ItemCell extends Item
{
public ItemCell(int itemID)
{
super(itemID);
setContainerItem(Atomic.itemCell);
}
@Override
public void addInformation(ItemStack itemStack, EntityPlayer par2EntityPlayer, List list, boolean par4)
{
String tooltip = LanguageUtility.getLocal(getUnlocalizedName(itemStack) + ".tooltip");
if (tooltip != null && tooltip.length() > 0)
{
if (!Keyboard.isKeyDown(Keyboard.KEY_LSHIFT))
{
list.add(LanguageUtility.getLocal("tooltip.noShift").replace("%0", EnumColor.AQUA.toString()).replace("%1", EnumColor.GREY.toString()));
}
else
{
list.addAll(LanguageUtility.splitStringPerWord(tooltip, 5));
}
}
}
@Override
public String getUnlocalizedName(ItemStack itemstack)
{
String localized = LanguageUtility.getLocal(getUnlocalizedName() + "." + itemstack.getItemDamage() + ".name");
if (localized != null && !localized.isEmpty())
{
return getUnlocalizedName() + "." + itemstack.getItemDamage();
}
return getUnlocalizedName();
}
}

View file

@ -0,0 +1,56 @@
package resonantinduction.atomic.fission;
import java.util.Random;
import net.minecraft.block.material.Material;
import net.minecraft.util.Icon;
import net.minecraft.world.World;
import resonant.lib.prefab.block.BlockRadioactive;
import resonantinduction.core.Reference;
import resonantinduction.core.Settings;
import resonantinduction.core.TabRI;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
/** Uranium ore block */
public class BlockUraniumOre extends BlockRadioactive
{
public BlockUraniumOre(int id)
{
super(id, Material.rock);
this.setUnlocalizedName(Reference.PREFIX + "oreUranium");
this.setStepSound(soundStoneFootstep);
this.setCreativeTab(TabRI.DEFAULT);
this.setHardness(2f);
this.setTextureName(Reference.PREFIX + "oreUranium");
this.isRandomlyRadioactive = Settings.allowRadioactiveOres;
this.canWalkPoison = Settings.allowRadioactiveOres;
this.canSpread = false;
this.radius = 1f;
this.amplifier = 0;
this.spawnParticle = false;
}
@Override
@SideOnly(Side.CLIENT)
public void randomDisplayTick(World world, int x, int y, int z, Random par5Random)
{
if (Settings.allowRadioactiveOres)
{
super.randomDisplayTick(world, x, y, z, par5Random);
}
}
@Override
public Icon getIcon(int side, int metadata)
{
return this.blockIcon;
}
@Override
public int quantityDropped(Random par1Random)
{
return 1;
}
}

View file

@ -0,0 +1,34 @@
package resonantinduction.atomic.fission;
import net.minecraft.item.ItemStack;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.world.World;
import resonant.api.IReactor;
import resonant.api.IReactorComponent;
/** Breeder rods */
public class ItemBreederFuel extends ItemRadioactive implements IReactorComponent
{
public ItemBreederFuel(int itemID)
{
super(itemID);
this.setMaxDamage(ItemFissileFuel.DECAY);
this.setMaxStackSize(1);
this.setNoRepair();
}
@Override
public void onReact(ItemStack itemStack, IReactor reactor)
{
TileEntity tileEntity = (TileEntity) reactor;
World worldObj = tileEntity.worldObj;
// Breeder fuel rods have half the normal energy potential of pure uranium.
reactor.heat(ItemFissileFuel.ENERGY_PER_TICK / 2);
if (reactor.world().getWorldTime() % 20 == 0)
{
itemStack.setItemDamage(Math.min(itemStack.getItemDamage() + 1, itemStack.getMaxDamage()));
}
}
}

View file

@ -0,0 +1,99 @@
package resonantinduction.atomic.fission;
import java.util.List;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.item.ItemStack;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.world.World;
import net.minecraftforge.common.ForgeDirection;
import net.minecraftforge.fluids.FluidStack;
import resonant.api.IReactor;
import resonant.api.IReactorComponent;
import resonantinduction.atomic.Atomic;
import resonantinduction.core.Settings;
import universalelectricity.api.vector.Vector3;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
/** Fissile fuel rod */
public class ItemFissileFuel extends ItemRadioactive implements IReactorComponent
{
public static final int DECAY = 2500;
/** Temperature at which the fuel rod will begin to re-enrich itself. */
public static final int BREEDING_TEMP = 1200;
/** The energy in one KG of uranium is: 72PJ, 100TJ in one cell of uranium. */
public static final long ENERGY = 100000000000L;
/** Approximately 20,000,000J per tick. 400 MW. */
public static final long ENERGY_PER_TICK = ENERGY / 50000;
public ItemFissileFuel(int itemID)
{
super(itemID);
this.setMaxStackSize(1);
this.setMaxDamage(DECAY);
this.setNoRepair();
}
@Override
public void onReact(ItemStack itemStack, IReactor reactor)
{
TileEntity tileEntity = (TileEntity) reactor;
World worldObj = tileEntity.worldObj;
int reactors = 0;
for (int i = 0; i < 6; i++)
{
Vector3 checkPos = new Vector3(tileEntity).translate(ForgeDirection.getOrientation(i));
TileEntity tile = checkPos.getTileEntity(worldObj);
// Check that the other reactors not only exist but also are running.
if (tile instanceof IReactor && ((IReactor) tile).getTemperature() > BREEDING_TEMP)
{
reactors++;
}
}
// Only three reactor cells are required to begin the uranium breeding process instead of four.
if (reactors >= 3)
{
// Begin the process of re-enriching the uranium rod but not consistently.
if (worldObj.rand.nextInt(1000) <= 100 && reactor.getTemperature() > BREEDING_TEMP)
{
// Cells can regain a random amount of health per tick.
int healAmt = worldObj.rand.nextInt(5);
itemStack.setItemDamage(Math.max(itemStack.getItemDamage() - healAmt, 0));
// System.out.println("[Atomic Science] [Reactor Cell] Breeding " + String.valueOf(healAmt) + " back into fissle rod. " + String.valueOf(itemStack.getItemDamage()) + " / " + String.valueOf(itemStack.getMaxDamage()));
}
}
else
{
reactor.heat(ENERGY_PER_TICK);
if (reactor.world().getWorldTime() % 20 == 0)
{
itemStack.setItemDamage(Math.min(itemStack.getItemDamage() + 1, itemStack.getMaxDamage()));
}
// Create toxic waste.
if (Settings.allowToxicWaste && worldObj.rand.nextFloat() > 0.5)
{
FluidStack fluid = Atomic.FLUIDSTACK_TOXIC_WASTE.copy();
fluid.amount = 1;
reactor.fill(ForgeDirection.UNKNOWN, fluid, true);
}
}
}
@Override
@SideOnly(Side.CLIENT)
public void getSubItems(int par1, CreativeTabs par2CreativeTabs, List par3List)
{
par3List.add(new ItemStack(par1, 1, 0));
par3List.add(new ItemStack(par1, 1, getMaxDamage() - 1));
}
}

View file

@ -0,0 +1,28 @@
package resonantinduction.atomic.fission;
import net.minecraft.entity.Entity;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.world.World;
import resonant.lib.prefab.poison.PoisonRadiation;
import universalelectricity.api.vector.Vector3;
/** Radioactive Items */
public class ItemRadioactive extends Item
{
public ItemRadioactive(int itemID)
{
super(itemID);
}
@Override
public void onUpdate(ItemStack par1ItemStack, World par2World, Entity entity, int par4, boolean par5)
{
if (entity instanceof EntityLivingBase)
{
PoisonRadiation.INSTANCE.poisonEntity(new Vector3(entity), (EntityLivingBase) entity, 1);
}
}
}

View file

@ -0,0 +1,54 @@
package resonantinduction.atomic.fission;
import java.util.List;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.ItemStack;
import org.lwjgl.input.Keyboard;
import resonant.lib.render.EnumColor;
import resonant.lib.utility.LanguageUtility;
/** Uranium */
public class ItemUranium extends ItemRadioactive
{
public ItemUranium(int itemID)
{
super(itemID);
this.setHasSubtypes(true);
this.setMaxDamage(0);
}
@Override
public void addInformation(ItemStack itemStack, EntityPlayer par2EntityPlayer, List list, boolean par4)
{
String tooltip = LanguageUtility.getLocal(getUnlocalizedName(itemStack) + ".tooltip");
if (tooltip != null && tooltip.length() > 0)
{
if (!Keyboard.isKeyDown(Keyboard.KEY_LSHIFT))
{
list.add(LanguageUtility.getLocal("tooltip.noShift").replace("%0", EnumColor.AQUA.toString()).replace("%1", EnumColor.GREY.toString()));
}
else
{
list.addAll(LanguageUtility.splitStringPerWord(tooltip, 5));
}
}
}
@Override
public String getUnlocalizedName(ItemStack itemStack)
{
return this.getUnlocalizedName() + "." + itemStack.getItemDamage();
}
@Override
public void getSubItems(int par1, CreativeTabs par2CreativeTabs, List list)
{
list.add(new ItemStack(this, 1, 0));
list.add(new ItemStack(this, 1, 1));
}
}

View file

@ -0,0 +1,72 @@
package resonantinduction.atomic.fission.reactor;
import net.minecraft.client.renderer.texture.IconRegister;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.item.ItemStack;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.Icon;
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 Icon 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 Icon getIcon(int side, int metadata)
{
if (side == metadata)
{
return this.frontIcon;
}
return this.blockIcon;
}
@SideOnly(Side.CLIENT)
@Override
public void registerIcons(IconRegister iconRegister)
{
super.registerIcons(iconRegister);
this.frontIcon = iconRegister.registerIcon(this.getUnlocalizedName().replace("tile.", "") + "_front");
}
@Override
public TileEntity createNewTileEntity(World var1)
{
return new TileReactorDrain();
}
}

View file

@ -0,0 +1,51 @@
package resonantinduction.atomic.fission.reactor;
import java.util.Random;
import net.minecraft.block.material.Material;
import net.minecraft.entity.Entity;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.util.DamageSource;
import net.minecraft.world.World;
import net.minecraftforge.fluids.BlockFluidClassic;
import net.minecraftforge.fluids.FluidRegistry;
import resonant.lib.prefab.poison.PoisonRadiation;
import universalelectricity.api.vector.Vector3;
public class BlockToxicWaste extends BlockFluidClassic
{
public BlockToxicWaste(int id)
{
super(id, FluidRegistry.getFluid("toxicwaste"), Material.water);
setTickRate(20);
}
@Override
public void randomDisplayTick(World par1World, int x, int y, int z, Random par5Random)
{
super.randomDisplayTick(par1World, x, y, z, par5Random);
if (par5Random.nextInt(100) == 0)
{
double d5 = x + par5Random.nextFloat();
double d7 = y + this.maxY;
double d6 = z + par5Random.nextFloat();
par1World.spawnParticle("suspended", d5, d7, d6, 0.0D, 0.0D, 0.0D);
}
if (par5Random.nextInt(200) == 0)
{
par1World.playSound(x, y, z, "liquid.lava", 0.2F + par5Random.nextFloat() * 0.2F, 0.9F + par5Random.nextFloat() * 0.15F, false);
}
}
@Override
public void onEntityCollidedWithBlock(World par1World, int x, int y, int z, Entity entity)
{
if (entity instanceof EntityLivingBase)
{
entity.attackEntityFrom(DamageSource.wither, 3);
PoisonRadiation.INSTANCE.poisonEntity(new Vector3(x, y, z), (EntityLivingBase) entity, 4);
}
}
}

View file

@ -0,0 +1,78 @@
package resonantinduction.atomic.fission.reactor;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.Slot;
import net.minecraft.item.ItemStack;
import resonant.lib.gui.ContainerBase;
import resonant.lib.prefab.slot.SlotSpecific;
import resonantinduction.atomic.fission.ItemBreederFuel;
import resonantinduction.atomic.fission.ItemFissileFuel;
public class ContainerReactorCell extends ContainerBase
{
public ContainerReactorCell(EntityPlayer player, TileReactorCell tileEntity)
{
super(tileEntity);
this.addSlotToContainer(new SlotSpecific(tileEntity, 0, 79, 17, ItemFissileFuel.class, ItemBreederFuel.class));
this.addPlayerInventory(player);
}
/** Called to transfer a stack from one inventory to the other eg. when shift clicking. */
@Override
public ItemStack transferStackInSlot(EntityPlayer par1EntityPlayer, int par1)
{
ItemStack var2 = null;
Slot var3 = (Slot) this.inventorySlots.get(par1);
if (var3 != null && var3.getHasStack())
{
ItemStack itemStack = var3.getStack();
var2 = itemStack.copy();
if (par1 >= this.slotCount)
{
if (this.getSlot(0).isItemValid(itemStack))
{
if (!this.mergeItemStack(itemStack, 0, 1, false))
{
return null;
}
}
else if (par1 < 27 + this.slotCount)
{
if (!this.mergeItemStack(itemStack, 27 + slotCount, 36 + slotCount, false))
{
return null;
}
}
else if (par1 >= 27 + slotCount && par1 < 36 + slotCount && !this.mergeItemStack(itemStack, 4, 30, false))
{
return null;
}
}
else if (!this.mergeItemStack(itemStack, slotCount, 36 + slotCount, false))
{
return null;
}
if (itemStack.stackSize == 0)
{
var3.putStack((ItemStack) null);
}
else
{
var3.onSlotChanged();
}
if (itemStack.stackSize == var2.stackSize)
{
return null;
}
var3.onPickupFromSlot(par1EntityPlayer, itemStack);
}
return var2;
}
}

View file

@ -0,0 +1,90 @@
package resonantinduction.atomic.fission.reactor;
import java.util.List;
import net.minecraft.entity.player.InventoryPlayer;
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
{
private TileReactorCell tileEntity;
public GuiReactorCell(InventoryPlayer inventory, TileReactorCell tileEntity)
{
super(new ContainerReactorCell(inventory.player, tileEntity));
this.tileEntity = tileEntity;
}
/** Draw the foreground layer for the GuiContainer (everything in front of the items) */
@Override
public void drawGuiContainerForegroundLayer(int x, int y)
{
fontRenderer.drawString(tileEntity.getInvName(), xSize / 2 - fontRenderer.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);
// 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);
}
fontRenderer.drawString(LanguageUtility.getLocal("tooltip.remainingTime"), 100, 45, 4210752);
if (isPointInRegion(80, 40, meterWidth, meterHeight, x, y))
{
if (tileEntity.tank.getFluid() != null)
{
drawTooltip(x - guiLeft, y - guiTop + 10, tileEntity.tank.getFluid().getFluid().getLocalizedName(), UnitDisplay.getDisplay(tileEntity.tank.getFluidAmount(), Unit.LITER));
}
else
{
drawTooltip(x - guiLeft, y - guiTop + 10, "No Fluid");
}
}
List<String> desc = LanguageUtility.splitStringPerWord(LanguageUtility.getLocal("tile.atomicscience:reactorCell.tooltip"), 5);
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) */
@Override
protected void drawGuiContainerBackgroundLayer(float par1, int x, int y)
{
super.drawGuiContainerBackgroundLayer(par1, x, y);
drawSlot(78, 16);
drawMeter(80, 36, (float) tileEntity.tank.getFluidAmount() / (float) tileEntity.tank.getCapacity(), tileEntity.tank.getFluid());
if (tileEntity.getStackInSlot(0) != null)
{
// Progress bar of temperature inside of reactor.
GL11.glPushMatrix();
GL11.glTranslatef(32 * 2, 0, 0);
GL11.glScalef(0.5f, 1, 1);
drawForce(20, 70, (tileEntity.getTemperature()) / (TileReactorCell.MELTING_POINT));
GL11.glPopMatrix();
// Progress bar of remaining burn time on reactor cell.
GL11.glPushMatrix();
GL11.glTranslatef(68 * 2, 0, 0);
GL11.glScalef(0.5f, 1, 1);
float ticksLeft = (tileEntity.getStackInSlot(0).getMaxDamage() - tileEntity.getStackInSlot(0).getItemDamage());
drawElectricity(70, 70, ticksLeft / tileEntity.getStackInSlot(0).getMaxDamage());
GL11.glPopMatrix();
}
}
}

View file

@ -0,0 +1,101 @@
package resonantinduction.atomic.fission.reactor;
import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.ResourceLocation;
import net.minecraftforge.client.model.AdvancedModelLoader;
import net.minecraftforge.client.model.IModelCustom;
import org.lwjgl.opengl.GL11;
import resonant.lib.render.RenderUtility;
import resonant.lib.render.block.ModelCube;
import resonantinduction.core.Reference;
import cpw.mods.fml.relauncher.Side;
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 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");
@Override
public void renderTileEntityAt(TileEntity t, double x, double y, double z, float f)
{
TileReactorCell tileEntity = (TileReactorCell) t;
// Render main body
GL11.glPushMatrix();
GL11.glTranslated(x + 0.5, y + 0.5, z + 0.5);
int meta = 2;
if (tileEntity.worldObj != null)
{
meta = tileEntity.getBlockMetadata();
}
boolean hasBelow = tileEntity.worldObj != null && t.worldObj.getBlockTileEntity(t.xCoord, t.yCoord - 1, t.zCoord) instanceof TileReactorCell;
switch (meta)
{
case 0:
bindTexture(TEXTURE_BOTTOM);
MODEL_BOTTOM.renderAll();
break;
case 1:
bindTexture(TEXTURE_MIDDLE);
GL11.glTranslatef(0, 0.075f, 0);
GL11.glScalef(1f, 1.15f, 1f);
MODEL_MIDDLE.renderAll();
break;
case 2:
bindTexture(TEXTURE_TOP);
if (hasBelow)
{
GL11.glScalef(1f, 1.32f, 1f);
}
else
{
GL11.glTranslatef(0, 0.1f, 0);
GL11.glScalef(1f, 1.2f, 1f);
}
if (hasBelow)
{
MODEL_TOP.renderAllExcept("BottomPad", "BaseDepth", "BaseWidth", "Base");
}
else
{
MODEL_TOP.renderAll();
}
break;
}
GL11.glPopMatrix();
// Render the fuel within the reactor
if (tileEntity.getStackInSlot(0) != null)
{
float height = tileEntity.getHeight() * ((float) (tileEntity.getStackInSlot(0).getMaxDamage() - tileEntity.getStackInSlot(0).getItemDamage()) / (float) tileEntity.getStackInSlot(0).getMaxDamage());
GL11.glPushMatrix();
GL11.glTranslatef((float) x + 0.5F, (float) y + 0.5F * height, (float) z + 0.5F);
GL11.glScalef(0.4f, 0.9f * height, 0.4f);
bindTexture(TEXTURE_FISSILE);
RenderUtility.disableLighting();
ModelCube.INSTNACE.render();
RenderUtility.enableLighting();
GL11.glPopMatrix();
}
}
}

View file

@ -0,0 +1,16 @@
package resonantinduction.atomic.fission.reactor;
import net.minecraft.block.material.Material;
import resonant.lib.content.module.TileBlock;
import resonant.lib.prefab.vector.Cuboid;
/** Control rod block */
public class TileControlRod extends TileBlock
{
public TileControlRod()
{
super(Material.iron);
bounds = new Cuboid(0.3f, 0f, 0.3f, 0.7f, 1f, 0.7f);
isOpaqueCube = false;
}
}

View file

@ -0,0 +1,612 @@
package resonantinduction.atomic.fission.reactor;
import java.util.ArrayList;
import java.util.List;
import net.minecraft.block.Block;
import net.minecraft.entity.EntityLiving;
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.minecraft.network.packet.Packet;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.AxisAlignedBB;
import net.minecraft.world.World;
import net.minecraftforge.common.ForgeDirection;
import net.minecraftforge.common.MinecraftForge;
import net.minecraftforge.fluids.Fluid;
import net.minecraftforge.fluids.FluidContainerRegistry;
import net.minecraftforge.fluids.FluidStack;
import net.minecraftforge.fluids.FluidTank;
import net.minecraftforge.fluids.FluidTankInfo;
import net.minecraftforge.fluids.IFluidHandler;
import resonant.api.IReactor;
import resonant.api.IReactorComponent;
import resonant.api.event.PlasmaEvent.SpawnPlasmaEvent;
import resonant.lib.content.module.prefab.TileInventory;
import resonant.lib.multiblock.IMultiBlockStructure;
import resonant.lib.multiblock.MultiBlockHandler;
import resonant.lib.network.PacketHandler;
import resonant.lib.network.Synced;
import resonant.lib.network.Synced.SyncedInput;
import resonant.lib.network.Synced.SyncedOutput;
import resonant.lib.prefab.poison.PoisonRadiation;
import resonant.lib.thermal.ThermalGrid;
import resonant.lib.thermal.ThermalPhysics;
import resonant.lib.utility.inventory.InventoryUtility;
import resonantinduction.atomic.Atomic;
import resonantinduction.atomic.ReactorExplosion;
import resonantinduction.atomic.fusion.TilePlasma;
import resonantinduction.core.ResonantInduction;
import universalelectricity.api.UniversalElectricity;
import universalelectricity.api.vector.Vector3;
import universalelectricity.api.vector.VectorWorld;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
/** The primary reactor component cell used to build reactors with.
*
* @author Calclavia */
public class TileReactorCell extends TileInventory implements IMultiBlockStructure<TileReactorCell>, IInventory, IReactor, IFluidHandler, ISidedInventory
{
public static final int RADIUS = 2;
public static final int MELTING_POINT = 2000;
private final int specificHeatCapacity = 1000;
private final float mass = ThermalPhysics.getMass(1000, 7);
public FluidTank tank = new FluidTank(FluidContainerRegistry.BUCKET_VOLUME * 15);
@Synced
public float temperature = 295;
private float previousTemperature = 295;
private boolean shouldUpdate = false;
private long prevInternalEnergy = 0;
private long internalEnergy = 0;
private int meltdownCounter = 0;
private int meltdownCounterMaximum = 1000;
/** Multiblock Methods. */
private MultiBlockHandler<TileReactorCell> multiBlock;
public TileReactorCell()
{
super(UniversalElectricity.machine);
textureName = "machine";
isOpaqueCube = false;
normalRender = false;
customItemRender = true;
}
@Override
protected void onWorldJoin()
{
updatePositionStatus();
}
@Override
protected void onNeighborChanged()
{
updatePositionStatus();
}
@Override
public void initiate()
{
updatePositionStatus();
super.initiate();
}
/** Called when the block is right clicked by the player */
@Override
protected boolean use(EntityPlayer player, int side, Vector3 hit)
{
if (!world().isRemote)
{
TileReactorCell tile = getMultiBlock().get();
if (!player.isSneaking())
{
if (tile.getStackInSlot(0) != null)
{
InventoryUtility.dropItemStack(world(), new Vector3(player), tile.getStackInSlot(0), 0);
tile.setInventorySlotContents(0, null);
return true;
}
else if (player.inventory.getCurrentItem() != null)
{
if (player.inventory.getCurrentItem().getItem() instanceof IReactorComponent)
{
ItemStack itemStack = player.inventory.getCurrentItem().copy();
itemStack.stackSize = 1;
tile.setInventorySlotContents(0, itemStack);
player.inventory.decrStackSize(player.inventory.currentItem, 1);
return true;
}
}
}
player.openGui(Atomic.INSTANCE, 0, world(), tile.xCoord, tile.yCoord, tile.zCoord);
}
return true;
}
@Override
protected void markUpdate()
{
super.markUpdate();
shouldUpdate = true;
}
@Override
public void updateEntity()
{
super.updateEntity();
/** Move fuel rod down into the primary cell block if possible */
if (!getMultiBlock().isPrimary())
{
if (getStackInSlot(0) != null)
{
if (getMultiBlock().get().getStackInSlot(0) == null)
{
getMultiBlock().get().setInventorySlotContents(0, getStackInSlot(0));
setInventorySlotContents(0, null);
}
}
if (tank.getFluidAmount() > 0)
{
getMultiBlock().get().tank.fill(tank.drain(tank.getCapacity(), true), true);
}
}
if (!worldObj.isRemote)
{
if (getMultiBlock().isPrimary() && tank.getFluid() != null && tank.getFluid().fluidID == Atomic.FLUID_PLASMA.getID())
{
/** Spawn plasma */
FluidStack drain = tank.drain(FluidContainerRegistry.BUCKET_VOLUME, false);
if (drain != null && drain.amount >= FluidContainerRegistry.BUCKET_VOLUME)
{
ForgeDirection spawnDir = ForgeDirection.getOrientation(worldObj.rand.nextInt(3) + 2);
Vector3 spawnPos = new Vector3(this).translate(spawnDir, 2);
spawnPos.translate(0, Math.max(worldObj.rand.nextInt(getHeight()) - 1, 0), 0);
if (worldObj.isAirBlock(spawnPos.intX(), spawnPos.intY(), spawnPos.intZ()))
{
MinecraftForge.EVENT_BUS.post(new SpawnPlasmaEvent(worldObj, spawnPos.intX(), spawnPos.intY(), spawnPos.intZ(), TilePlasma.plasmaMaxTemperature));
tank.drain(FluidContainerRegistry.BUCKET_VOLUME, true);
}
}
}
else
{
prevInternalEnergy = internalEnergy;
/** Handle cell rod interactions. */
ItemStack fuelRod = getMultiBlock().get().getStackInSlot(0);
if (fuelRod != null)
{
if (fuelRod.getItem() instanceof IReactorComponent)
{
// Activate rods.
((IReactorComponent) fuelRod.getItem()).onReact(fuelRod, this);
if (!worldObj.isRemote)
{
if (fuelRod.getItemDamage() >= fuelRod.getMaxDamage())
{
getMultiBlock().get().setInventorySlotContents(0, null);
}
}
// Emit Radiations
if (ticks % 20 == 0)
{
if (worldObj.rand.nextFloat() > 0.65)
{
List<EntityLiving> entities = worldObj.getEntitiesWithinAABB(EntityLiving.class,
AxisAlignedBB.getBoundingBox(xCoord - RADIUS * 2, yCoord - RADIUS * 2, zCoord - RADIUS * 2, xCoord + RADIUS * 2, yCoord + RADIUS * 2, zCoord + RADIUS * 2));
for (EntityLiving entity : entities)
{
PoisonRadiation.INSTANCE.poisonEntity(new Vector3(this), entity);
}
}
}
}
}
// Update the temperature from the thermal grid.
temperature = ThermalGrid.getTemperature(new VectorWorld(this));
/** Only a small percentage of the internal energy is used for temperature. */
if (internalEnergy - prevInternalEnergy > 0)
{
float deltaT = ThermalPhysics.getTemperatureForEnergy(mass, specificHeatCapacity, (long) ((internalEnergy - prevInternalEnergy) * 0.15));
/** Check control rods */
int rods = 0;
for (int i = 2; i < 6; i++)
{
Vector3 checkAdjacent = new Vector3(this).translate(ForgeDirection.getOrientation(i));
if (checkAdjacent.getBlockID(worldObj) == Atomic.blockControlRod.blockID)
{
deltaT /= 1.1;
rods++;
}
}
// Add heat to surrounding blocks in the thermal grid.
ThermalGrid.addTemperature(new VectorWorld(this), deltaT);
// Sound of lava flowing randomly plays when above temperature to boil water.
if (worldObj.rand.nextInt(80) == 0 && this.getTemperature() >= 373)
{
worldObj.playSoundEffect(this.xCoord + 0.5F, this.yCoord + 0.5F, this.zCoord + 0.5F, "Fluid.lava", 0.5F, 2.1F + (worldObj.rand.nextFloat() - worldObj.rand.nextFloat()) * 0.85F);
}
// Sounds of lava popping randomly plays when above temperature to boil water.
if (worldObj.rand.nextInt(40) == 0 && this.getTemperature() >= 373)
{
worldObj.playSoundEffect(this.xCoord + 0.5F, this.yCoord + 0.5F, this.zCoord + 0.5F, "Fluid.lavapop", 0.5F, 2.6F + (worldObj.rand.nextFloat() - worldObj.rand.nextFloat()) * 0.8F);
}
// Reactor cell plays random idle noises while operating and above temperature to boil water.
if (worldObj.getWorldTime() % (Atomic.SECOND_IN_TICKS * 5.0F) == 0 && this.getTemperature() >= 373)
{
float percentage = Math.min(this.getTemperature() / TileReactorCell.MELTING_POINT, 1.0F);
worldObj.playSoundEffect(this.xCoord + 0.5F, this.yCoord + 0.5F, this.zCoord + 0.5F, "atomicscience:reactorcell", percentage, 1.0F);
// AtomicScience.LOGGER.info("REACTOR SOUND");
}
if (previousTemperature != temperature && !shouldUpdate)
{
shouldUpdate = true;
previousTemperature = temperature;
// System.out.println("[Atomic Science] [Thermal Grid] Temperature: " + String.valueOf(previousTemperature));
}
if (previousTemperature >= MELTING_POINT && meltdownCounter < meltdownCounterMaximum)
{
shouldUpdate = true;
meltdownCounter++;
// System.out.println("[Atomic Science] [Reactor Cell] Meltdown Ticker: " + String.valueOf(temperature) + " @ " + String.valueOf(meltdownCounter) + "/" + String.valueOf(meltdownCounterMaximum));
}
if (previousTemperature >= MELTING_POINT && meltdownCounter >= meltdownCounterMaximum)
{
// System.out.println("[Atomic Science] [Reactor Cell] Meltdown Ticker: REACTOR MELTDOWN!");
meltdownCounter = 0;
meltDown();
return;
}
else
{
// Reset meltdown ticker to give the reactor more of a 'goldilocks zone'.
meltdownCounter = 0;
}
}
internalEnergy = 0;
if (isOverToxic())
{
/** Randomly leak toxic waste when it is too toxic */
VectorWorld leakPos = new VectorWorld(this).translate(worldObj.rand.nextInt(20) - 10, worldObj.rand.nextInt(20) - 10, worldObj.rand.nextInt(20) - 10);
int blockID = leakPos.getBlockID();
if (blockID == Block.grass.blockID)
{
leakPos.setBlock(worldObj, Atomic.blockRadioactive.blockID);
tank.drain(FluidContainerRegistry.BUCKET_VOLUME, true);
}
else if (blockID == 0 || Block.blocksList[blockID].isBlockReplaceable(worldObj, leakPos.intX(), leakPos.intY(), leakPos.intZ()))
{
if (tank.getFluid() != null)
{
leakPos.setBlock(worldObj, tank.getFluid().getFluid().getBlockID());
tank.drain(FluidContainerRegistry.BUCKET_VOLUME, true);
}
}
}
}
if (ticks % 60 == 0 || shouldUpdate)
{
shouldUpdate = false;
notifyChange();
PacketHandler.sendPacketToClients(getDescriptionPacket(), worldObj, new Vector3(this), 50);
}
}
else
{
// Particles of white smoke will rise from above the reactor chamber when above water boiling temperature.
if (worldObj.rand.nextInt(5) == 0 && this.getTemperature() >= 373)
{
worldObj.spawnParticle("cloud", this.xCoord + worldObj.rand.nextInt(2), this.yCoord + 1.0F, this.zCoord + worldObj.rand.nextInt(2), 0, 0.1D, 0);
worldObj.spawnParticle("bubble", this.xCoord + worldObj.rand.nextInt(5), this.yCoord, this.zCoord + worldObj.rand.nextInt(5), 0, 0, 0);
}
}
}
@Override
public boolean isOverToxic()
{
return tank.getFluid() != null && tank.getFluid().fluidID == Atomic.FLUID_TOXIC_WASTE.getID() && tank.getFluid().amount >= tank.getCapacity();
}
/** Multiblock Methods */
public void updatePositionStatus()
{
TileReactorCell mainTile = getLowest();
mainTile.getMultiBlock().deconstruct();
mainTile.getMultiBlock().construct();
boolean top = new Vector3(this).add(new Vector3(0, 1, 0)).getTileEntity(worldObj) instanceof TileReactorCell;
boolean bottom = new Vector3(this).add(new Vector3(0, -1, 0)).getTileEntity(worldObj) instanceof TileReactorCell;
if (top && bottom)
{
worldObj.setBlockMetadataWithNotify(xCoord, yCoord, zCoord, 1, 3);
}
else if (top)
{
worldObj.setBlockMetadataWithNotify(xCoord, yCoord, zCoord, 0, 3);
}
else
{
worldObj.setBlockMetadataWithNotify(xCoord, yCoord, zCoord, 2, 3);
}
}
@Override
public void onMultiBlockChanged()
{
}
@Override
public Vector3[] getMultiBlockVectors()
{
List<Vector3> vectors = new ArrayList<Vector3>();
Vector3 checkPosition = new Vector3(this);
while (true)
{
TileEntity t = checkPosition.getTileEntity(this.worldObj);
if (t instanceof TileReactorCell)
{
vectors.add(checkPosition.clone().subtract(getPosition()));
}
else
{
break;
}
checkPosition.y++;
}
return vectors.toArray(new Vector3[0]);
}
public TileReactorCell getLowest()
{
TileReactorCell lowest = this;
Vector3 checkPosition = new Vector3(this);
while (true)
{
TileEntity t = checkPosition.getTileEntity(this.worldObj);
if (t instanceof TileReactorCell)
{
lowest = (TileReactorCell) t;
}
else
{
break;
}
checkPosition.y--;
}
return lowest;
}
@Override
public World getWorld()
{
return worldObj;
}
@Override
public Vector3 getPosition()
{
return new Vector3(this);
}
@Override
public MultiBlockHandler<TileReactorCell> getMultiBlock()
{
if (multiBlock == null)
{
multiBlock = new MultiBlockHandler<TileReactorCell>(this);
}
return multiBlock;
}
public int getHeight()
{
int height = 0;
Vector3 checkPosition = new Vector3(this);
TileEntity tile = this;
while (tile instanceof TileReactorCell)
{
checkPosition.y++;
height++;
tile = checkPosition.getTileEntity(worldObj);
}
return height;
}
@Override
public Packet getDescriptionPacket()
{
return ResonantInduction.PACKET_ANNOTATION.getPacket(this);
}
private void meltDown()
{
if (!worldObj.isRemote)
{
// No need to destroy reactor cell since explosion will do that for us.
ReactorExplosion reactorExplosion = new ReactorExplosion(worldObj, null, xCoord, yCoord, zCoord, 9f);
reactorExplosion.doExplosionA();
reactorExplosion.doExplosionB(true);
}
}
/** Reads a tile entity from NBT. */
@SyncedInput
@Override
public void readFromNBT(NBTTagCompound nbt)
{
super.readFromNBT(nbt);
temperature = nbt.getFloat("temperature");
tank.readFromNBT(nbt);
getMultiBlock().load(nbt);
}
/** Writes a tile entity to NBT. */
@SyncedOutput
@Override
public void writeToNBT(NBTTagCompound nbt)
{
super.writeToNBT(nbt);
nbt.setFloat("temperature", temperature);
tank.writeToNBT(nbt);
getMultiBlock().save(nbt);
}
@Override
public int getInventoryStackLimit()
{
return 1;
}
/** Returns true if automation can insert the given item in the given slot from the given side. Args: Slot, item, side */
@Override
public boolean canInsertItem(int slot, ItemStack items, int side)
{
return this.isItemValidForSlot(slot, items);
}
@Override
public boolean isUseableByPlayer(EntityPlayer par1EntityPlayer)
{
return worldObj.getBlockTileEntity(xCoord, yCoord, zCoord) != this ? false : par1EntityPlayer.getDistanceSq(xCoord + 0.5D, yCoord + 0.5D, zCoord + 0.5D) <= 64.0D;
}
@Override
public String getInvName()
{
return getBlockType().getLocalizedName();
}
@Override
public boolean isItemValidForSlot(int slotID, ItemStack itemStack)
{
if (getMultiBlock().isPrimary() && getMultiBlock().get().getStackInSlot(0) == null)
{
return itemStack.getItem() instanceof IReactorComponent;
}
return false;
}
/** Fluid Functions. */
@Override
public int fill(ForgeDirection from, FluidStack resource, boolean doFill)
{
return getMultiBlock().get().tank.fill(resource, doFill);
}
@Override
public FluidStack drain(ForgeDirection from, int maxDrain, boolean doDrain)
{
return tank.drain(maxDrain, doDrain);
}
@Override
public FluidStack drain(ForgeDirection from, FluidStack resource, boolean doDrain)
{
if (resource == null || !resource.isFluidEqual(tank.getFluid()))
{
return null;
}
return tank.drain(resource.amount, doDrain);
}
@Override
public boolean canFill(ForgeDirection from, Fluid fluid)
{
return fluid == Atomic.FLUID_PLASMA;
}
@Override
public boolean canDrain(ForgeDirection from, Fluid fluid)
{
return fluid == Atomic.FLUID_TOXIC_WASTE;
}
@Override
public FluidTankInfo[] getTankInfo(ForgeDirection from)
{
return new FluidTankInfo[]
{ tank.getInfo() };
}
@Override
@SideOnly(Side.CLIENT)
public AxisAlignedBB getRenderBoundingBox()
{
if (getMultiBlock().isPrimary() && getMultiBlock().isConstructed())
{
return INFINITE_EXTENT_AABB;
}
return super.getRenderBoundingBox();
}
@Override
public void heat(long energy)
{
internalEnergy = Math.max(internalEnergy + energy, 0);
}
@Override
public float getTemperature()
{
return temperature;
}
}

View file

@ -0,0 +1,182 @@
package resonantinduction.atomic.fission.reactor;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import net.minecraft.block.Block;
import net.minecraft.block.BlockFluid;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.world.World;
import net.minecraftforge.common.ForgeDirection;
import net.minecraftforge.fluids.Fluid;
import net.minecraftforge.fluids.FluidStack;
import net.minecraftforge.fluids.FluidTankInfo;
import net.minecraftforge.fluids.IFluidBlock;
import net.minecraftforge.fluids.IFluidHandler;
import net.minecraftforge.fluids.IFluidTank;
import resonant.lib.path.IPathCallBack;
import resonant.lib.path.Pathfinder;
import resonant.lib.prefab.tile.TileAdvanced;
import universalelectricity.api.vector.Vector3;
/** Reactor Drain
*
* @author Calclavia */
public class TileReactorDrain extends TileAdvanced implements IFluidHandler
{
private final Set<IFluidTank> tanks = new HashSet<IFluidTank>();
private long lastFindTime = -1;
public void find()
{
this.tanks.clear();
final World world = this.worldObj;
final Vector3 position = new Vector3(this);
Pathfinder finder = new Pathfinder(new IPathCallBack()
{
@Override
public Set<Vector3> getConnectedNodes(Pathfinder finder, Vector3 currentNode)
{
Set<Vector3> neighbors = new HashSet<Vector3>();
for (int i = 0; i < 6; i++)
{
ForgeDirection direction = ForgeDirection.getOrientation(i);
Vector3 position = currentNode.clone().translate(direction);
int connectedBlockID = position.getBlockID(world);
if (connectedBlockID == 0 || Block.blocksList[connectedBlockID] instanceof BlockFluid || Block.blocksList[connectedBlockID] instanceof IFluidBlock || position.getTileEntity(world) instanceof TileReactorCell)
{
neighbors.add(position);
}
}
return neighbors;
}
@Override
public boolean onSearch(Pathfinder finder, Vector3 start, Vector3 node)
{
if (node.getTileEntity(world) instanceof TileReactorCell)
{
finder.results.add(node);
}
if (node.distance(position) > 6)
{
return true;
}
return false;
}
}).init(new Vector3(this).translate(ForgeDirection.getOrientation(this.getBlockMetadata()).getOpposite()));
for (Vector3 node : finder.results)
{
TileEntity tileEntity = node.getTileEntity(this.worldObj);
if (tileEntity instanceof TileReactorCell)
{
this.tanks.add(((TileReactorCell) tileEntity).tank);
}
}
this.lastFindTime = this.worldObj.getWorldTime();
}
public IFluidTank getOptimalTank()
{
if (this.lastFindTime == -1 || this.worldObj.getWorldTime() - this.lastFindTime > 20)
{
this.find();
}
if (this.tanks.size() > 0)
{
IFluidTank optimalTank = null;
for (IFluidTank tank : this.tanks)
{
if (tank != null)
{
if (optimalTank == null || (optimalTank != null && getFluidSafe(tank.getFluid()) > getFluidSafe(optimalTank.getFluid())))
{
optimalTank = tank;
}
}
}
return optimalTank;
}
return null;
}
public int getFluidSafe(FluidStack stack)
{
if (stack != null)
{
return stack.amount;
}
return 0;
}
@Override
public boolean canUpdate()
{
return false;
}
@Override
public int fill(ForgeDirection from, FluidStack resource, boolean doFill)
{
return 0;
}
@Override
public FluidStack drain(ForgeDirection from, int maxDrain, boolean doDrain)
{
if (this.getOptimalTank() != null)
{
return this.getOptimalTank().drain(maxDrain, doDrain);
}
return null;
}
@Override
public FluidStack drain(ForgeDirection from, FluidStack resource, boolean doDrain)
{
return null;
}
@Override
public boolean canFill(ForgeDirection from, Fluid fluid)
{
return false;
}
@Override
public boolean canDrain(ForgeDirection from, Fluid fluid)
{
return true;
}
@Override
public FluidTankInfo[] getTankInfo(ForgeDirection from)
{
List<FluidTankInfo> tankInfoList = new ArrayList<FluidTankInfo>();
this.getOptimalTank();
for (IFluidTank tank : this.tanks)
{
tankInfoList.add(tank.getInfo());
}
return tankInfoList.toArray(new FluidTankInfo[0]);
}
}

View file

@ -0,0 +1,53 @@
package resonantinduction.atomic.fusion;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.world.World;
import resonant.lib.prefab.block.BlockTile;
import resonant.lib.render.block.BlockRenderingHandler;
import resonant.lib.utility.FluidUtility;
import universalelectricity.api.UniversalElectricity;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
/** Fusion reactor */
public class BlockPlasmaHeater extends BlockTile
{
public BlockPlasmaHeater(int ID)
{
super(ID, UniversalElectricity.machine);
}
@Override
public boolean onMachineActivated(World world, int x, int y, int z, EntityPlayer player, int side, float hitX, float hitY, float hitZ)
{
return FluidUtility.playerActivatedFluidItem(world, x, y, z, player, side);
}
@SideOnly(Side.CLIENT)
@Override
public int getRenderType()
{
return BlockRenderingHandler.ID;
}
@Override
public TileEntity createNewTileEntity(World var1)
{
return new TilePlasmaHeater();
}
@Override
public boolean renderAsNormalBlock()
{
return false;
}
@Override
public boolean isOpaqueCube()
{
return false;
}
}

View file

@ -0,0 +1,114 @@
package resonantinduction.atomic.fusion;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.entity.player.InventoryPlayer;
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 resonantinduction.atomic.Atomic;
import resonantinduction.atomic.process.fission.TileNuclearBoiler;
/** Nuclear boiler container */
public class ContainerNuclearBoiler extends ContainerBase
{
private static final int slotCount = 4;
private TileNuclearBoiler tileEntity;
public ContainerNuclearBoiler(InventoryPlayer par1InventoryPlayer, TileNuclearBoiler tileEntity)
{
super(tileEntity);
this.tileEntity = tileEntity;
// Battery
this.addSlotToContainer(new SlotEnergyItem(tileEntity, 0, 56, 26));
// Water Input
this.addSlotToContainer(new Slot(tileEntity, 1, 25, 50));
// Gas Output
this.addSlotToContainer(new Slot(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();
}
@Override
public boolean canInteractWith(EntityPlayer par1EntityPlayer)
{
return this.tileEntity.isUseableByPlayer(par1EntityPlayer);
}
/** Called to transfer a stack from one inventory to the other eg. when shift clicking. */
@Override
public ItemStack transferStackInSlot(EntityPlayer par1EntityPlayer, int slotID)
{
ItemStack var2 = null;
Slot slot = (Slot) this.inventorySlots.get(slotID);
if (slot != null && slot.getHasStack())
{
ItemStack itemStack = slot.getStack();
var2 = itemStack.copy();
if (slotID >= slotCount)
{
if (this.getSlot(0).isItemValid(itemStack))
{
if (!this.mergeItemStack(itemStack, 0, 1, false))
{
return null;
}
}
else if (Atomic.FLUIDSTACK_WATER.isFluidEqual(FluidContainerRegistry.getFluidForFilledItem(itemStack)))
{
if (!this.mergeItemStack(itemStack, 1, 2, false))
{
return null;
}
}
else if (this.getSlot(3).isItemValid(itemStack))
{
if (!this.mergeItemStack(itemStack, 3, 4, false))
{
return null;
}
}
else if (slotID < 27 + slotCount)
{
if (!this.mergeItemStack(itemStack, 27 + slotCount, 36 + slotCount, false))
{
return null;
}
}
else if (slotID >= 27 + slotCount && slotID < 36 + slotCount && !this.mergeItemStack(itemStack, 4, 30, false))
{
return null;
}
}
else if (!this.mergeItemStack(itemStack, slotCount, 36 + slotCount, false))
{
return null;
}
if (itemStack.stackSize == 0)
{
slot.putStack((ItemStack) null);
}
else
{
slot.onSlotChanged();
}
if (itemStack.stackSize == var2.stackSize)
{
return null;
}
slot.onPickupFromSlot(par1EntityPlayer, itemStack);
}
return var2;
}
}

View file

@ -0,0 +1,45 @@
package resonantinduction.atomic.fusion;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.ResourceLocation;
import net.minecraftforge.client.model.AdvancedModelLoader;
import net.minecraftforge.client.model.IModelCustom;
import org.lwjgl.opengl.GL11;
import resonant.lib.render.RenderTaggedTile;
import resonantinduction.atomic.Atomic;
import resonantinduction.core.Reference;
import cpw.mods.fml.relauncher.Side;
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");
@Override
public void renderTileEntityAt(TileEntity t, double x, double y, double z, float f)
{
TilePlasmaHeater tileEntity = (TilePlasmaHeater) t;
if (tileEntity.worldObj != null)
{
super.renderTileEntityAt(t, x, y, z, f);
}
GL11.glPushMatrix();
GL11.glTranslated(x + 0.5, y + 0.5, z + 0.5);
bindTexture(TEXTURE);
GL11.glPushMatrix();
GL11.glRotated(Math.toDegrees(tileEntity.rotation), 0, 1, 0);
MODEL.renderOnly("rrot", "srot");
GL11.glPopMatrix();
MODEL.renderAllExcept("rrot", "srot");
GL11.glPopMatrix();
}
}

View file

@ -0,0 +1,101 @@
package resonantinduction.atomic.fusion;
import java.util.List;
import net.minecraft.client.renderer.texture.IconRegister;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.item.ItemStack;
import net.minecraft.util.Icon;
import net.minecraft.world.IBlockAccess;
import resonant.api.IElectromagnet;
import resonant.lib.content.module.TileBase;
import resonant.lib.content.module.TileRender;
import resonant.lib.utility.ConnectedTextureRenderer;
import resonant.lib.prefab.item.ItemBlockMetadata;
import resonantinduction.core.Reference;
import universalelectricity.api.UniversalElectricity;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
/** Electromagnet block */
public class TileElectromagnet extends TileBase implements IElectromagnet
{
private static Icon iconTop, iconGlass;
public TileElectromagnet()
{
super(UniversalElectricity.machine);
blockResistance = 20;
isOpaqueCube = false;
itemBlock = ItemBlockMetadata.class;
}
@Override
public Icon getIcon(int side, int metadata)
{
if (metadata == 1)
{
return iconGlass;
}
if (side == 0 || side == 1)
{
return iconTop;
}
return super.getIcon(side, metadata);
}
@SideOnly(Side.CLIENT)
@Override
public void registerIcons(IconRegister iconRegister)
{
super.registerIcons(iconRegister);
iconTop = iconRegister.registerIcon(domain + textureName + "_top");
iconGlass = iconRegister.registerIcon(domain + "electromagnetGlass");
}
@Override
public int metadataDropped(int meta, int fortune)
{
return meta;
}
@Override
public boolean canUpdate()
{
return false;
}
@Override
public boolean shouldSideBeRendered(IBlockAccess access, int x, int y, int z, int side)
{
return true; // access.getBlockId(x, y, z) == blockID() && access.getBlockMetadata(x, y, z) == 1 ? false : super.shouldSideBeRendered(access, x, y, z, side);
}
@Override
public int getRenderBlockPass()
{
return 0;
}
@Override
public void getSubBlocks(int par1, CreativeTabs par2CreativeTabs, List par3List)
{
par3List.add(new ItemStack(par1, 1, 0));
par3List.add(new ItemStack(par1, 1, 1));
}
@Override
public boolean isRunning()
{
return true;
}
@SideOnly(Side.CLIENT)
@Override
protected TileRender newRenderer()
{
return new ConnectedTextureRenderer(this, Reference.PREFIX + "atomic_edge");
}
}

View file

@ -0,0 +1,112 @@
package resonantinduction.atomic.fusion;
import java.util.ArrayList;
import net.minecraft.block.Block;
import net.minecraft.block.material.Material;
import net.minecraft.entity.Entity;
import net.minecraft.item.ItemStack;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.DamageSource;
import net.minecraft.world.IBlockAccess;
import net.minecraftforge.common.ForgeDirection;
import net.minecraftforge.common.MinecraftForge;
import resonant.api.event.PlasmaEvent.SpawnPlasmaEvent;
import resonant.lib.config.Config;
import resonant.lib.content.module.TileBase;
import resonant.lib.prefab.vector.Cuboid;
import resonant.lib.thermal.ThermalGrid;
import universalelectricity.api.vector.Vector3;
import universalelectricity.api.vector.VectorWorld;
public class TilePlasma extends TileBase
{
@Config
public static int plasmaMaxTemperature = 1000000;
private float temperature = plasmaMaxTemperature;
public TilePlasma()
{
super(Material.lava);
textureName = "plasma";
isOpaqueCube = false;
}
@Override
public int getLightValue(IBlockAccess access)
{
return 7;
}
@Override
public boolean isSolid(IBlockAccess access, int side)
{
return false;
}
@Override
public Iterable<Cuboid> getCollisionBoxes()
{
return new ArrayList();
}
@Override
public ArrayList<ItemStack> getDrops(int metadata, int fortune)
{
return new ArrayList<ItemStack>();
}
@Override
public int getRenderBlockPass()
{
return 1;
}
@Override
public void collide(Entity entity)
{
entity.attackEntityFrom(DamageSource.inFire, 100);
}
@Override
public void updateEntity()
{
super.updateEntity();
ThermalGrid.addTemperature(new VectorWorld(this), (temperature - ThermalGrid.getTemperature(new VectorWorld(this))) * 0.1f);
if (ticks % 20 == 0)
{
temperature /= 1.5;
if (temperature <= plasmaMaxTemperature / 10)
{
worldObj.setBlock(xCoord, yCoord, zCoord, Block.fire.blockID, 0, 3);
return;
}
for (int i = 0; i < 6; i++)
{
// Randomize spread direction.
if (worldObj.rand.nextFloat() > 0.4)
{
continue;
}
Vector3 diDian = new Vector3(this);
diDian.translate(ForgeDirection.getOrientation(i));
TileEntity tileEntity = diDian.getTileEntity(worldObj);
if (!(tileEntity instanceof TilePlasma))
{
MinecraftForge.EVENT_BUS.post(new SpawnPlasmaEvent(worldObj, diDian.intX(), diDian.intY(), diDian.intZ(), (int) temperature));
}
}
}
}
public void setTemperature(int newTemperature)
{
temperature = newTemperature;
}
}

View file

@ -0,0 +1,225 @@
package resonantinduction.atomic.fusion;
import java.util.HashMap;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.network.packet.Packet;
import net.minecraftforge.common.ForgeDirection;
import net.minecraftforge.fluids.Fluid;
import net.minecraftforge.fluids.FluidContainerRegistry;
import net.minecraftforge.fluids.FluidStack;
import net.minecraftforge.fluids.FluidTank;
import net.minecraftforge.fluids.FluidTankInfo;
import net.minecraftforge.fluids.IFluidHandler;
import resonant.api.ITagRender;
import resonant.lib.config.Config;
import resonant.lib.network.IPacketReceiver;
import resonant.lib.network.PacketHandler;
import resonant.lib.prefab.tile.TileElectrical;
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.vector.Vector3;
import com.google.common.io.ByteArrayDataInput;
public class TilePlasmaHeater extends TileElectrical implements IPacketReceiver, ITagRender, IFluidHandler
{
public static final long DIAN = 10000000000L;
@Config
public static final int plasmaHeatAmount = 100;
public final FluidTank tankInputDeuterium = new FluidTank(FluidContainerRegistry.BUCKET_VOLUME * 10);
public final FluidTank tankInputTritium = new FluidTank(FluidContainerRegistry.BUCKET_VOLUME * 10);
public final FluidTank tankOutput = new FluidTank(FluidContainerRegistry.BUCKET_VOLUME * 10);
public float rotation = 0;
public TilePlasmaHeater()
{
energy = new EnergyStorageHandler(DIAN, DIAN / 20);
}
@Override
public long onReceiveEnergy(ForgeDirection from, long receive, boolean doReceive)
{
if (tankInputDeuterium.getFluidAmount() > 0 && tankInputTritium.getFluidAmount() > 0)
{
return super.onReceiveEnergy(from, receive, doReceive);
}
return 0;
}
@Override
public void updateEntity()
{
super.updateEntity();
rotation += energy.getEnergy() / 10000f;
if (!worldObj.isRemote)
{
if (energy.checkExtract())
{
if (tankInputDeuterium.getFluidAmount() >= plasmaHeatAmount && tankInputTritium.getFluidAmount() >= plasmaHeatAmount)
{
tankInputDeuterium.drain(plasmaHeatAmount, true);
tankInputTritium.drain(plasmaHeatAmount, true);
tankOutput.fill(new FluidStack(Atomic.FLUID_PLASMA, plasmaHeatAmount), true);
energy.extractEnergy();
}
}
}
if (ticks % 80 == 0)
{
PacketHandler.sendPacketToClients(getDescriptionPacket(), worldObj, new Vector3(this), 25);
}
}
@Override
public Packet getDescriptionPacket()
{
NBTTagCompound nbt = new NBTTagCompound();
writeToNBT(nbt);
return ResonantInduction.PACKET_TILE.getPacket(this, nbt);
}
@Override
public void onReceivePacket(ByteArrayDataInput data, EntityPlayer player, Object... extra)
{
try
{
readFromNBT(PacketHandler.readNBTTagCompound(data));
}
catch (Exception e)
{
e.printStackTrace();
}
}
/** Reads a tile entity from NBT. */
@Override
public void readFromNBT(NBTTagCompound nbt)
{
super.readFromNBT(nbt);
NBTTagCompound deuterium = nbt.getCompoundTag("tankInputDeuterium");
tankInputDeuterium.setFluid(FluidStack.loadFluidStackFromNBT(deuterium));
NBTTagCompound tritium = nbt.getCompoundTag("tankInputTritium");
tankInputTritium.setFluid(FluidStack.loadFluidStackFromNBT(tritium));
NBTTagCompound output = nbt.getCompoundTag("tankOutput");
tankOutput.setFluid(FluidStack.loadFluidStackFromNBT(output));
}
/** Writes a tile entity to NBT. */
@Override
public void writeToNBT(NBTTagCompound nbt)
{
super.writeToNBT(nbt);
if (tankInputDeuterium.getFluid() != null)
{
NBTTagCompound compound = new NBTTagCompound();
tankInputDeuterium.getFluid().writeToNBT(compound);
nbt.setTag("tankInputDeuterium", compound);
}
if (tankInputTritium.getFluid() != null)
{
NBTTagCompound compound = new NBTTagCompound();
tankInputTritium.getFluid().writeToNBT(compound);
nbt.setTag("tankInputTritium", compound);
}
if (tankOutput.getFluid() != null)
{
NBTTagCompound compound = new NBTTagCompound();
tankOutput.getFluid().writeToNBT(compound);
nbt.setTag("tankOutput", compound);
}
}
@Override
public float addInformation(HashMap<String, Integer> map, EntityPlayer player)
{
if (energy != null)
{
map.put(LanguageUtility.getLocal("tooltip.energy") + ": " + UnitDisplay.getDisplay(energy.getEnergy(), Unit.JOULES), 0xFFFFFF);
}
if (tankInputDeuterium.getFluidAmount() > 0)
{
map.put(LanguageUtility.getLocal("fluid.deuterium") + ": " + tankInputDeuterium.getFluidAmount() + " L", 0xFFFFFF);
}
if (tankInputTritium.getFluidAmount() > 0)
{
map.put(LanguageUtility.getLocal("fluid.tritium") + ": " + tankInputTritium.getFluidAmount() + " L", 0xFFFFFF);
}
if (tankOutput.getFluidAmount() > 0)
{
map.put(LanguageUtility.getLocal("fluid.plasma") + ": " + tankOutput.getFluidAmount() + " L", 0xFFFFFF);
}
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)
{
if (resource.isFluidEqual(Atomic.FLUIDSTACK_DEUTERIUM))
{
return tankInputDeuterium.fill(resource, doFill);
}
if (resource.isFluidEqual(Atomic.FLUIDSTACK_TRITIUM))
{
return tankInputTritium.fill(resource, doFill);
}
return 0;
}
@Override
public FluidStack drain(ForgeDirection from, FluidStack resource, boolean doDrain)
{
return drain(from, resource.amount, doDrain);
}
@Override
public FluidStack drain(ForgeDirection from, int maxDrain, boolean doDrain)
{
return tankOutput.drain(maxDrain, doDrain);
}
@Override
public boolean canFill(ForgeDirection from, Fluid fluid)
{
return fluid.getID() == Atomic.FLUID_DEUTERIUM.getID() || fluid.getID() == Atomic.FLUID_TRITIUM.getID();
}
@Override
public boolean canDrain(ForgeDirection from, Fluid fluid)
{
return fluid == Atomic.FLUID_PLASMA;
}
@Override
public FluidTankInfo[] getTankInfo(ForgeDirection from)
{
return new FluidTankInfo[]
{ tankInputDeuterium.getInfo(), tankInputTritium.getInfo(), tankOutput.getInfo() };
}
}

View file

@ -0,0 +1,37 @@
package resonantinduction.atomic.particle.accelerator;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.world.World;
import resonant.lib.prefab.block.BlockRotatable;
import resonantinduction.atomic.Atomic;
import universalelectricity.api.UniversalElectricity;
/** Accelerator block */
public class BlockAccelerator extends BlockRotatable
{
public BlockAccelerator(int id)
{
super(id, UniversalElectricity.machine);
}
@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;
}
@Override
public TileEntity createNewTileEntity(World var1)
{
return new TileAccelerator();
}
}

View file

@ -0,0 +1,79 @@
package resonantinduction.atomic.particle.accelerator;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.entity.player.InventoryPlayer;
import net.minecraft.inventory.Slot;
import net.minecraft.inventory.SlotFurnace;
import net.minecraft.item.ItemStack;
import resonant.lib.gui.ContainerBase;
import resonantinduction.atomic.Atomic;
/** Accelerator container */
public class ContainerAccelerator extends ContainerBase
{
private TileAccelerator tileEntity;
public ContainerAccelerator(InventoryPlayer par1InventoryPlayer, TileAccelerator tileEntity)
{
super(tileEntity);
this.tileEntity = tileEntity;
// Inputs
addSlotToContainer(new Slot(tileEntity, 0, 132, 26));
addSlotToContainer(new Slot(tileEntity, 1, 132, 51));
// Output
addSlotToContainer(new SlotFurnace(par1InventoryPlayer.player, tileEntity, 2, 132, 75));
addSlotToContainer(new SlotFurnace(par1InventoryPlayer.player, tileEntity, 3, 106, 75));
addPlayerInventory(par1InventoryPlayer.player);
}
/** Called to transfer a stack from one inventory to the other eg. when shift clicking. */
@Override
public ItemStack transferStackInSlot(EntityPlayer par1EntityPlayer, int par1)
{
ItemStack var2 = null;
Slot var3 = (Slot) this.inventorySlots.get(par1);
if (var3 != null && var3.getHasStack())
{
ItemStack itemStack = var3.getStack();
var2 = itemStack.copy();
if (par1 > 2)
{
if (itemStack.itemID == Atomic.itemCell.itemID)
{
if (!this.mergeItemStack(itemStack, 1, 2, false))
{
return null;
}
}
else if (!this.mergeItemStack(itemStack, 0, 1, false))
{
return null;
}
}
else if (!this.mergeItemStack(itemStack, 3, 36 + 3, false))
{
return null;
}
if (itemStack.stackSize == 0)
{
var3.putStack((ItemStack) null);
}
else
{
var3.onSlotChanged();
}
if (itemStack.stackSize == var2.stackSize)
{
return null;
}
var3.onPickupFromSlot(par1EntityPlayer, itemStack);
}
return var2;
}
}

View file

@ -0,0 +1,326 @@
package resonantinduction.atomic.particle.accelerator;
import java.util.List;
import net.minecraft.entity.Entity;
import net.minecraft.entity.EntityLiving;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.AxisAlignedBB;
import net.minecraft.world.ChunkCoordIntPair;
import net.minecraft.world.World;
import net.minecraftforge.common.ForgeChunkManager;
import net.minecraftforge.common.ForgeChunkManager.Ticket;
import net.minecraftforge.common.ForgeChunkManager.Type;
import net.minecraftforge.common.ForgeDirection;
import resonant.api.IElectromagnet;
import resonant.lib.prefab.poison.PoisonRadiation;
import resonantinduction.atomic.Atomic;
import resonantinduction.core.Reference;
import universalelectricity.api.vector.Vector3;
import universalelectricity.api.vector.VectorHelper;
import com.google.common.io.ByteArrayDataInput;
import com.google.common.io.ByteArrayDataOutput;
import cpw.mods.fml.common.registry.IEntityAdditionalSpawnData;
/** The particle entity used to determine the particle acceleration. */
public class EntityParticle extends Entity implements IEntityAdditionalSpawnData
{
private static final int MOVE_TICK_RATE = 20;
public Ticket updateTicket;
public boolean didParticleCollide = false;
private int lastTurn = 60;
private Vector3 movementVector = new Vector3();
private ForgeDirection movementDirection = ForgeDirection.NORTH;
public EntityParticle(World par1World)
{
super(par1World);
this.setSize(0.3f, 0.3f);
this.renderDistanceWeight = 4f;
this.ignoreFrustumCheck = true;
}
public EntityParticle(World world, Vector3 pos, Vector3 movementVec, ForgeDirection dir)
{
this(world);
this.setPosition(pos.x, pos.y, pos.z);
this.movementVector = movementVec;
this.movementDirection = dir;
}
public static boolean canRenderAcceleratedParticle(World world, Vector3 pos)
{
if (pos.getBlockID(world) != 0)
{
return false;
}
for (int i = 0; i <= 1; i++)
{
ForgeDirection dir = ForgeDirection.getOrientation(i);
if (!isElectromagnet(world, pos, dir))
{
return false;
}
}
return true;
}
public static boolean isElectromagnet(World world, Vector3 position, ForgeDirection dir)
{
Vector3 checkPos = position.clone().translate(dir);
TileEntity tile = checkPos.getTileEntity(world);
if (tile instanceof IElectromagnet)
{
return ((IElectromagnet) tile).isRunning();
}
return false;
}
@Override
public void writeSpawnData(ByteArrayDataOutput data)
{
data.writeInt(this.movementVector.intX());
data.writeInt(this.movementVector.intY());
data.writeInt(this.movementVector.intZ());
data.writeInt(this.movementDirection.ordinal());
}
@Override
public void readSpawnData(ByteArrayDataInput data)
{
this.movementVector.x = data.readInt();
this.movementVector.y = data.readInt();
this.movementVector.z = data.readInt();
this.movementDirection = ForgeDirection.getOrientation(data.readInt());
}
@Override
protected void entityInit()
{
this.dataWatcher.addObject(MOVE_TICK_RATE, (byte) 3);
if (this.updateTicket == null)
{
this.updateTicket = ForgeChunkManager.requestTicket(Atomic.INSTANCE, this.worldObj, Type.ENTITY);
this.updateTicket.getModData();
this.updateTicket.bindEntity(this);
}
}
@Override
public void onUpdate()
{
/** Play sound fxs. */
if (this.ticksExisted % 10 == 0)
{
this.worldObj.playSoundAtEntity(this, Reference.PREFIX + "accelerator", 1f, (float) (0.6f + (0.4 * (this.getParticleVelocity() / TileAccelerator.clientParticleVelocity))));
}
/** Check if the accelerator tile entity exists. */
TileEntity t = this.worldObj.getBlockTileEntity(this.movementVector.intX(), this.movementVector.intY(), this.movementVector.intZ());
if (!(t instanceof TileAccelerator))
{
setDead();
return;
}
TileAccelerator tileEntity = (TileAccelerator) t;
if (tileEntity.entityParticle == null)
{
tileEntity.entityParticle = this;
}
for (int x = -1; x < 1; x++)
{
for (int z = -1; z < 1; z++)
{
ForgeChunkManager.forceChunk(this.updateTicket, new ChunkCoordIntPair(((int) this.posX >> 4) + x, ((int) this.posZ >> 4) + z));
}
}
try
{
if (!this.worldObj.isRemote)
{
this.dataWatcher.updateObject(MOVE_TICK_RATE, (byte) this.movementDirection.ordinal());
}
else
{
this.movementDirection = ForgeDirection.getOrientation(this.dataWatcher.getWatchableObjectByte(MOVE_TICK_RATE));
}
}
catch (Exception e)
{
e.printStackTrace();
}
double acceleration = 0.0006f;
if ((!isElectromagnet(worldObj, new Vector3(this), movementDirection.getRotation(ForgeDirection.UP)) || !isElectromagnet(worldObj, new Vector3(this), movementDirection.getRotation(ForgeDirection.DOWN))) && this.lastTurn <= 0)
{
acceleration = turn();
this.motionX = 0;
this.motionY = 0;
this.motionZ = 0;
this.lastTurn = 40;
}
this.lastTurn--;
/** Checks if the current block condition allows the particle to exist */
if (!canRenderAcceleratedParticle(this.worldObj, new Vector3(this)) || this.isCollided)
{
explode();
return;
}
Vector3 dongLi = new Vector3();
dongLi.translate(this.movementDirection);
dongLi.scale(acceleration);
this.motionX = Math.min(dongLi.x + this.motionX, TileAccelerator.clientParticleVelocity);
this.motionY = Math.min(dongLi.y + this.motionY, TileAccelerator.clientParticleVelocity);
this.motionZ = Math.min(dongLi.z + this.motionZ, TileAccelerator.clientParticleVelocity);
this.isAirBorne = true;
this.lastTickPosX = this.posX;
this.lastTickPosY = this.posY;
this.lastTickPosZ = this.posZ;
this.moveEntity(this.motionX, this.motionY, this.motionZ);
this.setPosition(this.posX, this.posY, this.posZ);
if (this.lastTickPosX == this.posX && this.lastTickPosY == this.posY && this.lastTickPosZ == this.posZ && this.getParticleVelocity() <= 0 && this.lastTurn <= 0)
{
this.setDead();
}
this.worldObj.spawnParticle("portal", this.posX, this.posY, this.posZ, 0, 0, 0);
this.worldObj.spawnParticle("largesmoke", this.posX, this.posY, this.posZ, 0, 0, 0);
float radius = 0.5f;
AxisAlignedBB bounds = AxisAlignedBB.getBoundingBox(this.posX - radius, this.posY - radius, this.posZ - radius, this.posX + radius, this.posY + radius, this.posZ + radius);
List<Entity> entitiesNearby = this.worldObj.getEntitiesWithinAABB(Entity.class, bounds);
if (entitiesNearby.size() > 1)
{
this.explode();
return;
}
}
/** Try to move the particle left or right depending on which side is empty.
*
* @return The new velocity. */
private double turn()
{
ForgeDirection zuoFangXiang = VectorHelper.getOrientationFromSide(this.movementDirection, ForgeDirection.EAST);
Vector3 zuoBian = new Vector3(this).floor();
zuoBian.translate(zuoFangXiang);
ForgeDirection youFangXiang = VectorHelper.getOrientationFromSide(this.movementDirection, ForgeDirection.WEST);
Vector3 youBian = new Vector3(this).floor();
youBian.translate(youFangXiang);
if (zuoBian.getBlockID(this.worldObj) == 0)
{
this.movementDirection = zuoFangXiang;
}
else if (youBian.getBlockID(this.worldObj) == 0)
{
this.movementDirection = youFangXiang;
}
else
{
setDead();
return 0;
}
this.setPosition(Math.floor(this.posX) + 0.5, Math.floor(this.posY) + 0.5, Math.floor(this.posZ) + 0.5);
return this.getParticleVelocity() - (this.getParticleVelocity() / Math.min(Math.max(70 * this.getParticleVelocity(), 4), 30));
}
public void explode()
{
this.worldObj.playSoundAtEntity(this, Reference.PREFIX + "antimatter", 1.5f, 1f - this.worldObj.rand.nextFloat() * 0.3f);
if (!this.worldObj.isRemote)
{
if (this.getParticleVelocity() > TileAccelerator.clientParticleVelocity / 2)
{
/* Check for nearby particles and if colliding with another one, drop strange matter. */
float radius = 1f;
AxisAlignedBB bounds = AxisAlignedBB.getBoundingBox(this.posX - radius, this.posY - radius, this.posZ - radius, this.posX + radius, this.posY + radius, this.posZ + radius);
List<EntityParticle> entitiesNearby = this.worldObj.getEntitiesWithinAABB(EntityParticle.class, bounds);
if (entitiesNearby.size() > 0)
{
didParticleCollide = true;
setDead();
return;
}
}
this.worldObj.createExplosion(this, this.posX, this.posY, this.posZ, (float) this.getParticleVelocity() * 2.5f, true);
}
float radius = 6;
AxisAlignedBB bounds = AxisAlignedBB.getBoundingBox(this.posX - radius, this.posY - radius, this.posZ - radius, this.posX + radius, this.posY + radius, this.posZ + radius);
List<EntityLiving> livingNearby = this.worldObj.getEntitiesWithinAABB(EntityLiving.class, bounds);
for (EntityLiving entity : livingNearby)
{
PoisonRadiation.INSTANCE.poisonEntity(new Vector3(entity), entity);
}
setDead();
}
public double getParticleVelocity()
{
return Math.abs(this.motionX) + Math.abs(this.motionY) + Math.abs(this.motionZ);
}
@Override
public void applyEntityCollision(Entity par1Entity)
{
this.explode();
}
@Override
public void setDead()
{
ForgeChunkManager.releaseTicket(this.updateTicket);
super.setDead();
}
@Override
protected void readEntityFromNBT(NBTTagCompound nbt)
{
this.movementVector = new Vector3(nbt.getCompoundTag("jiqi"));
ForgeDirection.getOrientation(nbt.getByte("fangXiang"));
}
@Override
protected void writeEntityToNBT(NBTTagCompound nbt)
{
nbt.setTag("jiqi", this.movementVector.writeToNBT(new NBTTagCompound()));
nbt.setByte("fangXiang", (byte) this.movementDirection.ordinal());
}
}

View file

@ -0,0 +1,69 @@
package resonantinduction.atomic.particle.accelerator;
import net.minecraft.entity.player.InventoryPlayer;
import resonant.lib.gui.GuiContainerBase;
import universalelectricity.api.energy.UnitDisplay;
import universalelectricity.api.energy.UnitDisplay.Unit;
import universalelectricity.api.vector.Vector3;
public class GuiAccelerator extends GuiContainerBase
{
private TileAccelerator tileEntity;
private int containerWidth;
private int containerHeight;
public GuiAccelerator(InventoryPlayer par1InventoryPlayer, TileAccelerator tileEntity)
{
super(new ContainerAccelerator(par1InventoryPlayer, tileEntity));
this.tileEntity = tileEntity;
}
/** Draw the foreground layer for the GuiContainer (everything in front of the items) */
@Override
public void drawGuiContainerForegroundLayer(int x, int y)
{
this.fontRenderer.drawString(tileEntity.getInvName(), 40, 10, 4210752);
String status = "";
Vector3 position = new Vector3(this.tileEntity);
position.translate(this.tileEntity.getDirection().getOpposite());
if (!EntityParticle.canRenderAcceleratedParticle(this.tileEntity.worldObj, position))
{
status = "\u00a74Fail to emit; try rotating.";
}
else if (this.tileEntity.entityParticle != null && this.tileEntity.velocity > 0)
{
status = "\u00a76Accelerating";
}
else
{
status = "\u00a72Idle";
}
this.fontRenderer.drawString("Velocity: " + Math.round((this.tileEntity.velocity / TileAccelerator.clientParticleVelocity) * 100) + "%", 8, 27, 4210752);
this.fontRenderer.drawString("Energy Used:", 8, 38, 4210752);
this.fontRenderer.drawString(UnitDisplay.getDisplay(this.tileEntity.totalEnergyConsumed, Unit.JOULES), 8, 49, 4210752);
this.fontRenderer.drawString(UnitDisplay.getDisplay(TileAccelerator.energyPerTick * 20, Unit.WATT), 8, 60, 4210752);
this.fontRenderer.drawString(UnitDisplay.getDisplay(this.tileEntity.getVoltageInput(null), Unit.VOLTAGE), 8, 70, 4210752);
this.fontRenderer.drawString("Antimatter: " + this.tileEntity.antimatter + " mg", 8, 80, 4210752);
this.fontRenderer.drawString("Status:", 8, 90, 4210752);
this.fontRenderer.drawString(status, 8, 100, 4210752);
this.fontRenderer.drawString("Buffer: " + UnitDisplay.getDisplayShort(this.tileEntity.getEnergyHandler().getEnergy(), Unit.JOULES) + "/" + UnitDisplay.getDisplayShort(this.tileEntity.getEnergyHandler().getEnergyCapacity(), Unit.JOULES), 8, 110,
4210752);
this.fontRenderer.drawString("Facing: " + this.tileEntity.getDirection().getOpposite(), 100, 123, 4210752);
}
/** Draw the background layer for the GuiContainer (everything behind the items) */
@Override
protected void drawGuiContainerBackgroundLayer(float par1, int x, int y)
{
super.drawGuiContainerBackgroundLayer(par1, x, y);
this.drawSlot(131, 25);
this.drawSlot(131, 50);
this.drawSlot(131, 74);
this.drawSlot(105, 74);
}
}

View file

@ -0,0 +1,12 @@
package resonantinduction.atomic.particle.accelerator;
import resonantinduction.atomic.base.ItemCell;
/** Strange matter cell */
public class ItemDarkMatter extends ItemCell
{
public ItemDarkMatter(int itemID)
{
super(itemID);
}
}

View file

@ -0,0 +1,95 @@
package resonantinduction.atomic.particle.accelerator;
import java.util.Random;
import net.minecraft.client.renderer.RenderHelper;
import net.minecraft.client.renderer.Tessellator;
import net.minecraft.client.renderer.entity.Render;
import net.minecraft.entity.Entity;
import net.minecraft.util.ResourceLocation;
import org.lwjgl.opengl.GL11;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
@SideOnly(Side.CLIENT)
public class RenderParticle extends Render
{
@Override
public void doRender(Entity entity, double x, double y, double z, float var8, float var9)
{
Tessellator tessellator = Tessellator.instance;
/** Enderdragon Light */
float par2 = (entity.ticksExisted);
while (par2 > 200)
{
par2 -= 100;
}
RenderHelper.disableStandardItemLighting();
float var41 = (5 + par2) / 200.0F;
float var51 = 0.0F;
if (var41 > 0.8F)
{
var51 = (var41 - 0.8F) / 0.2F;
}
Random rand = new Random(432L);
GL11.glPushMatrix();
GL11.glTranslatef((float) x, (float) y, (float) z);
GL11.glScalef(0.15f, 0.15f, 0.15f);
GL11.glDisable(GL11.GL_TEXTURE_2D);
GL11.glShadeModel(GL11.GL_SMOOTH);
GL11.glEnable(GL11.GL_BLEND);
GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE);
GL11.glDisable(GL11.GL_ALPHA_TEST);
GL11.glEnable(GL11.GL_CULL_FACE);
GL11.glDepthMask(false);
GL11.glPushMatrix();
GL11.glTranslatef(0.0F, -1.0F, -2.0F);
for (int i1 = 0; i1 < (var41 + var41 * var41) / 2.0F * 60.0F; ++i1)
{
GL11.glRotatef(rand.nextFloat() * 360.0F, 1.0F, 0.0F, 0.0F);
GL11.glRotatef(rand.nextFloat() * 360.0F, 0.0F, 1.0F, 0.0F);
GL11.glRotatef(rand.nextFloat() * 360.0F, 0.0F, 0.0F, 1.0F);
GL11.glRotatef(rand.nextFloat() * 360.0F, 1.0F, 0.0F, 0.0F);
GL11.glRotatef(rand.nextFloat() * 360.0F, 0.0F, 1.0F, 0.0F);
GL11.glRotatef(rand.nextFloat() * 360.0F + var41 * 90.0F, 0.0F, 0.0F, 1.0F);
tessellator.startDrawing(6);
float var81 = rand.nextFloat() * 20.0F + 5.0F + var51 * 10.0F;
float var91 = rand.nextFloat() * 2.0F + 1.0F + var51 * 2.0F;
tessellator.setColorRGBA_I(16777215, (int) (255.0F * (1.0F - var51)));
tessellator.addVertex(0.0D, 0.0D, 0.0D);
tessellator.setColorRGBA_I(0, 0);
tessellator.addVertex(-0.866D * var91, var81, -0.5F * var91);
tessellator.addVertex(0.866D * var91, var81, -0.5F * var91);
tessellator.addVertex(0.0D, var81, 1.0F * var91);
tessellator.addVertex(-0.866D * var91, var81, -0.5F * var91);
tessellator.draw();
}
GL11.glPopMatrix();
GL11.glDepthMask(true);
GL11.glDisable(GL11.GL_CULL_FACE);
GL11.glDisable(GL11.GL_BLEND);
GL11.glShadeModel(GL11.GL_FLAT);
GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
GL11.glEnable(GL11.GL_TEXTURE_2D);
GL11.glEnable(GL11.GL_ALPHA_TEST);
RenderHelper.enableStandardItemLighting();
GL11.glPopMatrix();
}
@Override
protected ResourceLocation getEntityTexture(Entity entity)
{
return null;
}
}

View file

@ -0,0 +1,358 @@
package resonantinduction.atomic.particle.accelerator;
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.minecraft.network.packet.Packet;
import net.minecraftforge.common.ForgeDirection;
import resonant.api.IElectromagnet;
import resonant.api.IRotatable;
import resonant.lib.network.Synced;
import resonant.lib.prefab.tile.TileElectricalInventory;
import resonantinduction.atomic.Atomic;
import resonantinduction.atomic.particle.fulmination.ItemAntimatter;
import resonantinduction.core.Reference;
import resonantinduction.core.ResonantInduction;
import resonantinduction.core.Settings;
import universalelectricity.api.electricity.IVoltageInput;
import universalelectricity.api.energy.EnergyStorageHandler;
import universalelectricity.api.energy.IEnergyInterface;
import universalelectricity.api.vector.Vector3;
import cpw.mods.fml.common.network.PacketDispatcher;
import cpw.mods.fml.common.network.Player;
/** Accelerator TileEntity */
public class TileAccelerator extends TileElectricalInventory implements IElectromagnet, IRotatable, IInventory, ISidedInventory, IVoltageInput
{
/** Joules required per ticks. */
public static final int energyPerTick = 4800000;
/** User client side to determine the velocity of the particle. */
public static final float clientParticleVelocity = 0.9f;
/** The total amount of energy consumed by this particle. In Joules. */
@Synced
public float totalEnergyConsumed = 0;
/** The amount of anti-matter stored within the accelerator. Measured in milligrams. */
@Synced
public int antimatter;
public EntityParticle entityParticle;
@Synced
public float velocity;
@Synced
private long clientEnergy = 0;
private int lastSpawnTick = 0;
/** Multiplier that is used to give extra anti-matter based on density (hardness) of a given ore. */
private int antiMatterDensityMultiplyer = DENSITY_MULTIPLYER_DEFAULT;
private static final int DENSITY_MULTIPLYER_DEFAULT = 1;
public TileAccelerator()
{
energy = new EnergyStorageHandler(energyPerTick * 2, energyPerTick / 20);
maxSlots = 4;
antiMatterDensityMultiplyer = DENSITY_MULTIPLYER_DEFAULT;
}
@Override
public boolean canConnect(ForgeDirection direction, Object obj)
{
return obj instanceof IEnergyInterface;
}
@Override
public long onReceiveEnergy(ForgeDirection from, long receive, boolean doReceive)
{
if (doReceive)
{
totalEnergyConsumed += receive;
}
if (getStackInSlot(0) != null && (worldObj.isBlockIndirectlyGettingPowered(xCoord, yCoord, zCoord) || worldObj.getBlockPowerInput(xCoord, yCoord, zCoord) > 0))
{
return super.onReceiveEnergy(from, receive, doReceive);
}
return 0;
}
@Override
public void updateEntity()
{
super.updateEntity();
if (!worldObj.isRemote)
{
clientEnergy = energy.getEnergy();
velocity = 0;
// Calculate accelerated particle velocity if it is spawned.
if (entityParticle != null)
{
velocity = (float) entityParticle.getParticleVelocity();
}
// Check if item inside of empty cell slot is indeed an empty slot.
if (Atomic.isItemStackEmptyCell(getStackInSlot(1)))
{
// Check if there are any empty cells we can store anti-matter in.
if (getStackInSlot(1).stackSize > 0)
{
// Craft anti-matter item if there is enough anti-matter to actually do so.
if (antimatter >= 125)
{
if (getStackInSlot(2) != null)
{
// Increase the existing amount of anti-matter if stack already exists.
if (getStackInSlot(2).itemID == Atomic.itemAntimatter.itemID)
{
ItemStack newStack = getStackInSlot(2).copy();
if (newStack.stackSize < newStack.getMaxStackSize())
{
// Remove an empty cell which we will put the anti-matter into.
decrStackSize(1, 1);
// Remove anti-matter from internal reserve and increase stack count.
antimatter -= 125;
newStack.stackSize++;
setInventorySlotContents(2, newStack);
}
}
}
else
{
// Remove some of the internal reserves of anti-matter and use it to craft an individual item.
antimatter -= 125;
decrStackSize(1, 1);
setInventorySlotContents(2, new ItemStack(Atomic.itemAntimatter));
}
}
}
}
// Check if redstone signal is currently being applied.
if (worldObj.isBlockIndirectlyGettingPowered(xCoord, yCoord, zCoord))
{
if (energy.checkExtract())
{
if (entityParticle == null)
{
// Creates a accelerated particle if one needs to exist (on world load for example or player login).
if (getStackInSlot(0) != null && lastSpawnTick >= 40)
{
Vector3 spawnAcceleratedParticle = new Vector3(this);
spawnAcceleratedParticle.translate(getDirection().getOpposite());
spawnAcceleratedParticle.translate(0.5f);
// Only render the particle if container within the proper environment for it.
if (EntityParticle.canRenderAcceleratedParticle(worldObj, spawnAcceleratedParticle))
{
// Spawn the particle.
totalEnergyConsumed = 0;
entityParticle = new EntityParticle(worldObj, spawnAcceleratedParticle, new Vector3(this), getDirection().getOpposite());
worldObj.spawnEntityInWorld(entityParticle);
// Grabs input block hardness if available, otherwise defaults are used.
CalculateParticleDensity();
// Decrease particle we want to collide.
decrStackSize(0, 1);
lastSpawnTick = 0;
}
}
}
else
{
if (entityParticle.isDead)
{
// On particle collision we roll the dice to see if dark-matter is generated.
if (entityParticle.didParticleCollide)
{
if (worldObj.rand.nextFloat() <= Settings.darkMatterSpawnChance)
{
incrStackSize(3, new ItemStack(Atomic.itemDarkMatter));
}
}
entityParticle = null;
}
else if (velocity > clientParticleVelocity)
{
// Play sound of anti-matter being created.
worldObj.playSoundEffect(xCoord, yCoord, zCoord, Reference.PREFIX + "antimatter", 2f, 1f - worldObj.rand.nextFloat() * 0.3f);
// Create anti-matter in the internal reserve.
int generatedAntimatter = 5 + worldObj.rand.nextInt(antiMatterDensityMultiplyer);
antimatter += generatedAntimatter;
// AtomicScience.LOGGER.info("[Particle Accelerator] Generated " + String.valueOf(generatedAntimatter) + " mg of anti-matter.");
// Reset energy consumption levels and destroy accelerated particle.
totalEnergyConsumed = 0;
entityParticle.setDead();
entityParticle = null;
}
// Plays sound of particle accelerating past the speed based on total velocity at the time of anti-matter creation.
if (entityParticle != null)
{
worldObj.playSoundEffect(xCoord, yCoord, zCoord, Reference.PREFIX + "accelerator", 1.5f, (float) (0.6f + (0.4 * (entityParticle.getParticleVelocity()) / TileAccelerator.clientParticleVelocity)));
}
}
energy.extractEnergy();
}
else
{
if (entityParticle != null)
{
entityParticle.setDead();
}
entityParticle = null;
}
}
else
{
if (entityParticle != null)
{
entityParticle.setDead();
}
entityParticle = null;
}
if (ticks % 5 == 0)
{
for (EntityPlayer player : getPlayersUsing())
{
PacketDispatcher.sendPacketToPlayer(getDescriptionPacket(), (Player) player);
}
}
lastSpawnTick++;
}
}
private void CalculateParticleDensity()
{
ItemStack itemToAccelerate = this.getStackInSlot(0);
if (itemToAccelerate != null)
{
// Calculate block density multiplier if ore dictionary block.
antiMatterDensityMultiplyer = DENSITY_MULTIPLYER_DEFAULT;
try
{
Block potentialBlock = Block.blocksList[itemToAccelerate.getItem().itemID];
if (potentialBlock != null)
{
// Prevent negative numbers and disallow zero for density multiplier.
antiMatterDensityMultiplyer = (int) Math.abs(potentialBlock.blockHardness);
if (antiMatterDensityMultiplyer <= 0)
{
antiMatterDensityMultiplyer = 1;
}
// AtomicScience.LOGGER.info("[Particle Accelerator] " + String.valueOf(potentialBlock.getUnlocalizedName()) + " Hardness: " + String.valueOf(antiMatterDensityMultiplyer));
}
}
catch (Exception err)
{
antiMatterDensityMultiplyer = DENSITY_MULTIPLYER_DEFAULT;
// AtomicScience.LOGGER.info("[Particle Accelerator] Attempted to query Minecraft block-list with value out of index.");
}
}
}
@Override
public Packet getDescriptionPacket()
{
return ResonantInduction.PACKET_ANNOTATION.getPacket(this);
}
/** Reads a tile entity from NBT. */
@Override
public void readFromNBT(NBTTagCompound par1NBTTagCompound)
{
super.readFromNBT(par1NBTTagCompound);
totalEnergyConsumed = par1NBTTagCompound.getFloat("totalEnergyConsumed");
antimatter = par1NBTTagCompound.getInteger("antimatter");
}
/** Writes a tile entity to NBT. */
@Override
public void writeToNBT(NBTTagCompound par1NBTTagCompound)
{
super.writeToNBT(par1NBTTagCompound);
par1NBTTagCompound.setFloat("totalEnergyConsumed", totalEnergyConsumed);
par1NBTTagCompound.setInteger("antimatter", antimatter);
}
@Override
public long getVoltageInput(ForgeDirection dir)
{
return 1000;
}
@Override
public int[] getAccessibleSlotsFromSide(int side)
{
return new int[]
{ 0, 1, 2, 3 };
}
@Override
public boolean canInsertItem(int slotID, ItemStack itemStack, int j)
{
return isItemValidForSlot(slotID, itemStack) && slotID != 2 && slotID != 3;
}
@Override
public boolean canExtractItem(int slotID, ItemStack itemstack, int j)
{
return slotID == 2 || slotID == 3;
}
@Override
public boolean isItemValidForSlot(int i, ItemStack itemStack)
{
switch (i)
{
case 0:
return true;
case 1:
return Atomic.isItemStackEmptyCell(itemStack);
case 2:
return itemStack.getItem() instanceof ItemAntimatter;
case 3:
return itemStack.getItem() instanceof ItemDarkMatter;
}
return false;
}
@Override
public long onExtractEnergy(ForgeDirection from, long extract, boolean doExtract)
{
return 0;
}
@Override
public void onWrongVoltage(ForgeDirection direction, long voltage)
{
}
@Override
public boolean isRunning()
{
return true;
}
}

View file

@ -0,0 +1,80 @@
package resonantinduction.atomic.particle.fulmination;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import net.minecraft.util.Vec3;
import net.minecraftforge.event.ForgeSubscribe;
import resonant.api.explosion.ExplosionEvent.DoExplosionEvent;
import resonantinduction.atomic.Atomic;
import universalelectricity.api.vector.Vector3;
/** Atomic Science Event Handling. */
public class FulminationHandler
{
public static final FulminationHandler INSTANCE = new FulminationHandler();
public static final List<TileFulmination> list = new ArrayList<TileFulmination>();
public void register(TileFulmination tileEntity)
{
if (!list.contains(tileEntity))
{
list.add(tileEntity);
}
}
public void unregister(TileFulmination tileEntity)
{
list.remove(tileEntity);
}
@ForgeSubscribe
public void BaoZha(DoExplosionEvent evt)
{
if (evt.iExplosion != null)
{
if (evt.iExplosion.getRadius() > 0 && evt.iExplosion.getEnergy() > 0)
{
HashSet<TileFulmination> avaliableGenerators = new HashSet<TileFulmination>();
for (TileFulmination tileEntity : FulminationHandler.list)
{
if (tileEntity != null)
{
if (!tileEntity.isInvalid())
{
Vector3 tileDiDian = new Vector3(tileEntity);
tileDiDian.translate(0.5f);
double juLi = tileDiDian.distance(new Vector3(evt.x, evt.y, evt.z));
if (juLi <= evt.iExplosion.getRadius() && juLi > 0)
{
float miDu = evt.world.getBlockDensity(Vec3.createVectorHelper(evt.x, evt.y, evt.z), Atomic.blockFulmination.getCollisionBoundingBoxFromPool(evt.world, tileEntity.xCoord, tileEntity.yCoord, tileEntity.zCoord));
if (miDu < 1)
{
avaliableGenerators.add(tileEntity);
}
}
}
}
}
final float totalEnergy = evt.iExplosion.getEnergy();
final float maxEnergyPerGenerator = totalEnergy / avaliableGenerators.size();
for (TileFulmination tileEntity : avaliableGenerators)
{
float density = evt.world.getBlockDensity(Vec3.createVectorHelper(evt.x, evt.y, evt.z), Atomic.blockFulmination.getCollisionBoundingBoxFromPool(evt.world, tileEntity.xCoord, tileEntity.yCoord, tileEntity.zCoord));
double juLi = new Vector3(tileEntity).distance(new Vector3(evt.x, evt.y, evt.z));
long energy = (long) Math.min(maxEnergyPerGenerator, maxEnergyPerGenerator / (juLi / evt.iExplosion.getRadius()));
energy = (long) Math.max((1 - density) * energy, 0);
tileEntity.getEnergyHandler().receiveEnergy(energy, true);
}
}
}
}
}

View file

@ -0,0 +1,144 @@
package resonantinduction.atomic.particle.fulmination;
import java.util.List;
import net.minecraft.client.renderer.texture.IconRegister;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.entity.Entity;
import net.minecraft.entity.EntityLiving;
import net.minecraft.item.ItemStack;
import net.minecraft.util.AxisAlignedBB;
import net.minecraft.util.Icon;
import net.minecraft.world.Explosion;
import net.minecraft.world.World;
import net.minecraftforge.common.MinecraftForge;
import net.minecraftforge.event.ForgeSubscribe;
import net.minecraftforge.event.entity.item.ItemExpireEvent;
import resonant.api.explosion.ExplosionEvent.DoExplosionEvent;
import resonant.api.explosion.IExplosion;
import resonant.lib.flag.FlagRegistry;
import resonant.lib.prefab.poison.PoisonRadiation;
import resonantinduction.atomic.Atomic;
import resonantinduction.atomic.base.ItemCell;
import resonantinduction.core.Reference;
import resonantinduction.core.ResonantInduction;
import resonantinduction.core.Settings;
import universalelectricity.api.vector.Vector3;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
/* Antimatter Cell */
public class ItemAntimatter extends ItemCell
{
private Icon iconGram;
public ItemAntimatter(int itemID)
{
super(itemID);
this.setMaxDamage(0);
this.setHasSubtypes(true);
}
@SideOnly(Side.CLIENT)
@Override
public void registerIcons(IconRegister iconRegister)
{
this.itemIcon = iconRegister.registerIcon(this.getUnlocalizedName().replace("item.", "") + "_milligram");
this.iconGram = iconRegister.registerIcon(this.getUnlocalizedName().replace("item.", "") + "_gram");
}
@Override
public Icon getIconFromDamage(int metadata)
{
if (metadata >= 1)
{
return this.iconGram;
}
else
{
return this.itemIcon;
}
}
@Override
public void getSubItems(int id, CreativeTabs par2CreativeTabs, List par3List)
{
par3List.add(new ItemStack(id, 1, 0));
par3List.add(new ItemStack(id, 1, 1));
}
@Override
public int getEntityLifespan(ItemStack itemStack, World world)
{
return 160;
}
@ForgeSubscribe
public void baoZhaEvent(ItemExpireEvent evt)
{
if (evt.entityItem != null)
{
ItemStack itemStack = evt.entityItem.getEntityItem();
if (itemStack != null)
{
if (itemStack.itemID == this.itemID)
{
evt.entityItem.worldObj.playSoundEffect(evt.entityItem.posX, evt.entityItem.posY, evt.entityItem.posZ, Reference.PREFIX + "antimatter", 3f, 1f - evt.entityItem.worldObj.rand.nextFloat() * 0.3f);
if (!evt.entityItem.worldObj.isRemote)
{
if (!FlagRegistry.getModFlag(FlagRegistry.DEFAULT_NAME).containsValue(evt.entityItem.worldObj, Atomic.BAN_ANTIMATTER_POWER, "true", new Vector3(evt.entityItem)))
{
IExplosion explosive = new BzFanWuSu(evt.entity.worldObj, evt.entityItem, evt.entityItem.posX, evt.entityItem.posY, evt.entityItem.posZ, 4, itemStack.getItemDamage());
MinecraftForge.EVENT_BUS.post(new DoExplosionEvent(evt.entityItem.worldObj, explosive));
evt.entityItem.worldObj.createExplosion(evt.entityItem, evt.entityItem.posX, evt.entityItem.posY, evt.entityItem.posZ, explosive.getRadius(), true);
ResonantInduction.LOGGER.fine("Antimatter cell detonated at: " + evt.entityItem.posX + ", " + evt.entityItem.posY + ", " + evt.entityItem.posZ);
final int radius = 20;
AxisAlignedBB bounds = AxisAlignedBB.getBoundingBox(evt.entityItem.posX - radius, evt.entityItem.posY - radius, evt.entityItem.posZ - radius, evt.entityItem.posX + radius, evt.entityItem.posY + radius, evt.entityItem.posZ
+ radius);
List<EntityLiving> entitiesNearby = evt.entityItem.worldObj.getEntitiesWithinAABB(EntityLiving.class, bounds);
for (EntityLiving entity : entitiesNearby)
{
PoisonRadiation.INSTANCE.poisonEntity(new Vector3(entity), entity);
}
}
}
}
}
}
}
public static class BzFanWuSu extends Explosion implements IExplosion
{
private int tier;
public BzFanWuSu(World par1World, Entity par2Entity, double x, double y, double z, float size, int tier)
{
super(par1World, par2Entity, x, y, z, size + 2 * tier);
this.tier = tier;
}
@Override
public float getRadius()
{
return this.explosionSize;
}
@Override
public long getEnergy()
{
return (long) ((2000000000000000L + (2000000000000000L * 9 * tier)) * Settings.fulminationOutputMultiplier);
}
@Override
public void explode()
{
this.doExplosionA();
this.doExplosionB(true);
}
}
}

View file

@ -0,0 +1,82 @@
package resonantinduction.atomic.particle.fulmination;
import java.util.EnumSet;
import net.minecraft.block.material.Material;
import net.minecraftforge.common.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;
/** Fulmination TileEntity */
public class TileFulmination extends TileElectrical implements IVoltageOutput
{
private static final long DIAN = 10000000000000L;
public TileFulmination()
{
super(Material.iron);
energy = new EnergyStorageHandler(DIAN);
blockHardness = 10;
blockResistance = 25000;
}
@Override
public void initiate()
{
super.initiate();
FulminationHandler.INSTANCE.register(this);
}
@Override
public void updateEntity()
{
super.updateEntity();
produce();
// Slowly lose energy.
energy.extractEnergy(1, true);
}
@Override
public void invalidate()
{
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");
}
}

View file

@ -0,0 +1,111 @@
package resonantinduction.atomic.particle.quantum;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.entity.player.InventoryPlayer;
import net.minecraft.inventory.Container;
import net.minecraft.inventory.Slot;
import net.minecraft.item.ItemStack;
import resonantinduction.atomic.Atomic;
/* Atomic assembler container */
public class ContainerQuantumAssembler extends Container
{
private TileQuantumAssembler tileEntity;
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));
int var3;
for (var3 = 0; var3 < 3; ++var3)
{
for (int var4 = 0; var4 < 9; ++var4)
{
this.addSlotToContainer(new Slot(par1InventoryPlayer, var4 + var3 * 9 + 9, 8 + var4 * 18, 148 + var3 * 18));
}
}
for (var3 = 0; var3 < 9; ++var3)
{
this.addSlotToContainer(new Slot(par1InventoryPlayer, var3, 8 + var3 * 18, 206));
}
this.tileEntity.getPlayersUsing().add(par1InventoryPlayer.player);
tileEntity.openChest();
}
@Override
public void onContainerClosed(EntityPlayer entityplayer)
{
super.onContainerClosed(entityplayer);
this.tileEntity.getPlayersUsing().remove(entityplayer);
}
@Override
public boolean canInteractWith(EntityPlayer par1EntityPlayer)
{
return this.tileEntity.isUseableByPlayer(par1EntityPlayer);
}
/** Called to transfer a stack from one inventory to the other eg. when shift clicking. */
@Override
public ItemStack transferStackInSlot(EntityPlayer par1EntityPlayer, int par1)
{
ItemStack var2 = null;
Slot var3 = (Slot) this.inventorySlots.get(par1);
if (var3 != null && var3.getHasStack())
{
ItemStack itemStack = var3.getStack();
var2 = itemStack.copy();
if (par1 > 6)
{
if (itemStack.itemID == Atomic.itemDarkMatter.itemID)
{
if (!this.mergeItemStack(itemStack, 0, 6, false))
{
return null;
}
}
else if (!this.getSlot(6).getHasStack())
{
if (!this.mergeItemStack(itemStack, 6, 7, false))
{
return null;
}
}
}
else if (!this.mergeItemStack(itemStack, 7, 36 + 7, false))
{
return null;
}
if (itemStack.stackSize == 0)
{
var3.putStack((ItemStack) null);
}
else
{
var3.onSlotChanged();
}
if (itemStack.stackSize == var2.stackSize)
{
return null;
}
var3.onPickupFromSlot(par1EntityPlayer, itemStack);
}
return var2;
}
}

View file

@ -0,0 +1,66 @@
package resonantinduction.atomic.particle.quantum;
import net.minecraft.entity.player.InventoryPlayer;
import net.minecraft.util.ResourceLocation;
import org.lwjgl.opengl.GL11;
import resonant.lib.gui.GuiContainerBase;
import resonantinduction.atomic.Atomic;
import resonantinduction.core.Reference;
import universalelectricity.api.energy.UnitDisplay.Unit;
public class GuiQuantumAssembler extends GuiContainerBase
{
public static final ResourceLocation TEXTURE = new ResourceLocation(Reference.DOMAIN, Atomic.GUI_TEXTURE_DIRECTORY + "gui_atomic_assembler.png");
private TileQuantumAssembler tileEntity;
private int containerWidth;
private int containerHeight;
public GuiQuantumAssembler(InventoryPlayer par1InventoryPlayer, TileQuantumAssembler tileEntity)
{
super(new ContainerQuantumAssembler(par1InventoryPlayer, tileEntity));
this.tileEntity = tileEntity;
this.ySize = 230;
}
/** Draw the foreground layer for the GuiContainer (everything in front of the items) */
@Override
public void drawGuiContainerForegroundLayer(int mouseX, int mouseY)
{
this.fontRenderer.drawString(this.tileEntity.getInvName(), 65 - this.tileEntity.getInvName().length(), 6, 4210752);
String displayText = "";
if (this.tileEntity.time() > 0)
{
displayText = "Process: " + (int) (100 - ((float) this.tileEntity.time() / (float) this.tileEntity.MAX_TIME()) * 100) + "%";
}
else if (this.tileEntity.canProcess())
{
displayText = "Ready";
}
else
{
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);
}
/** Draw the background layer for the GuiContainer (everything behind the items) */
@Override
protected void drawGuiContainerBackgroundLayer(float par1, int par2, int par3)
{
this.mc.renderEngine.bindTexture(TEXTURE);
GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
this.containerWidth = (this.width - this.xSize) / 2;
this.containerHeight = (this.height - this.ySize) / 2;
this.drawTexturedModalRect(this.containerWidth, this.containerHeight, 0, 0, this.xSize, this.ySize);
}
}

View file

@ -0,0 +1,83 @@
package resonantinduction.atomic.particle.quantum;
import net.minecraft.client.renderer.RenderBlocks;
import net.minecraft.client.renderer.entity.RenderItem;
import net.minecraft.client.renderer.entity.RenderManager;
import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer;
import net.minecraft.entity.item.EntityItem;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.ResourceLocation;
import net.minecraftforge.client.model.AdvancedModelLoader;
import net.minecraftforge.client.model.IModelCustom;
import org.apache.commons.lang3.ArrayUtils;
import org.lwjgl.opengl.GL11;
import resonantinduction.core.Reference;
import cpw.mods.fml.relauncher.Side;
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");
private final RenderBlocks renderBlocks = new RenderBlocks();
public void render(TileQuantumAssembler tileEntity, double x, double y, double z, float f)
{
GL11.glPushMatrix();
GL11.glTranslated(x + 0.5, y + 0.5, z + 0.5);
final String[] hands = new String[]
{ "Back Arm Upper", "Back Arm Lower", "Right Arm Upper", "Right Arm Lower", "Front Arm Upper", "Front Arm Lower", "Left Arm Upper", "Left Arm Lower" };
final String[] arms = new String[]
{ "Middle Rotor Focus Lazer", "Middle Rotor Uppper Arm", "Middle Rotor Lower Arm", "Middle Rotor Arm Base", "Middle Rotor" };
final String[] largeArms = new String[]
{ "Bottom Rotor Upper Arm", "Bottom Rotor Lower Arm", "Bottom Rotor Arm Base", "Bottom Rotor", "Bottom Rotor Resonator Arm" };
bindTexture(TEXTURE);
GL11.glPushMatrix();
GL11.glRotatef(-tileEntity.rotationYaw1(), 0, 1f, 0);
MODEL.renderOnly(hands);
MODEL.renderOnly("Resonance_Crystal");
GL11.glPopMatrix();
/** Small Laser Arm */
GL11.glPushMatrix();
GL11.glRotatef(tileEntity.rotationYaw2(), 0, 1f, 0);
MODEL.renderOnly(arms);
GL11.glPopMatrix();
/** Large Laser Arm */
GL11.glPushMatrix();
GL11.glRotatef(-tileEntity.rotationYaw3(), 0, 1f, 0);
MODEL.renderOnly(largeArms);
GL11.glPopMatrix();
MODEL.renderAllExcept(ArrayUtils.add(ArrayUtils.addAll(ArrayUtils.addAll(hands, arms), largeArms), "Resonance_Crystal"));
GL11.glPopMatrix();
/** Render the item */
RenderItem renderItem = ((RenderItem) RenderManager.instance.getEntityClassRenderObject(EntityItem.class));
GL11.glPushMatrix();
if (tileEntity.entityItem() != null)
{
renderItem.doRenderItem(tileEntity.entityItem(), x + 0.5, y + 0.4, z + 0.5, 0, 0);
}
GL11.glPopMatrix();
}
@Override
public void renderTileEntityAt(TileEntity tileEntity, double var2, double var4, double var6, float var8)
{
this.render((TileQuantumAssembler) tileEntity, var2, var4, var6, var8);
}
}

View file

@ -0,0 +1,239 @@
package resonantinduction.atomic.particle.quantum
import resonantinduction.atomic
import resonant.api.recipe.QuantumAssemblerRecipes
import resonant.lib.network.IPacketReceiver
import com.google.common.io.ByteArrayDataInput
import cpw.mods.fml.common.network.PacketDispatcher
import cpw.mods.fml.common.network.Player
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.minecraftforge.common.ForgeDirection
import universalelectricity.api.electricity.IVoltageInput
import universalelectricity.api.energy.EnergyStorageHandler
import resonant.lib.content.prefab.TraitInventory
import net.minecraft.block.material.Material
import universalelectricity.api.vector.Vector3
import resonant.lib.prefab.tile.TileElectrical
import resonantinduction.atomic.Atomic
import resonantinduction.core.ResonantInduction
import resonantinduction.core.Reference
class TileQuantumAssembler extends TileElectrical(Material.iron) with TraitInventory with IPacketReceiver with IVoltageInput {
val ENERGY: Long = 10000000000000L
val MAX_TIME: Int = 20 * 120
var time: Int = 0
/**
* Used for rendering.
*/
var rotationYaw1: Float = 0
var rotationYaw2: Float = 0
var rotationYaw3: Float = 0
/**
* Used for rendering.
*/
var entityItem: EntityItem = null
energy = new EnergyStorageHandler(ENERGY)
maxSlots = 6 + 1
isOpaqueCube = false;
normalRender = false;
customItemRender = true;
textureName = "machine"
/**
* Called when the block is right clicked by the player
*/
override def use(player: EntityPlayer, side: Int, hit: Vector3): Boolean =
{
if (!world().isRemote) {
player.openGui(Atomic.INSTANCE, 0, world, x, y, z)
return true
}
return true
}
override def updateEntity {
super.updateEntity
if (!this.worldObj.isRemote) {
if (this.canProcess) {
if (energy.checkExtract) {
if (this.time == 0) {
this.time = this.MAX_TIME
}
if (this.time > 0) {
this.time -= 1
if (this.time < 1) {
this.process
this.time = 0
}
} else {
this.time = 0
}
this.energy.extractEnergy(ENERGY, true)
}
} else {
this.time = 0
}
if (this.ticks % 10 == 0) {
import scala.collection.JavaConversions._
for (player <- this.getPlayersUsing) {
PacketDispatcher.sendPacketToPlayer(getDescriptionPacket, player.asInstanceOf[Player])
}
}
} else if (this.time > 0) {
if (this.ticks % 600 == 0) {
this.worldObj.playSoundEffect(this.xCoord, this.yCoord, this.zCoord, Reference.PREFIX + "assembler", 0.7f, 1f)
}
this.rotationYaw1 += 3
this.rotationYaw2 += 2
this.rotationYaw3 += 1
var itemStack: ItemStack = this.getStackInSlot(6)
if (itemStack != null) {
itemStack = itemStack.copy
itemStack.stackSize = 1
if (this.entityItem == null) {
this.entityItem = new EntityItem(this.worldObj, 0, 0, 0, itemStack)
} else if (!itemStack.isItemEqual(this.entityItem.getEntityItem)) {
this.entityItem = new EntityItem(this.worldObj, 0, 0, 0, itemStack)
}
this.entityItem.age += 1
} else {
this.entityItem = null
}
}
}
override def onReceiveEnergy(from: ForgeDirection, receive: Long, doReceive: Boolean): Long =
{
if (this.canProcess) {
return super.onReceiveEnergy(from, receive, doReceive)
}
return 0
}
def onReceivePacket(data: ByteArrayDataInput, player: EntityPlayer, extra: AnyRef*) {
try {
this.time = data.readInt
val itemID: Int = data.readInt
val itemAmount: Int = data.readInt
val itemMeta: Int = data.readInt
if (itemID != -1 && itemAmount != -1 && itemMeta != -1) {
this.setInventorySlotContents(6, new ItemStack(Item.itemsList(itemID), itemAmount, itemMeta))
}
} catch {
case e: Exception =>
{
e.printStackTrace
}
}
}
override def getDescriptionPacket: Packet =
{
if (this.getStackInSlot(6) != null) {
return ResonantInduction.PACKET_TILE.getPacket(this, Int.box(time), Int.box(getStackInSlot(6).itemID), Int.box(getStackInSlot(6).stackSize), Int.box(getStackInSlot(6).getItemDamage))
}
return ResonantInduction.PACKET_TILE.getPacket(this, Int.box(time), Int.box(-1), Int.box(-1), Int.box(-1))
}
override def openChest {
if (!this.worldObj.isRemote) {
import scala.collection.JavaConversions._
for (player <- this.getPlayersUsing) {
PacketDispatcher.sendPacketToPlayer(getDescriptionPacket, player.asInstanceOf[Player])
}
}
}
def canProcess: Boolean =
{
if (getStackInSlot(6) != null) {
if (QuantumAssemblerRecipes.hasItemStack(getStackInSlot(6))) {
{
var i: Int = 0
while (i < 6) {
{
if (getStackInSlot(i) == null) {
return false
}
if (getStackInSlot(i).itemID != Atomic.itemDarkMatter.itemID) {
return false
}
}
({
i += 1;
i - 1
})
}
}
return getStackInSlot(6).stackSize < 64
}
}
return false
}
/**
* Turn one item from the furnace source stack into the appropriate smelted item in the furnace
* result stack
*/
def process {
if (this.canProcess) {
{
var i: Int = 0
while (i < 5) {
{
if (getStackInSlot(i) != null) {
decrStackSize(i, 1)
}
}
({
i += 1;
i - 1
})
}
}
if (getStackInSlot(6) != null) {
getStackInSlot(6).stackSize += 1
}
}
}
/**
* Reads a tile entity from NBT.
*/
override def readFromNBT(par1NBTTagCompound: NBTTagCompound) {
super.readFromNBT(par1NBTTagCompound)
this.time = par1NBTTagCompound.getInteger("smeltingTicks")
}
/**
* Writes a tile entity to NBT.
*/
override def writeToNBT(par1NBTTagCompound: NBTTagCompound) {
super.writeToNBT(par1NBTTagCompound)
par1NBTTagCompound.setInteger("smeltingTicks", this.time)
}
override def isItemValidForSlot(slotID: Int, itemStack: ItemStack): Boolean =
{
if (slotID == 6) {
return true
}
return itemStack.itemID == Atomic.itemDarkMatter.itemID
}
def getVoltageInput(from: ForgeDirection): Long =
{
return 1000
}
def onWrongVoltage(direction: ForgeDirection, voltage: Long) {
}
}

View file

@ -0,0 +1,62 @@
package resonantinduction.atomic.process;
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 resonantinduction.atomic.Atomic;
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;
}
}

View file

@ -0,0 +1,38 @@
package resonantinduction.atomic.process;
import net.minecraft.entity.player.InventoryPlayer;
import net.minecraft.inventory.Slot;
import net.minecraft.inventory.SlotFurnace;
import resonant.lib.gui.ContainerBase;
import resonant.lib.prefab.slot.SlotEnergyItem;
/** Chemical extractor container */
public class ContainerChemicalExtractor extends ContainerBase
{
private static final int slotCount = 5;
private TileChemicalExtractor tileEntity;
public ContainerChemicalExtractor(InventoryPlayer par1InventoryPlayer, TileChemicalExtractor tileEntity)
{
super(tileEntity);
this.tileEntity = tileEntity;
// Battery
addSlotToContainer(new SlotEnergyItem(tileEntity, 0, 80, 50));
// Process Input (Cell or Uranium)
addSlotToContainer(new Slot(tileEntity, 1, 53, 25));
// Process Output
addSlotToContainer(new SlotFurnace(par1InventoryPlayer.player, tileEntity, 2, 107, 25));
// Fluid input fill
addSlotToContainer(new Slot(tileEntity, 3, 25, 19));
// Fluid input drain
addSlotToContainer(new Slot(tileEntity, 4, 25, 50));
// Fluid output fill
addSlotToContainer(new Slot(tileEntity, 5, 135, 19));
// Fluid output drain
addSlotToContainer(new Slot(tileEntity, 6, 135, 50));
addPlayerInventory(par1InventoryPlayer.player);
}
}

View file

@ -0,0 +1,54 @@
package resonantinduction.atomic.process;
import net.minecraft.entity.Entity;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.item.EnumArmorMaterial;
import net.minecraft.item.Item;
import net.minecraft.item.ItemArmor;
import net.minecraft.item.ItemStack;
import resonant.api.armor.IAntiPoisonArmor;
import resonantinduction.core.Reference;
import resonantinduction.core.TabRI;
/** Hazmat */
public class ItemHazmat extends ItemArmor implements IAntiPoisonArmor
{
public ItemHazmat(int par1, EnumArmorMaterial par2EnumArmorMaterial, int par3, int par4)
{
super(par1, par2EnumArmorMaterial, par3, par4);
this.setCreativeTab(TabRI.DEFAULT);
this.setMaxDamage(200000);
}
@Override
public Item setUnlocalizedName(String par1Str)
{
super.setUnlocalizedName(par1Str);
this.setTextureName(par1Str);
return this;
}
@Override
public String getArmorTexture(ItemStack stack, Entity entity, int slot, int layer)
{
return Reference.PREFIX + Reference.MODEL_DIRECTORY + "hazmat.png";
}
@Override
public boolean isProtectedFromPoison(ItemStack itemStack, EntityLivingBase entityLiving, String type)
{
return type.equalsIgnoreCase("radiation") || type.equalsIgnoreCase("chemical") || type.equalsIgnoreCase("contagious");
}
@Override
public void onProtectFromPoison(ItemStack itemStack, EntityLivingBase entityLiving, String type)
{
itemStack.damageItem(1, entityLiving);
}
@Override
public int getArmorType()
{
return this.armorType;
}
}

View file

@ -0,0 +1,47 @@
package resonantinduction.atomic.process;
import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.ResourceLocation;
import net.minecraftforge.client.model.AdvancedModelLoader;
import org.lwjgl.opengl.GL11;
import resonant.lib.render.RenderUtility;
import resonant.lib.render.model.TechneAdvancedModel;
import resonantinduction.core.Reference;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
@SideOnly(Side.CLIENT)
public class RenderChemicalExtractor extends TileEntitySpecialRenderer
{
public static final TechneAdvancedModel MODEL = (TechneAdvancedModel) AdvancedModelLoader.loadModel(Reference.MODEL_DIRECTORY + "chemicalExtractor.tcn");
public static final ResourceLocation TEXTURE = new ResourceLocation(Reference.DOMAIN, Reference.MODEL_PATH + "chemicalExtractor.png");
public void render(TileChemicalExtractor tileEntity, double x, double y, double z, float f)
{
GL11.glPushMatrix();
GL11.glTranslated(x + 0.5, y + 0.5, z + 0.5);
if (tileEntity.worldObj != null)
{
RenderUtility.rotateBlockBasedOnDirection(tileEntity.getDirection());
}
bindTexture(TEXTURE);
GL11.glPushMatrix();
MODEL.renderOnlyAroundPivot(Math.toDegrees(tileEntity.rotation), 0, 0, 1, "MAIN CHAMBER-ROTATES", "MAGNET 1-ROTATES", "MAGNET 2-ROTATES");
GL11.glPopMatrix();
MODEL.renderAllExcept("MAIN CHAMBER-ROTATES", "MAGNET 1-ROTATES", "MAGNET 2-ROTATES");
GL11.glPopMatrix();
}
@Override
public void renderTileEntityAt(TileEntity tileEntity, double var2, double var4, double var6, float var8)
{
this.render((TileChemicalExtractor) tileEntity, var2, var4, var6, var8);
}
}

View file

@ -0,0 +1,385 @@
package resonantinduction.atomic.process;
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.ForgeDirection;
import net.minecraftforge.fluids.Fluid;
import net.minecraftforge.fluids.FluidContainerRegistry;
import net.minecraftforge.fluids.FluidRegistry;
import net.minecraftforge.fluids.FluidStack;
import net.minecraftforge.fluids.FluidTank;
import net.minecraftforge.fluids.FluidTankInfo;
import net.minecraftforge.fluids.IFluidHandler;
import resonant.api.IRotatable;
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;
/** Chemical extractor TileEntity */
public class TileChemicalExtractor extends TileProcess implements ISidedInventory, IFluidHandler, IRotatable, IVoltageInput
{
public static final int TICK_TIME = 20 * 14;
public static final int EXTRACT_SPEED = 100;
public static final long ENERGY = 5000;
@Synced
public final FluidTank inputTank = new FluidTank(FluidContainerRegistry.BUCKET_VOLUME * 10);
@Synced
public final FluidTank outputTank = new FluidTank(FluidContainerRegistry.BUCKET_VOLUME * 10);
// How many ticks has this item been extracting for?
@Synced
public int time = 0;
public float rotation = 0;
public TileChemicalExtractor()
{
energy = new EnergyStorageHandler(ENERGY * 2);
maxSlots = 7;
inputSlot = 1;
outputSlot = 2;
tankInputFillSlot = 3;
tankInputDrainSlot = 4;
tankOutputFillSlot = 5;
tankOutputDrainSlot = 6;
}
@Override
public void updateEntity()
{
super.updateEntity();
if (time > 0)
{
rotation += 0.2f;
}
if (!worldObj.isRemote)
{
if (canUse())
{
discharge(getStackInSlot(0));
if (energy.checkExtract(ENERGY))
{
if (time == 0)
{
time = TICK_TIME;
}
if (time > 0)
{
time--;
if (time < 1)
{
if (!refineUranium())
{
if (!extractTritium())
{
extractDeuterium();
}
}
time = 0;
}
}
else
{
time = 0;
}
}
energy.extractEnergy(ENERGY, true);
}
else
{
time = 0;
}
if (ticks % 10 == 0)
{
for (EntityPlayer player : getPlayersUsing())
{
PacketDispatcher.sendPacketToPlayer(getDescriptionPacket(), (Player) player);
}
}
}
}
@Override
public Packet getDescriptionPacket()
{
return ResonantInduction.PACKET_ANNOTATION.getPacket(this);
}
public boolean canUse()
{
if (inputTank.getFluid() != null)
{
if (inputTank.getFluid().amount >= FluidContainerRegistry.BUCKET_VOLUME && Atomic.isItemStackUraniumOre(getStackInSlot(inputSlot)))
{
if (isItemValidForSlot(outputSlot, new ItemStack(Atomic.itemYellowCake)))
{
return true;
}
}
if (outputTank.getFluidAmount() < outputTank.getCapacity())
{
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()))
{
return true;
}
}
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()))
{
return true;
}
}
}
}
return false;
}
/** Turn one item from the furnace source stack into the appropriate smelted item in the furnace result stack. */
public boolean refineUranium()
{
if (canUse())
{
if (Atomic.isItemStackUraniumOre(getStackInSlot(inputSlot)))
{
inputTank.drain(FluidContainerRegistry.BUCKET_VOLUME, true);
incrStackSize(outputSlot, new ItemStack(Atomic.itemYellowCake, 3));
decrStackSize(inputSlot, 1);
return true;
}
}
return false;
}
public boolean extractDeuterium()
{
if (canUse())
{
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);
return true;
}
}
}
return false;
}
public boolean extractTritium()
{
if (canUse())
{
int waterUsage = Settings.deutermiumPerTritium;
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);
return true;
}
}
}
return false;
}
/** Reads a tile entity from NBT. */
@Override
public void readFromNBT(NBTTagCompound nbt)
{
super.readFromNBT(nbt);
time = nbt.getInteger("time");
NBTTagCompound water = nbt.getCompoundTag("inputTank");
inputTank.setFluid(FluidStack.loadFluidStackFromNBT(water));
NBTTagCompound deuterium = nbt.getCompoundTag("outputTank");
outputTank.setFluid(FluidStack.loadFluidStackFromNBT(deuterium));
}
/** Writes a tile entity to NBT. */
@Override
public void writeToNBT(NBTTagCompound nbt)
{
super.writeToNBT(nbt);
nbt.setInteger("time", time);
if (inputTank.getFluid() != null)
{
NBTTagCompound compound = new NBTTagCompound();
inputTank.getFluid().writeToNBT(compound);
nbt.setTag("inputTank", compound);
}
if (outputTank.getFluid() != null)
{
NBTTagCompound compound = new NBTTagCompound();
outputTank.getFluid().writeToNBT(compound);
nbt.setTag("outputTank", compound);
}
}
/** Tank Methods */
@Override
public int fill(ForgeDirection from, FluidStack resource, boolean doFill)
{
if (resource != null && canFill(from, resource.getFluid()))
{
return inputTank.fill(resource, doFill);
}
return 0;
}
@Override
public FluidStack drain(ForgeDirection from, FluidStack resource, boolean doDrain)
{
return drain(from, resource.amount, doDrain);
}
@Override
public FluidStack drain(ForgeDirection from, int maxDrain, boolean doDrain)
{
return outputTank.drain(maxDrain, doDrain);
}
@Override
public boolean canFill(ForgeDirection from, Fluid fluid)
{
return FluidRegistry.WATER.getID() == fluid.getID() || Atomic.FLUID_DEUTERIUM.getID() == fluid.getID();
}
@Override
public boolean canDrain(ForgeDirection from, Fluid fluid)
{
return outputTank.getFluid() != null && outputTank.getFluid().getFluid().getID() == fluid.getID();
}
@Override
public FluidTankInfo[] getTankInfo(ForgeDirection from)
{
return new FluidTankInfo[]
{ this.inputTank.getInfo(), this.outputTank.getInfo() };
}
@Override
public boolean isItemValidForSlot(int slotID, ItemStack itemStack)
{
// Water input for machine.
if (slotID == 0)
{
return CompatibilityModule.isHandler(itemStack.getItem());
}
if (slotID == 1)
{
return Atomic.isItemStackWaterCell(itemStack);
}
// Empty cell to be filled with deuterium or tritium.
if (slotID == 2)
{
return Atomic.isItemStackDeuteriumCell(itemStack) || Atomic.isItemStackTritiumCell(itemStack);
}
// Uranium to be extracted into yellowcake.
if (slotID == 3)
{
return Atomic.isItemStackEmptyCell(itemStack) || Atomic.isItemStackUraniumOre(itemStack) || Atomic.isItemStackDeuteriumCell(itemStack);
}
return false;
}
@Override
public int[] getAccessibleSlotsFromSide(int side)
{
return new int[]
{ 1, 2, 3 };
}
@Override
public boolean canInsertItem(int slotID, ItemStack itemStack, int side)
{
return this.isItemValidForSlot(slotID, itemStack);
}
@Override
public boolean canExtractItem(int slotID, ItemStack itemstack, int side)
{
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()
{
return inputTank;
}
@Override
public FluidTank getOutputTank()
{
return outputTank;
}
}

View file

@ -0,0 +1,102 @@
package resonantinduction.atomic.process;
import net.minecraft.item.ItemStack;
import net.minecraftforge.fluids.FluidContainerRegistry;
import net.minecraftforge.fluids.FluidStack;
import net.minecraftforge.fluids.FluidTank;
import resonant.api.recipe.MachineRecipes;
import resonant.api.recipe.RecipeResource;
import resonant.lib.prefab.tile.TileElectricalInventory;
/** General class for all machines that do traditional recipe processing
*
* @author Calclavia */
public abstract class TileProcess extends TileElectricalInventory
{
protected int inputSlot;
protected int outputSlot;
protected int tankInputFillSlot;
protected int tankInputDrainSlot;
protected int tankOutputFillSlot;
protected int tankOutputDrainSlot;
protected String machineName;
@Override
public void updateEntity()
{
super.updateEntity();
if (getInputTank() != null)
{
fillOrDrainTank(tankInputFillSlot, tankInputDrainSlot, getInputTank());
}
if (getOutputTank() != null)
{
fillOrDrainTank(tankOutputFillSlot, tankOutputDrainSlot, getOutputTank());
}
}
/** Takes an fluid container item and try to fill the tank, dropping the remains in the output slot. */
public void fillOrDrainTank(int containerInput, int containerOutput, FluidTank tank)
{
ItemStack inputStack = getStackInSlot(containerInput);
ItemStack outputStack = getStackInSlot(containerOutput);
if (FluidContainerRegistry.isFilledContainer(inputStack))
{
FluidStack fluidStack = FluidContainerRegistry.getFluidForFilledItem(inputStack);
ItemStack result = inputStack.getItem().getContainerItemStack(inputStack);
if (result != null && tank.fill(fluidStack, false) >= fluidStack.amount && (outputStack == null || result.isItemEqual(outputStack)))
{
tank.fill(fluidStack, true);
decrStackSize(containerInput, 1);
incrStackSize(containerOutput, result);
}
}
else if (FluidContainerRegistry.isEmptyContainer(inputStack))
{
FluidStack avaliable = tank.getFluid();
if (avaliable != null)
{
ItemStack result = FluidContainerRegistry.fillFluidContainer(avaliable, inputStack);
FluidStack filled = FluidContainerRegistry.getFluidForFilledItem(result);
if (result != null && filled != null && (outputStack == null || result.isItemEqual(outputStack)))
{
decrStackSize(containerInput, 1);
incrStackSize(containerOutput, result);
tank.drain(filled.amount, true);
}
}
}
}
/** Gets the current result of the input set up.
*
* @return */
public RecipeResource[] getResults()
{
ItemStack inputStack = getStackInSlot(inputSlot);
RecipeResource[] mixedResult = MachineRecipes.INSTANCE.getOutput(machineName, inputStack, getInputTank().getFluid());
if (mixedResult.length > 0)
{
return mixedResult;
}
return MachineRecipes.INSTANCE.getOutput(machineName, inputStack);
}
public boolean hasResult()
{
return getResults().length > 0;
}
public abstract FluidTank getInputTank();
public abstract FluidTank getOutputTank();
}

View file

@ -0,0 +1,61 @@
package resonantinduction.atomic.process.fission;
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 resonantinduction.atomic.Atomic;
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;
}
}

View file

@ -0,0 +1,60 @@
package resonantinduction.atomic.process.fission;
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 resonantinduction.atomic.Atomic;
import universalelectricity.api.UniversalElectricity;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
/** Nuclear boiler block */
public class BlockNuclearBoiler extends BlockRotatable
{
public BlockNuclearBoiler(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;
}
@SideOnly(Side.CLIENT)
@Override
public int getRenderType()
{
return BlockRenderingHandler.ID;
}
@Override
public TileEntity createNewTileEntity(World var1)
{
return new TileNuclearBoiler();
}
@Override
public boolean renderAsNormalBlock()
{
return false;
}
@Override
public boolean isOpaqueCube()
{
return false;
}
}

View file

@ -0,0 +1,119 @@
package resonantinduction.atomic.process.fission;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.entity.player.InventoryPlayer;
import net.minecraft.inventory.Slot;
import net.minecraft.inventory.SlotFurnace;
import net.minecraft.item.ItemStack;
import resonant.lib.gui.ContainerBase;
import resonant.lib.prefab.slot.SlotEnergyItem;
import resonantinduction.atomic.Atomic;
/** Centrifuge container */
public class ContainerCentrifuge extends ContainerBase
{
private static final int slotCount = 4;
private TileCentrifuge tileEntity;
public ContainerCentrifuge(InventoryPlayer par1InventoryPlayer, TileCentrifuge tileEntity)
{
super(tileEntity);
this.tileEntity = tileEntity;
// Electric Item
this.addSlotToContainer(new SlotEnergyItem(tileEntity, 0, 131, 26));
// Uranium Gas Tank
this.addSlotToContainer(new Slot(tileEntity, 1, 25, 50));
// Output Uranium 235
this.addSlotToContainer(new SlotFurnace(par1InventoryPlayer.player, tileEntity, 2, 81, 26));
// Output Uranium 238
this.addSlotToContainer(new SlotFurnace(par1InventoryPlayer.player, tileEntity, 3, 101, 26));
this.addPlayerInventory(par1InventoryPlayer.player);
tileEntity.openChest();
}
@Override
public void onContainerClosed(EntityPlayer entityplayer)
{
super.onContainerClosed(entityplayer);
this.tileEntity.getPlayersUsing().remove(entityplayer);
}
@Override
public boolean canInteractWith(EntityPlayer par1EntityPlayer)
{
return this.tileEntity.isUseableByPlayer(par1EntityPlayer);
}
/** Called to transfer a stack from one inventory to the other eg. when shift clicking. */
@Override
public ItemStack transferStackInSlot(EntityPlayer par1EntityPlayer, int par1)
{
ItemStack var2 = null;
Slot var3 = (Slot) this.inventorySlots.get(par1);
if (var3 != null && var3.getHasStack())
{
ItemStack itemStack = var3.getStack();
var2 = itemStack.copy();
if (par1 >= slotCount)
{
if (this.getSlot(0).isItemValid(itemStack))
{
if (!this.mergeItemStack(itemStack, 0, 1, false))
{
return null;
}
}
else if (Atomic.isItemStackUraniumOre(itemStack))
{
if (!this.mergeItemStack(itemStack, 1, 2, false))
{
return null;
}
}
else if (Atomic.isItemStackEmptyCell(itemStack))
{
if (!this.mergeItemStack(itemStack, 3, 4, false))
{
return null;
}
}
else if (par1 < 27 + slotCount)
{
if (!this.mergeItemStack(itemStack, 27 + slotCount, 36 + slotCount, false))
{
return null;
}
}
else if (par1 >= 27 + slotCount && par1 < 36 + slotCount && !this.mergeItemStack(itemStack, 4, 30, false))
{
return null;
}
}
else if (!this.mergeItemStack(itemStack, slotCount, 36 + slotCount, false))
{
return null;
}
if (itemStack.stackSize == 0)
{
var3.putStack((ItemStack) null);
}
else
{
var3.onSlotChanged();
}
if (itemStack.stackSize == var2.stackSize)
{
return null;
}
var3.onPickupFromSlot(par1EntityPlayer, itemStack);
}
return var2;
}
}

View file

@ -0,0 +1,72 @@
package resonantinduction.atomic.process.fission;
import net.minecraft.entity.player.InventoryPlayer;
import net.minecraft.util.StatCollector;
import resonant.lib.gui.GuiContainerBase;
import universalelectricity.api.energy.UnitDisplay.Unit;
public class GuiCentrifuge extends GuiContainerBase
{
private TileCentrifuge tileEntity;
public GuiCentrifuge(InventoryPlayer par1InventoryPlayer, TileCentrifuge tileEntity)
{
super(new ContainerCentrifuge(par1InventoryPlayer, tileEntity));
this.tileEntity = tileEntity;
}
/** Draw the foreground layer for the GuiContainer (everything in front of the items) */
@Override
public void drawGuiContainerForegroundLayer(int mouseX, int mouseY)
{
this.fontRenderer.drawString(tileEntity.getInvName(), 60, 6, 4210752);
String displayText = "";
if (this.tileEntity.timer > 0)
{
displayText = "Processing";
}
else if (this.tileEntity.nengYong())
{
displayText = "Ready";
}
else
{
displayText = "Idle";
}
this.fontRenderer.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.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.fontRenderer.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");
}
}
/** Draw the background layer for the GuiContainer (everything behind the items) */
@Override
protected void drawGuiContainerBackgroundLayer(float par1, int x, int y)
{
super.drawGuiContainerBackgroundLayer(par1, x, y);
this.drawSlot(80, 25);
this.drawSlot(100, 25);
this.drawSlot(130, 25, SlotType.BATTERY);
this.drawBar(40, 26, (float) this.tileEntity.timer / (float) TileCentrifuge.SHI_JIAN);
// Uranium Gas
this.drawMeter(8, 18, (float) this.tileEntity.gasTank.getFluidAmount() / (float) this.tileEntity.gasTank.getCapacity(), this.tileEntity.gasTank.getFluid());
this.drawSlot(24, 49, SlotType.GAS);
}
}

View file

@ -0,0 +1,82 @@
package resonantinduction.atomic.process.fission;
import net.minecraft.entity.player.InventoryPlayer;
import net.minecraft.util.StatCollector;
import resonant.lib.gui.GuiContainerBase;
import resonantinduction.atomic.process.ContainerChemicalExtractor;
import resonantinduction.atomic.process.TileChemicalExtractor;
import universalelectricity.api.energy.UnitDisplay.Unit;
public class GuiChemicalExtractor extends GuiContainerBase
{
private TileChemicalExtractor tileEntity;
public GuiChemicalExtractor(InventoryPlayer par1InventoryPlayer, TileChemicalExtractor tileEntity)
{
super(new ContainerChemicalExtractor(par1InventoryPlayer, tileEntity));
this.tileEntity = tileEntity;
}
/** Draw the foreground layer for the GuiContainer (everything in front of the items) */
@Override
public void drawGuiContainerForegroundLayer(int mouseX, int mouseY)
{
this.fontRenderer.drawString(tileEntity.getInvName(), 45, 6, 4210752);
this.renderUniversalDisplay(8, 112, TileChemicalExtractor.ENERGY * 20, mouseX, mouseY, Unit.WATT);
this.renderUniversalDisplay(100, 112, this.tileEntity.getVoltageInput(null), mouseX, mouseY, Unit.VOLTAGE);
this.fontRenderer.drawString("The extractor can extract", 8, 75, 4210752);
this.fontRenderer.drawString("uranium, deuterium and tritium.", 8, 85, 4210752);
this.fontRenderer.drawString("Place them in the input slot.", 8, 95, 4210752);
this.fontRenderer.drawString(StatCollector.translateToLocal("container.inventory"), 8, this.ySize - 96 + 2, 4210752);
if (this.isPointInRegion(8, 18, this.meterWidth, this.meterHeight, mouseX, mouseY) && this.tileEntity.inputTank.getFluid() != null)
{
if (this.tileEntity.inputTank.getFluid() != null)
{
this.drawTooltip(mouseX - this.guiLeft, mouseY - this.guiTop + 10, this.tileEntity.inputTank.getFluid().getFluid().getLocalizedName(), this.tileEntity.inputTank.getFluid().amount + " L");
}
}
if (this.isPointInRegion(154, 18, this.meterWidth, this.meterHeight, mouseX, mouseY) && this.tileEntity.outputTank.getFluid() != null)
{
if (this.tileEntity.outputTank.getFluid() != null)
{
this.drawTooltip(mouseX - this.guiLeft, mouseY - this.guiTop + 10, this.tileEntity.outputTank.getFluid().getFluid().getLocalizedName(), this.tileEntity.outputTank.getFluid().amount + " L");
}
}
if (this.isPointInRegion(134, 49, 18, 18, mouseX, mouseY))
{
if (this.tileEntity.getStackInSlot(4) == null)
{
// this.drawTooltip(x - this.guiLeft, y - this.guiTop + 10, "Place empty cells.");
}
}
if (this.isPointInRegion(52, 24, 18, 18, mouseX, mouseY))
{
if (this.tileEntity.outputTank.getFluidAmount() > 0 && this.tileEntity.getStackInSlot(3) == null)
{
this.drawTooltip(mouseX - this.guiLeft, mouseY - this.guiTop + 10, "Input slot");
}
}
}
/** Draw the background layer for the GuiContainer (everything behind the items) */
@Override
protected void drawGuiContainerBackgroundLayer(float par1, int x, int y)
{
super.drawGuiContainerBackgroundLayer(par1, x, y);
drawSlot(79, 49, SlotType.BATTERY);
drawSlot(52, 24);
drawSlot(106, 24);
drawBar(75, 24, (float) tileEntity.time / (float) TileChemicalExtractor.TICK_TIME);
drawMeter(8, 18, (float) tileEntity.inputTank.getFluidAmount() / (float) tileEntity.inputTank.getCapacity(), tileEntity.inputTank.getFluid());
drawSlot(24, 18, SlotType.LIQUID);
drawSlot(24, 49, SlotType.LIQUID);
drawMeter(154, 18, (float) tileEntity.outputTank.getFluidAmount() / (float) tileEntity.outputTank.getCapacity(), tileEntity.outputTank.getFluid());
drawSlot(134, 18, SlotType.LIQUID);
drawSlot(134, 49, SlotType.LIQUID);
}
}

View file

@ -0,0 +1,64 @@
package resonantinduction.atomic.process.fission;
import net.minecraft.entity.player.InventoryPlayer;
import net.minecraft.util.StatCollector;
import resonant.lib.gui.GuiContainerBase;
import resonantinduction.atomic.fusion.ContainerNuclearBoiler;
import universalelectricity.api.energy.UnitDisplay.Unit;
public class GuiNuclearBoiler extends GuiContainerBase
{
private TileNuclearBoiler tileEntity;
public GuiNuclearBoiler(InventoryPlayer par1InventoryPlayer, TileNuclearBoiler tileEntity)
{
super(new ContainerNuclearBoiler(par1InventoryPlayer, tileEntity));
this.tileEntity = tileEntity;
}
/** Draw the foreground layer for the GuiContainer (everything in front of the items) */
@Override
public void drawGuiContainerForegroundLayer(int mouseX, int mouseY)
{
this.fontRenderer.drawString(tileEntity.getInvName(), 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.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.fontRenderer.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");
}
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) */
@Override
protected void drawGuiContainerBackgroundLayer(float par1, int x, int y)
{
super.drawGuiContainerBackgroundLayer(par1, x, y);
this.drawSlot(55, 25, SlotType.BATTERY);
this.drawSlot(80, 25);
this.drawBar(110, 26, (float) this.tileEntity.timer / (float) this.tileEntity.SHI_JIAN);
// Water
this.drawMeter(8, 18, (float) this.tileEntity.waterTank.getFluidAmount() / (float) this.tileEntity.waterTank.getCapacity(), this.tileEntity.waterTank.getFluid());
this.drawSlot(24, 49, SlotType.LIQUID);
// Uranium Gas
this.drawMeter(155, 18, (float) this.tileEntity.gasTank.getFluidAmount() / (float) this.tileEntity.gasTank.getCapacity(), this.tileEntity.gasTank.getFluid());
this.drawSlot(135, 49, SlotType.GAS);
}
}

View file

@ -0,0 +1,48 @@
package resonantinduction.atomic.process.fission;
import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.ResourceLocation;
import net.minecraftforge.client.model.AdvancedModelLoader;
import net.minecraftforge.client.model.IModelCustom;
import org.lwjgl.opengl.GL11;
import resonant.lib.render.RenderUtility;
import resonantinduction.core.Reference;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
@SideOnly(Side.CLIENT)
public class RenderCentrifuge extends TileEntitySpecialRenderer
{
public static final IModelCustom MODEL = AdvancedModelLoader.loadModel(Reference.MODEL_DIRECTORY + "centrifuge.tcn");
public static final ResourceLocation TEXTURE = new ResourceLocation(Reference.DOMAIN, Reference.MODEL_PATH + "centrifuge.png");
public void render(TileCentrifuge tileEntity, double x, double y, double z, float f)
{
GL11.glPushMatrix();
GL11.glTranslated(x + 0.5, y + 0.5, z + 0.5);
if (tileEntity.worldObj != null)
{
RenderUtility.rotateBlockBasedOnDirection(tileEntity.getDirection());
}
bindTexture(TEXTURE);
GL11.glPushMatrix();
GL11.glRotated(Math.toDegrees(tileEntity.rotation), 0, 1, 0);
MODEL.renderOnly("C", "JROT", "KROT", "LROT", "MROT");
GL11.glPopMatrix();
MODEL.renderAllExcept("C", "JROT", "KROT", "LROT", "MROT");
GL11.glPopMatrix();
}
@Override
public void renderTileEntityAt(TileEntity tileEntity, double var2, double var4, double var6, float var8)
{
this.render((TileCentrifuge) tileEntity, var2, var4, var6, var8);
}
}

View file

@ -0,0 +1,46 @@
package resonantinduction.atomic.process.fission;
import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.ResourceLocation;
import net.minecraftforge.client.model.AdvancedModelLoader;
import org.lwjgl.opengl.GL11;
import resonant.lib.render.RenderUtility;
import resonant.lib.render.model.TechneAdvancedModel;
import resonantinduction.core.Reference;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
@SideOnly(Side.CLIENT)
public class RenderNuclearBoiler extends TileEntitySpecialRenderer
{
public static final TechneAdvancedModel MODEL = (TechneAdvancedModel) AdvancedModelLoader.loadModel(Reference.MODEL_DIRECTORY + "nuclearBoiler.tcn");
public static final ResourceLocation TEXTURE = new ResourceLocation(Reference.DOMAIN, Reference.MODEL_PATH + "nuclearBoiler.png");
public void renderAModelAt(TileNuclearBoiler tileEntity, double x, double y, double z, float f)
{
GL11.glPushMatrix();
GL11.glTranslated(x + 0.5, y + 0.5, z + 0.5);
GL11.glRotatef(90, 0, 1, 0);
if (tileEntity.worldObj != null)
{
RenderUtility.rotateBlockBasedOnDirection(tileEntity.getDirection());
}
bindTexture(TEXTURE);
MODEL.renderOnlyAroundPivot(Math.toDegrees(tileEntity.rotation), 0, 1, 0, "FUEL BAR SUPPORT 1 ROTATES", "FUEL BAR 1 ROTATES");
MODEL.renderOnlyAroundPivot(-Math.toDegrees(tileEntity.rotation), 0, 1, 0, "FUEL BAR SUPPORT 2 ROTATES", "FUEL BAR 2 ROTATES");
MODEL.renderAllExcept("FUEL BAR SUPPORT 1 ROTATES", "FUEL BAR SUPPORT 2 ROTATES", "FUEL BAR 1 ROTATES", "FUEL BAR 2 ROTATES");
GL11.glPopMatrix();
}
@Override
public void renderTileEntityAt(TileEntity tileEntity, double var2, double var4, double var6, float var8)
{
this.renderAModelAt((TileNuclearBoiler) tileEntity, var2, var4, var6, var8);
}
}

View file

@ -0,0 +1,345 @@
package resonantinduction.atomic.process.fission;
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.tileentity.TileEntity;
import net.minecraftforge.common.ForgeDirection;
import net.minecraftforge.fluids.Fluid;
import net.minecraftforge.fluids.FluidContainerRegistry;
import net.minecraftforge.fluids.FluidStack;
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 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.api.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;
/** Centrifuge TileEntity */
public class TileCentrifuge extends TileElectricalInventory implements ISidedInventory, IPacketReceiver, IFluidHandler, IRotatable, IVoltageInput
{
public static final int SHI_JIAN = 20 * 60;
public static final long DIAN = 500000;
public final FluidTank gasTank = new FluidTank(Atomic.FLUIDSTACK_URANIUM_HEXAFLOURIDE.copy(), FluidContainerRegistry.BUCKET_VOLUME * 5);
public int timer = 0;
public float rotation = 0;
public TileCentrifuge()
{
energy = new EnergyStorageHandler(DIAN * 2);
maxSlots = 4;
}
@Override
public void updateEntity()
{
super.updateEntity();
if (timer > 0)
{
rotation += 0.45f;
}
if (!this.worldObj.isRemote)
{
/** Look for nearby tanks that contains uranium gas and try to extract it. */
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);
if (tileEntity instanceof IFluidHandler && tileEntity.getClass() != this.getClass())
{
IFluidHandler fluidHandler = ((IFluidHandler) tileEntity);
if (fluidHandler != null)
{
FluidStack requestFluid = Atomic.FLUIDSTACK_URANIUM_HEXAFLOURIDE.copy();
requestFluid.amount = this.gasTank.getCapacity() - Atomic.getFluidAmount(this.gasTank.getFluid());
FluidStack receiveFluid = fluidHandler.drain(direction.getOpposite(), requestFluid, true);
if (receiveFluid != null)
{
if (receiveFluid.amount > 0)
{
if (this.gasTank.fill(receiveFluid, false) > 0)
{
this.gasTank.fill(receiveFluid, true);
}
}
}
}
}
}
}
if (this.nengYong())
{
this.discharge(getStackInSlot(0));
if (this.energy.extractEnergy(TileCentrifuge.DIAN, false) >= DIAN)
{
if (this.timer == 0)
{
this.timer = TileCentrifuge.SHI_JIAN;
}
if (this.timer > 0)
{
this.timer--;
if (this.timer < 1)
{
this.yong();
this.timer = 0;
}
}
else
{
this.timer = 0;
}
this.energy.extractEnergy(DIAN, true);
}
}
else
{
this.timer = 0;
}
if (this.ticks % 10 == 0)
{
for (EntityPlayer player : this.getPlayersUsing())
{
PacketDispatcher.sendPacketToPlayer(getDescriptionPacket(), (Player) player);
}
}
}
}
@Override
public long onReceiveEnergy(ForgeDirection from, long receive, boolean doReceive)
{
if (this.nengYong())
{
return super.onReceiveEnergy(from, receive, doReceive);
}
else
{
return 0;
}
}
@Override
public void onReceivePacket(ByteArrayDataInput data, EntityPlayer player, Object... extra)
{
try
{
this.timer = data.readInt();
this.gasTank.setFluid(new FluidStack(Atomic.FLUIDSTACK_URANIUM_HEXAFLOURIDE.fluidID, data.readInt()));
}
catch (Exception e)
{
e.printStackTrace();
}
}
@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 If the machine can be used. */
public boolean nengYong()
{
if (this.gasTank.getFluid() != null)
{
if (this.gasTank.getFluid().amount >= Settings.uraniumHexaflourideRatio)
{
return isItemValidForSlot(2, new ItemStack(Atomic.itemUranium)) && isItemValidForSlot(3, new ItemStack(Atomic.itemUranium, 1, 1));
}
}
return false;
}
/** Turn one item from the furnace source stack into the appropriate smelted item in the furnace result stack */
public void yong()
{
if (this.nengYong())
{
this.gasTank.drain(Settings.uraniumHexaflourideRatio, true);
if (this.worldObj.rand.nextFloat() > 0.6)
{
this.incrStackSize(2, new ItemStack(Atomic.itemUranium));
}
else
{
this.incrStackSize(3, new ItemStack(Atomic.itemUranium, 1, 1));
}
}
}
/** Reads a tile entity from NBT. */
@Override
public void readFromNBT(NBTTagCompound nbt)
{
super.readFromNBT(nbt);
this.timer = nbt.getInteger("smeltingTicks");
NBTTagCompound compound = nbt.getCompoundTag("gas");
this.gasTank.setFluid(FluidStack.loadFluidStackFromNBT(compound));
}
/** Writes a tile entity to NBT. */
@Override
public void writeToNBT(NBTTagCompound nbt)
{
super.writeToNBT(nbt);
nbt.setInteger("smeltingTicks", this.timer);
if (this.gasTank.getFluid() != null)
{
NBTTagCompound compound = new NBTTagCompound();
this.gasTank.getFluid().writeToNBT(compound);
nbt.setTag("gas", compound);
}
}
/** Tank Methods */
@Override
public int fill(ForgeDirection from, FluidStack resource, boolean doFill)
{
if (Atomic.FLUIDSTACK_URANIUM_HEXAFLOURIDE.isFluidEqual(resource))
{
return this.gasTank.fill(resource, doFill);
}
return 0;
}
@Override
public FluidStack drain(ForgeDirection from, FluidStack resource, boolean doDrain)
{
return null;
}
@Override
public FluidStack drain(ForgeDirection from, int maxDrain, boolean doDrain)
{
return null;
}
@Override
public boolean canFill(ForgeDirection from, Fluid fluid)
{
return Atomic.FLUIDSTACK_URANIUM_HEXAFLOURIDE.fluidID == fluid.getID();
}
@Override
public boolean canDrain(ForgeDirection from, Fluid fluid)
{
return false;
}
@Override
public FluidTankInfo[] getTankInfo(ForgeDirection from)
{
return new FluidTankInfo[]
{ this.gasTank.getInfo() };
}
/** Inventory */
@Override
public int[] getAccessibleSlotsFromSide(int side)
{
return side == 1 ? new int[]
{ 0, 1 } : new int[]
{ 2, 3 };
}
@Override
public boolean canInsertItem(int slotID, ItemStack itemStack, int side)
{
return slotID == 1 && this.isItemValidForSlot(slotID, itemStack);
}
@Override
public boolean canExtractItem(int slotID, ItemStack itemstack, int j)
{
return slotID == 2 || slotID == 3;
}
@Override
public boolean isItemValidForSlot(int i, ItemStack itemStack)
{
switch (i)
{
case 0:
return CompatibilityModule.isHandler(itemStack.getItem());
case 1:
return true;
case 2:
return itemStack.itemID == Atomic.itemUranium.itemID;
case 3:
return itemStack.itemID == Atomic.itemUranium.itemID;
}
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)
{
}
}

View file

@ -0,0 +1,348 @@
package resonantinduction.atomic.process.fission;
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.ForgeDirection;
import net.minecraftforge.fluids.Fluid;
import net.minecraftforge.fluids.FluidContainerRegistry;
import net.minecraftforge.fluids.FluidStack;
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.network.Synced;
import resonant.lib.prefab.tile.TileElectricalInventory;
import resonantinduction.atomic.Atomic;
import resonantinduction.core.ResonantInduction;
import resonantinduction.core.Settings;
import universalelectricity.api.electricity.IVoltageInput;
import universalelectricity.api.energy.EnergyStorageHandler;
import com.google.common.io.ByteArrayDataInput;
import cpw.mods.fml.common.network.PacketDispatcher;
import cpw.mods.fml.common.network.Player;
/** Nuclear boiler TileEntity */
public class TileNuclearBoiler extends TileElectricalInventory implements ISidedInventory, IPacketReceiver, IFluidHandler, IRotatable, IVoltageInput
{
public final static long DIAN = 50000;
public final int SHI_JIAN = 20 * 15;
@Synced
public final FluidTank waterTank = new FluidTank(Atomic.FLUIDSTACK_WATER.copy(), FluidContainerRegistry.BUCKET_VOLUME * 5);
@Synced
public final FluidTank gasTank = new FluidTank(Atomic.FLUIDSTACK_URANIUM_HEXAFLOURIDE.copy(), FluidContainerRegistry.BUCKET_VOLUME * 5);
// How many ticks has this item been extracting for?
@Synced
public int timer = 0;
public float rotation = 0;
public TileNuclearBoiler()
{
energy = new EnergyStorageHandler(DIAN * 2);
maxSlots = 4;
}
@Override
public long onReceiveEnergy(ForgeDirection from, long receive, boolean doReceive)
{
if (this.nengYong())
{
return super.onReceiveEnergy(from, receive, doReceive);
}
return 0;
}
@Override
public void updateEntity()
{
super.updateEntity();
if (timer > 0)
{
rotation += 0.1f;
}
if (!this.worldObj.isRemote)
{
// Put water as liquid
if (getStackInSlot(1) != null)
{
if (FluidContainerRegistry.isFilledContainer(getStackInSlot(1)))
{
FluidStack liquid = FluidContainerRegistry.getFluidForFilledItem(getStackInSlot(1));
if (liquid.isFluidEqual(Atomic.FLUIDSTACK_WATER))
{
if (this.fill(ForgeDirection.UNKNOWN, liquid, false) > 0)
{
ItemStack resultingContainer = getStackInSlot(1).getItem().getContainerItemStack(getStackInSlot(1));
if (resultingContainer == null && getStackInSlot(1).stackSize > 1)
{
getStackInSlot(1).stackSize--;
}
else
{
setInventorySlotContents(1, resultingContainer);
}
this.waterTank.fill(liquid, true);
}
}
}
}
if (this.nengYong())
{
this.discharge(getStackInSlot(0));
if (this.energy.extractEnergy(DIAN, false) >= TileNuclearBoiler.DIAN)
{
if (this.timer == 0)
{
this.timer = SHI_JIAN;
}
if (this.timer > 0)
{
this.timer--;
if (this.timer < 1)
{
this.yong();
this.timer = 0;
}
}
else
{
this.timer = 0;
}
this.energy.extractEnergy(DIAN, true);
}
}
else
{
this.timer = 0;
}
if (this.ticks % 10 == 0)
{
this.sendDescPack();
}
}
}
@Override
public void onReceivePacket(ByteArrayDataInput data, EntityPlayer player, Object... extra)
{
try
{
this.timer = data.readInt();
this.waterTank.setFluid(new FluidStack(Atomic.FLUIDSTACK_WATER.fluidID, data.readInt()));
this.gasTank.setFluid(new FluidStack(Atomic.FLUIDSTACK_URANIUM_HEXAFLOURIDE.fluidID, data.readInt()));
}
catch (Exception e)
{
e.printStackTrace();
}
}
@Override
public Packet getDescriptionPacket()
{
return ResonantInduction.PACKET_TILE.getPacket(this, this.timer, Atomic.getFluidAmount(this.waterTank.getFluid()), Atomic.getFluidAmount(this.gasTank.getFluid()));
}
public void sendDescPack()
{
if (!this.worldObj.isRemote)
{
for (EntityPlayer player : this.getPlayersUsing())
{
PacketDispatcher.sendPacketToPlayer(getDescriptionPacket(), (Player) player);
}
}
}
// Check all conditions and see if we can start smelting
public boolean nengYong()
{
if (this.waterTank.getFluid() != null)
{
if (this.waterTank.getFluid().amount >= FluidContainerRegistry.BUCKET_VOLUME)
{
if (getStackInSlot(3) != null)
{
if (Atomic.itemYellowCake.itemID == getStackInSlot(3).itemID || Atomic.isItemStackUraniumOre(getStackInSlot(3)))
{
if (Atomic.getFluidAmount(this.gasTank.getFluid()) < this.gasTank.getCapacity())
{
return true;
}
}
}
}
}
return false;
}
/** Turn one item from the furnace source stack into the appropriate smelted item in the furnace result stack. */
public void yong()
{
if (this.nengYong())
{
this.waterTank.drain(FluidContainerRegistry.BUCKET_VOLUME, true);
FluidStack liquid = Atomic.FLUIDSTACK_URANIUM_HEXAFLOURIDE.copy();
liquid.amount = Settings.uraniumHexaflourideRatio * 2;
this.gasTank.fill(liquid, true);
this.decrStackSize(3, 1);
}
}
/** Reads a tile entity from NBT. */
@Override
public void readFromNBT(NBTTagCompound nbt)
{
super.readFromNBT(nbt);
this.timer = nbt.getInteger("shiJian");
NBTTagCompound waterCompound = nbt.getCompoundTag("water");
this.waterTank.setFluid(FluidStack.loadFluidStackFromNBT(waterCompound));
NBTTagCompound gasCompound = nbt.getCompoundTag("gas");
this.gasTank.setFluid(FluidStack.loadFluidStackFromNBT(gasCompound));
}
/** Writes a tile entity to NBT. */
@Override
public void writeToNBT(NBTTagCompound nbt)
{
super.writeToNBT(nbt);
nbt.setInteger("shiJian", this.timer);
if (this.waterTank.getFluid() != null)
{
NBTTagCompound compound = new NBTTagCompound();
this.waterTank.getFluid().writeToNBT(compound);
nbt.setTag("water", compound);
}
if (this.gasTank.getFluid() != null)
{
NBTTagCompound compound = new NBTTagCompound();
this.gasTank.getFluid().writeToNBT(compound);
nbt.setTag("gas", compound);
}
}
/** Tank Methods */
@Override
public int fill(ForgeDirection from, FluidStack resource, boolean doFill)
{
if (Atomic.FLUIDSTACK_WATER.isFluidEqual(resource))
{
return this.waterTank.fill(resource, doFill);
}
return 0;
}
@Override
public FluidStack drain(ForgeDirection from, FluidStack resource, boolean doDrain)
{
if (Atomic.FLUIDSTACK_URANIUM_HEXAFLOURIDE.isFluidEqual(resource))
{
return this.gasTank.drain(resource.amount, doDrain);
}
return null;
}
@Override
public FluidStack drain(ForgeDirection from, int maxDrain, boolean doDrain)
{
return this.gasTank.drain(maxDrain, doDrain);
}
@Override
public boolean canFill(ForgeDirection from, Fluid fluid)
{
return Atomic.FLUIDSTACK_WATER.fluidID == fluid.getID();
}
@Override
public boolean canDrain(ForgeDirection from, Fluid fluid)
{
return Atomic.FLUIDSTACK_URANIUM_HEXAFLOURIDE.fluidID == fluid.getID();
}
@Override
public FluidTankInfo[] getTankInfo(ForgeDirection from)
{
return new FluidTankInfo[]
{ this.waterTank.getInfo(), this.gasTank.getInfo() };
}
/** Inventory */
@Override
public boolean isItemValidForSlot(int slotID, ItemStack itemStack)
{
if (slotID == 1)
{
return Atomic.isItemStackWaterCell(itemStack);
}
else if (slotID == 3)
{
return itemStack.itemID == Atomic.itemYellowCake.itemID;
}
return false;
}
@Override
public int[] getAccessibleSlotsFromSide(int side)
{
return side == 0 ? new int[]
{ 2 } : new int[]
{ 1, 3 };
}
@Override
public boolean canInsertItem(int slotID, ItemStack itemStack, int side)
{
return this.isItemValidForSlot(slotID, itemStack);
}
@Override
public boolean canExtractItem(int slotID, ItemStack itemstack, int j)
{
return slotID == 2;
}
@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)
{
}
}

View file

@ -0,0 +1,96 @@
package resonantinduction.atomic.process.sensor;
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.api.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.intX() + ", Y: " + coord.intY() + ", Z: " + coord.intZ());
// 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);
}
}

View file

@ -0,0 +1,37 @@
package resonantinduction.atomic.process.sensor;
import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer;
import net.minecraft.tileentity.TileEntity;
import org.lwjgl.opengl.GL11;
import resonant.lib.render.RenderUtility;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
@SideOnly(Side.CLIENT)
public class RenderThermometer extends TileEntitySpecialRenderer
{
@Override
public void renderTileEntityAt(TileEntity tileEntity, double x, double y, double z, float var8)
{
TileThermometer tile = (TileThermometer) tileEntity;
GL11.glPushMatrix();
RenderUtility.enableLightmap();
for (int side = 2; side < 6; side++)
{
RenderUtility.renderText((tile.isOverThreshold() ? "\u00a74" : "") + Math.round(tile.detectedTemperature) + " K", side, 0.8f, x, y + 0.1, z);
RenderUtility.renderText((tile.isOverThreshold() ? "\u00a74" : "\u00a71") + "Threshold: " + (tile.getThershold()) + " K", side, 1, x, y - 0.1, z);
if (tile.trackCoordinate != null)
{
RenderUtility.renderText(tile.trackCoordinate.intX() + ", " + tile.trackCoordinate.intY() + ", " + tile.trackCoordinate.intZ(), side, 0.5f, x, y - 0.3, z);
}
}
GL11.glPopMatrix();
}
}

View file

@ -0,0 +1,79 @@
package resonantinduction.atomic.process.sensor;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraftforge.common.ForgeDirection;
import resonant.lib.content.module.TileBlock;
import resonantinduction.core.Reference;
import universalelectricity.api.UniversalElectricity;
import universalelectricity.api.vector.Vector3;
/** Siren block */
public class TileSiren extends TileBlock
{
public TileSiren()
{
super(UniversalElectricity.machine);
}
@Override
public void onWorldJoin()
{
scheduelTick(1);
}
@Override
public void onNeighborChanged()
{
scheduelTick(1);
}
@Override
public void updateEntity()
{
if (worldObj == null)
{
return;
}
int metadata = worldObj.getBlockMetadata(x(), y(), z());
if (worldObj.getBlockPowerInput(x(), y(), z()) > 0)
{
float volume = 0.5f;
for (int i = 0; i < 6; i++)
{
Vector3 check = position().translate(ForgeDirection.getOrientation(i));
int blockID = check.getBlockID(worldObj);
if (blockID == blockID())
{
volume *= 1.5f;
}
}
worldObj.playSoundEffect(x(), y(), z(), Reference.PREFIX + "alarm", volume, 1f - 0.18f * (metadata / 15f));
scheduelTick(30);
}
}
@Override
protected boolean configure(EntityPlayer player, int side, Vector3 hit)
{
int metadata = world().getBlockMetadata(x(), y(), z());
if (player.isSneaking())
{
metadata -= 1;
}
else
{
metadata += 1;
}
metadata = Math.max(metadata % 16, 0);
world().setBlockMetadataWithNotify(x(), y(), z(), metadata, 2);
return true;
}
}

View file

@ -0,0 +1,351 @@
package resonantinduction.atomic.process.sensor;
import java.util.ArrayList;
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.material.Material;
import net.minecraft.client.renderer.texture.IconRegister;
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.Icon;
import net.minecraft.world.IBlockAccess;
import resonant.lib.content.module.TileBase;
import resonant.lib.network.PacketHandler;
import resonant.lib.network.Synced;
import resonant.lib.prefab.item.ItemBlockSaved;
import resonant.lib.thermal.ThermalGrid;
import resonant.lib.utility.inventory.InventoryUtility;
import resonantinduction.core.Reference;
import resonantinduction.core.ResonantInduction;
import universalelectricity.api.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;
/** Thermometer TileEntity */
@Optional.Interface(iface = "li.cil.oc.api.network.SimpleComponent", modid = "OpenComputers")
public class TileThermometer extends TileBase implements IPeripheral, SimpleComponent
{
public static final int MAX_THRESHOLD = 5000;
private static Icon iconSide;
@Synced
public float detectedTemperature = 295;
@Synced
public float previousDetectedTemperature = 295;
@Synced
public Vector3 trackCoordinate;
@Synced
private int threshold = 1000;
@Synced
private boolean isProvidingPower = false;
public TileThermometer()
{
super(Material.piston);
canProvidePower = true;
normalRender = false;
forceStandardRender = true;
itemBlock = ItemBlockThermometer.class;
}
@Override
public Icon getIcon(int side, int meta)
{
return side == 1 || side == 0 ? super.getIcon(side, meta) : iconSide;
}
@SideOnly(Side.CLIENT)
@Override
public void registerIcons(IconRegister iconRegister)
{
super.registerIcons(iconRegister);
iconSide = iconRegister.registerIcon(Reference.PREFIX + "machine");
}
@Override
protected boolean use(EntityPlayer player, int side, Vector3 hit)
{
if (player.isSneaking())
{
setThreshold(getThershold() + 100);
}
else
{
setThreshold(getThershold() - 100);
}
return true;
}
@Override
protected boolean configure(EntityPlayer player, int side, Vector3 hit)
{
if (player.isSneaking())
{
setThreshold(getThershold() - 10);
}
else
{
setThreshold(getThershold() + 10);
}
return true;
}
@Override
public int getStrongRedstonePower(IBlockAccess access, int side)
{
return isProvidingPower ? 15 : 0;
}
@Override
public ArrayList<ItemStack> getDrops(int metadata, int fortune)
{
return new ArrayList<ItemStack>();
}
@Override
public void onRemove(int par5, int par6)
{
ItemStack stack = ItemBlockSaved.getItemStackWithNBT(getBlockType(), world(), x(), y(), z());
InventoryUtility.dropItemStack(world(), center(), stack);
}
@Override
public void updateEntity()
{
super.updateEntity();
// Server only operation.
if (!worldObj.isRemote)
{
// Every ten ticks.
if (ticks % 10 == 0)
{
// Grab temperature from target or from ourselves.
if (trackCoordinate != null)
{
detectedTemperature = ThermalGrid.getTemperature(new VectorWorld(world(), trackCoordinate));
}
else
{
detectedTemperature = ThermalGrid.getTemperature(new VectorWorld(this));
}
// Send update packet if temperature is different or over temperature threshold.
if (detectedTemperature != previousDetectedTemperature || isProvidingPower != this.isOverThreshold())
{
previousDetectedTemperature = detectedTemperature;
isProvidingPower = isOverThreshold();
notifyChange();
PacketHandler.sendPacketToClients(getDescriptionPacket(), this.worldObj, new Vector3(this), 25);
}
}
}
}
@Override
public Packet getDescriptionPacket()
{
return ResonantInduction.PACKET_ANNOTATION.getPacket(this);
}
public void setTrack(Vector3 track)
{
trackCoordinate = track;
}
/** Reads a tile entity from NBT. */
@Override
public void readFromNBT(NBTTagCompound nbt)
{
super.readFromNBT(nbt);
threshold = nbt.getInteger("threshold");
if (nbt.hasKey("trackCoordinate"))
{
trackCoordinate = new Vector3(nbt.getCompoundTag("trackCoordinate"));
}
else
{
trackCoordinate = null;
}
}
/** Writes a tile entity to NBT. */
@Override
public void writeToNBT(NBTTagCompound nbt)
{
super.writeToNBT(nbt);
nbt.setInteger("threshold", threshold);
if (trackCoordinate != null)
{
nbt.setCompoundTag("trackCoordinate", this.trackCoordinate.writeToNBT(new NBTTagCompound()));
}
}
public int getThershold()
{
return threshold;
}
public void setThreshold(int newThreshold)
{
threshold = newThreshold % MAX_THRESHOLD;
if (threshold <= 0)
{
threshold = MAX_THRESHOLD;
}
markUpdate();
}
public boolean isOverThreshold()
{
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)
{
return new Object[]
{ this.detectedTemperature };
}
@Callback
@Optional.Method(modid = "OpenComputers")
public Object[] getWarningTemperature(Context context, Arguments args)
{
return new Object[]
{ this.getThershold() };
}
@Callback
@Optional.Method(modid = "OpenComputers")
public Object[] isAboveWarningTemperature(Context context, Arguments args)
{
return new Object[]
{ this.isOverThreshold() };
}
@Callback
@Optional.Method(modid = "OpenComputers")
public Object[] setWarningTemperature(Context context, Arguments args)
{
if (args.count() <= 0)
{
throw new IllegalArgumentException("Not enough Arguments. Must provide one argument");
}
if (args.count() >= 2)
{
throw new IllegalArgumentException("Too many Arguments. Must provide one argument");
}
if (!(args.isInteger(0)))
{
throw new IllegalArgumentException("Invalid Argument. Must provide an Integer");
}
synchronized (this)
{
this.setThreshold(args.checkInteger(0));
}
return new Object[]
{ this.threshold == args.checkInteger(0) };
}
}

View file

@ -0,0 +1,33 @@
package resonantinduction.atomic.process.turbine;
import net.minecraft.block.material.Material;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.world.World;
import resonant.lib.prefab.turbine.BlockTurbine;
import resonant.lib.render.block.BlockRenderingHandler;
import resonantinduction.atomic.Atomic;
import resonantinduction.core.Reference;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
public class BlockElectricTurbine extends BlockTurbine
{
public BlockElectricTurbine(int id)
{
super(id, Material.iron);
setTextureName(Reference.PREFIX + "machine");
}
@SideOnly(Side.CLIENT)
@Override
public int getRenderType()
{
return BlockRenderingHandler.ID;
}
@Override
public TileEntity createNewTileEntity(World var1)
{
return new TileElectricTurbine();
}
}

View file

@ -0,0 +1,109 @@
package resonantinduction.atomic.process.turbine;
import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.ResourceLocation;
import net.minecraftforge.client.model.AdvancedModelLoader;
import net.minecraftforge.client.model.IModelCustom;
import org.apache.commons.lang3.ArrayUtils;
import org.lwjgl.opengl.GL11;
import resonant.lib.prefab.turbine.TileTurbine;
import resonantinduction.atomic.Atomic;
import resonantinduction.core.Reference;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
@SideOnly(Side.CLIENT)
public class RenderElectricTurbine extends TileEntitySpecialRenderer
{
public static final IModelCustom MODEL_SMALL = AdvancedModelLoader.loadModel(Reference.MODEL_DIRECTORY + "turbineSmall.tcn");
public static final IModelCustom MODEL_LARGE = AdvancedModelLoader.loadModel(Reference.MODEL_DIRECTORY + "turbineLarge.tcn");
public static final ResourceLocation SMALL_TEXTURE = new ResourceLocation(Reference.DOMAIN, Reference.MODEL_PATH + "turbineSmall.png");
public static final ResourceLocation LARGE_TEXTURE = new ResourceLocation(Reference.DOMAIN, Reference.MODEL_PATH + "turbineLarge.png");
@Override
public void renderTileEntityAt(TileEntity t, double x, double y, double z, float f)
{
TileTurbine tile = (TileTurbine) t;
if (tile.getMultiBlock().isPrimary())
{
// Texture file
GL11.glPushMatrix();
GL11.glTranslated(x + 0.5, y + 0.5, z + 0.5);
if (tile.getMultiBlock().isConstructed())
{
bindTexture(LARGE_TEXTURE);
final String[] blades = new String[]
{ "Blade1", "Blade2", "Blade3", "Blade4", "Blade5", "Blade6" };
final String[] mediumBlades = new String[]
{ "MediumBlade1", "MediumBlade2", "MediumBlade3", "MediumBlade4", "MediumBlade5", "MediumBlade6" };
final String[] largeBlades = new String[]
{ "LargeBlade1", "LargeBlade2", "LargeBlade3", "LargeBlade4", "LargeBlade5", "LargeBlade6" };
GL11.glPushMatrix();
GL11.glRotated(Math.toDegrees(tile.rotation), 0, 1, 0);
MODEL_LARGE.renderOnly(blades);
MODEL_LARGE.renderOnly(largeBlades);
GL11.glPopMatrix();
GL11.glPushMatrix();
GL11.glRotated(-Math.toDegrees(tile.rotation), 0, 1, 0);
MODEL_LARGE.renderOnly(mediumBlades);
GL11.glPopMatrix();
MODEL_LARGE.renderAllExcept(ArrayUtils.addAll(ArrayUtils.addAll(blades, mediumBlades), largeBlades));
}
else
{
GL11.glScalef(1f, 1.1f, 1f);
bindTexture(SMALL_TEXTURE);
final String[] bladesA = new String[3];
for (int i = 0; i < bladesA.length; i++)
{
bladesA[i] = "BLADE A" + (i + 1) + " SPINS";
}
final String[] sheildsA = new String[6];
for (int i = 0; i < sheildsA.length; i++)
{
sheildsA[i] = "SHIELD A" + (i + 1) + " SPINS";
}
final String[] bladesB = new String[3];
for (int i = 0; i < bladesB.length; i++)
{
bladesB[i] = "BLADE B" + (i + 1) + " SPINS";
}
final String[] sheildsB = new String[6];
for (int i = 0; i < sheildsB.length; i++)
{
sheildsB[i] = "SHIELD B" + (i + 1) + " SPINS";
}
final String[] renderA = ArrayUtils.addAll(bladesA, sheildsA);
final String[] renderB = ArrayUtils.addAll(bladesB, sheildsB);
GL11.glPushMatrix();
GL11.glRotated(Math.toDegrees(tile.rotation), 0, 1, 0);
MODEL_SMALL.renderOnly(renderA);
GL11.glPopMatrix();
GL11.glPushMatrix();
GL11.glRotated(-Math.toDegrees(tile.rotation), 0, 1, 0);
MODEL_SMALL.renderOnly(renderB);
GL11.glPopMatrix();
MODEL_SMALL.renderAllExcept(ArrayUtils.addAll(renderA, renderB));
}
GL11.glPopMatrix();
}
}
}

View file

@ -0,0 +1,56 @@
package resonantinduction.atomic.process.turbine;
import net.minecraftforge.common.ForgeDirection;
import net.minecraftforge.fluids.Fluid;
import resonant.api.IBoilHandler;
import resonant.lib.prefab.turbine.TileTurbine;
import resonantinduction.atomic.Atomic;
import resonantinduction.core.Settings;
public class TileElectricTurbine extends TileTurbine implements IBoilHandler
{
public TileElectricTurbine()
{
super();
maxPower = 5000000;
}
@Override
public void updateEntity()
{
if (getMultiBlock().isConstructed())
{
torque = defaultTorque * 500 * getArea();
}
else
{
torque = defaultTorque * 500;
}
super.updateEntity();
}
@Override
public void onProduce()
{
energy.receiveEnergy((long) (power * Settings.turbineOutputMultiplier), true);
produce();
}
@Override
public void playSound()
{
if (this.worldObj.getWorldTime() % (Atomic.SECOND_IN_TICKS * 1.3F) == 0)
{
double maxVelocity = (getMaxPower() / torque) * 4;
float percentage = angularVelocity * 4 / (float) maxVelocity;
this.worldObj.playSoundEffect(this.xCoord, this.yCoord, this.zCoord, "atomicscience:turbine", percentage, 1.0F);
}
}
@Override
public boolean canFill(ForgeDirection from, Fluid fluid)
{
return from == ForgeDirection.DOWN && super.canFill(from, fluid);
}
}

View file

@ -0,0 +1,149 @@
package resonantinduction.atomic.process.turbine;
import net.minecraft.block.material.Material;
import net.minecraft.client.renderer.texture.IconRegister;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.Icon;
import net.minecraftforge.common.ForgeDirection;
import net.minecraftforge.fluids.Fluid;
import net.minecraftforge.fluids.FluidContainerRegistry;
import net.minecraftforge.fluids.FluidStack;
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 cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
/** Funnel for gas. */
public class TileFunnel extends TileBase implements IBoilHandler
{
private static Icon iconTop;
private final FluidTank tank = new FluidTank(FluidContainerRegistry.BUCKET_VOLUME * 16);
public TileFunnel()
{
super(Material.iron);
}
@Override
public Icon getIcon(int side, int meta)
{
return side == 1 || side == 0 ? iconTop : super.getIcon(side, meta);
}
@SideOnly(Side.CLIENT)
@Override
public void registerIcons(IconRegister iconRegister)
{
super.registerIcons(iconRegister);
iconTop = iconRegister.registerIcon(domain + name + "_top");
}
@Override
public void updateEntity()
{
super.updateEntity();
if (tank.getFluidAmount() > 0)
{
TileEntity tileEntity = this.worldObj.getBlockTileEntity(this.xCoord, this.yCoord + 1, this.zCoord);
if (tileEntity instanceof IFluidHandler)
{
IFluidHandler handler = (IFluidHandler) tileEntity;
if (handler.canFill(ForgeDirection.DOWN, tank.getFluid().getFluid()))
{
FluidStack drainedStack = tank.drain(tank.getCapacity(), false);
if (drainedStack != null)
{
tank.drain(handler.fill(ForgeDirection.DOWN, drainedStack, true), true);
}
}
}
}
}
@Override
public void readFromNBT(NBTTagCompound tag)
{
super.readFromNBT(tag);
tank.writeToNBT(tag);
}
@Override
public void writeToNBT(NBTTagCompound tag)
{
super.writeToNBT(tag);
tank.readFromNBT(tag);
}
/** Tank Methods */
/* IFluidHandler */
@Override
public int fill(ForgeDirection from, FluidStack resource, boolean doFill)
{
return tank.fill(resource, doFill);
}
@Override
public FluidStack drain(ForgeDirection from, int maxDrain, boolean doDrain)
{
return this.tank.drain(maxDrain, doDrain);
}
@Override
public FluidStack drain(ForgeDirection from, FluidStack resource, boolean doDrain)
{
if (resource == null || !resource.isFluidEqual(tank.getFluid()))
{
return null;
}
return tank.drain(resource.amount, doDrain);
}
@Override
public boolean canFill(ForgeDirection from, Fluid fluid)
{
if (fluid.isGaseous() && from == ForgeDirection.DOWN)
{
return true;
}
return false;
}
@Override
public boolean canDrain(ForgeDirection from, Fluid fluid)
{
if (fluid.isGaseous() && from == ForgeDirection.UP)
{
return true;
}
return false;
}
@Override
public FluidTankInfo[] getTankInfo(ForgeDirection from)
{
return new FluidTankInfo[]
{ tank.getInfo() };
}
@SideOnly(Side.CLIENT)
@Override
protected TileRender newRenderer()
{
return new ConnectedTextureRenderer(this, Reference.PREFIX + "funnel_edge");
}
}

View file

@ -0,0 +1,81 @@
package resonantinduction.atomic.schematic;
import java.util.HashMap;
import net.minecraftforge.common.ForgeDirection;
import resonant.lib.schematic.Schematic;
import resonant.lib.type.Pair;
import resonantinduction.atomic.Atomic;
import universalelectricity.api.vector.Vector3;
public class SchematicAccelerator extends Schematic
{
@Override
public String getName()
{
return "schematic.accelerator.name";
}
@Override
public HashMap<Vector3, Pair<Integer, Integer>> getStructure(ForgeDirection dir, int size)
{
HashMap<Vector3, Pair<Integer, Integer>> returnMap = new HashMap<Vector3, Pair<Integer, Integer>>();
int r = size;
for (int x = -r; x < r; x++)
{
for (int z = -r; z < r; z++)
{
for (int y = -1; y <= 1; y++)
{
if (x == -r || x == r - 1 || z == -r || z == r - 1)
{
returnMap.put(new Vector3(x, y, z), new Pair(Atomic.blockElectromagnet.blockID, 0));
}
}
}
}
r = size - 2;
for (int x = -r; x < r; x++)
{
for (int z = -r; z < r; z++)
{
for (int y = -1; y <= 1; y++)
{
if (x == -r || x == r - 1 || z == -r || z == r - 1)
{
returnMap.put(new Vector3(x, y, z), new Pair(Atomic.blockElectromagnet.blockID, 0));
}
}
}
}
r = size - 1;
for (int x = -r; x < r; x++)
{
for (int z = -r; z < r; z++)
{
for (int y = -1; y <= 1; y++)
{
if (x == -r || x == r - 1 || z == -r || z == r - 1)
{
if (y == -1 || y == 1)
{
returnMap.put(new Vector3(x, y, z), new Pair(Atomic.blockElectromagnet.blockID, 1));
}
else if (y == 0)
{
returnMap.put(new Vector3(x, y, z), new Pair(0, 0));
}
}
}
}
}
return returnMap;
}
}

View file

@ -0,0 +1,67 @@
package resonantinduction.atomic.schematic;
import java.util.HashMap;
import net.minecraft.block.Block;
import net.minecraftforge.common.ForgeDirection;
import resonant.lib.schematic.Schematic;
import resonant.lib.type.Pair;
import resonantinduction.atomic.Atomic;
import universalelectricity.api.vector.Vector3;
public class SchematicBreedingReactor extends Schematic
{
@Override
public String getName()
{
return "schematic.breedingReactor.name";
}
@Override
public HashMap<Vector3, Pair<Integer, Integer>> getStructure(ForgeDirection dir, int size)
{
HashMap<Vector3, Pair<Integer, Integer>> returnMap = new HashMap<Vector3, Pair<Integer, Integer>>();
int r = Math.max(size, 2);
for (int x = -r; x <= r; x++)
{
for (int z = -r; z <= r; z++)
{
returnMap.put(new Vector3(x, 0, z), new Pair(Block.waterStill.blockID, 0));
}
}
r--;
for (int x = -r; x <= r; x++)
{
for (int z = -r; z <= r; z++)
{
Vector3 targetPosition = new Vector3(x, 1, z);
if (new Vector3(x, 0, z).getMagnitude() <= 2)
{
if (!((x == -r || x == r) && (z == -r || z == r)))
{
returnMap.put(new Vector3(x, 0, z), new Pair(Atomic.blockReactorCell.blockID, 0));
returnMap.put(new Vector3(x, -1, z), new Pair(Atomic.blockThermometer.blockID, 0));
returnMap.put(new Vector3(x, -3, z), new Pair(Atomic.blockSiren.blockID, 0));
returnMap.put(new Vector3(x, -2, z), new Pair(Block.redstoneWire.blockID, 0));
}
else
{
returnMap.put(new Vector3(x, -1, z), new Pair(Atomic.blockControlRod.blockID, 0));
returnMap.put(new Vector3(x, -2, z), new Pair(Block.pistonStickyBase.blockID, 1));
}
}
}
}
returnMap.put(new Vector3(0, -2, 0), new Pair(Block.stone.blockID, 0));
returnMap.put(new Vector3(0, -3, 0), new Pair(Block.stone.blockID, 0));
returnMap.put(new Vector3(), new Pair(Atomic.blockReactorCell.blockID, 0));
return returnMap;
}
}

View file

@ -0,0 +1,121 @@
package resonantinduction.atomic.schematic;
import java.util.HashMap;
import net.minecraft.block.Block;
import net.minecraftforge.common.ForgeDirection;
import resonant.lib.schematic.Schematic;
import resonant.lib.type.Pair;
import resonantinduction.atomic.Atomic;
import universalelectricity.api.vector.Vector3;
public class SchematicFissionReactor extends Schematic
{
@Override
public String getName()
{
return "schematic.fissionReactor.name";
}
@Override
public HashMap<Vector3, Pair<Integer, Integer>> getStructure(ForgeDirection dir, int size)
{
HashMap<Vector3, Pair<Integer, Integer>> returnMap = new HashMap<Vector3, Pair<Integer, Integer>>();
if (size <= 1)
{
int r = 2;
for (int x = -r; x <= r; x++)
{
for (int z = -r; z <= r; z++)
{
Vector3 targetPosition = new Vector3(x, 0, z);
returnMap.put(targetPosition, new Pair(Block.waterStill.blockID, 0));
}
}
r -= 1;
/** Create turbines and control rods */
for (int x = -r; x <= r; x++)
{
for (int z = -r; z <= r; z++)
{
Vector3 targetPosition = new Vector3(x, 1, z);
returnMap.put(targetPosition, new Pair(Atomic.blockElectricTurbine.blockID, 0));
if (!((x == -r || x == r) && (z == -r || z == r)) && new Vector3(x, 0, z).getMagnitude() <= 1)
{
returnMap.put(new Vector3(x, -1, z), new Pair(Atomic.blockControlRod.blockID, 0));
returnMap.put(new Vector3(x, -2, z), new Pair(Block.pistonStickyBase.blockID, 1));
}
}
}
returnMap.put(new Vector3(0, -1, 0), new Pair(Atomic.blockThermometer.blockID, 0));
// TODO: IF Siren is a Tile, don't do this. Redstone can't hold it.
returnMap.put(new Vector3(0, -3, 0), new Pair(Atomic.blockSiren.blockID, 0));
returnMap.put(new Vector3(0, -2, 0), new Pair(Block.redstoneWire.blockID, 0));
returnMap.put(new Vector3(), new Pair(Atomic.blockReactorCell.blockID, 0));
}
else
{
int r = 2;
for (int y = 0; y < size; y++)
{
for (int x = -r; x <= r; x++)
{
for (int z = -r; z <= r; z++)
{
Vector3 targetPosition = new Vector3(x, y, z);
Vector3 leveledPosition = new Vector3(0, y, 0);
if (y < size - 1)
{
if (targetPosition.distance(leveledPosition) == 2)
{
returnMap.put(targetPosition, new Pair(Atomic.blockControlRod.blockID, 0));
/** Place piston base to push control rods in. */
int rotationMetadata = 0;
Vector3 offset = new Vector3(x, 0, z).normalize();
for (ForgeDirection checkDir : ForgeDirection.VALID_DIRECTIONS)
{
if (offset.x == checkDir.offsetX && offset.y == checkDir.offsetY && offset.z == checkDir.offsetZ)
{
rotationMetadata = checkDir.getOpposite().ordinal();
break;
}
}
returnMap.put(targetPosition.clone().translate(offset), new Pair(Block.pistonStickyBase.blockID, rotationMetadata));
}
else if (x == -r || x == r || z == -r || z == r)
{
returnMap.put(targetPosition, new Pair(Block.glass.blockID, 0));
}
else if (x == 0 && z == 0)
{
returnMap.put(targetPosition, new Pair(Atomic.blockReactorCell.blockID, 0));
}
else
{
returnMap.put(targetPosition, new Pair(Block.waterMoving.blockID, 0));
}
}
else if (targetPosition.distance(leveledPosition) < 2)
{
returnMap.put(targetPosition, new Pair(Atomic.blockElectricTurbine.blockID, 0));
}
}
}
}
}
return returnMap;
}
}

View file

@ -0,0 +1,74 @@
package resonantinduction.atomic.schematic;
import java.util.HashMap;
import net.minecraftforge.common.ForgeDirection;
import resonant.lib.schematic.Schematic;
import resonant.lib.type.Pair;
import resonantinduction.atomic.Atomic;
import universalelectricity.api.vector.Vector3;
public class SchematicFusionReactor extends Schematic
{
@Override
public String getName()
{
return "schematic.fusionReactor.name";
}
@Override
public HashMap<Vector3, Pair<Integer, Integer>> getStructure(ForgeDirection dir, int size)
{
HashMap<Vector3, Pair<Integer, Integer>> returnMap = new HashMap<Vector3, Pair<Integer, Integer>>();
/** Fusion Torus */
int radius = size + 2;
for (int x = -radius; x <= radius; x++)
{
for (int z = -radius; z <= radius; z++)
{
for (int y = 0; y <= size; y++)
{
Vector3 position = new Vector3(x, y, z);
double magnitude = Math.sqrt(x * x + z * z);
if (!returnMap.containsKey(position))
{
returnMap.put(position, new Pair(0, 0));
}
if (magnitude <= radius)
{
if (y == 0 || y == size)
{
if (magnitude >= 1)
{
double yDeviation = (y == 0 ? size / 3 : -size / 3) + (y == 0 ? -1 : 1) * Math.sin(magnitude / radius * Math.PI) * size / 2d;
Vector3 newPos = position.clone().translate(0, yDeviation, 0);
returnMap.put(newPos.round(), new Pair(Atomic.blockElectromagnet.blockID, 1));
}
}
else if (magnitude > radius - 1)
{
returnMap.put(position, new Pair(Atomic.blockElectromagnet.blockID, 0));
}
}
}
}
}
/** Fusion Core */
for (int y = 0; y < size; y++)
{
returnMap.put(new Vector3(0, y, 0), new Pair(Atomic.blockReactorCell.blockID, 0));
returnMap.put(new Vector3(1, y, 0), new Pair(Atomic.blockElectromagnet.blockID, 0));
returnMap.put(new Vector3(0, y, 1), new Pair(Atomic.blockElectromagnet.blockID, 0));
returnMap.put(new Vector3(0, y, -1), new Pair(Atomic.blockElectromagnet.blockID, 0));
returnMap.put(new Vector3(-1, y, 0), new Pair(Atomic.blockElectromagnet.blockID, 0));
}
returnMap.put(new Vector3(0, 0, 0), new Pair(Atomic.blockReactorCell.blockID, 0));
return returnMap;
}
}

View file

@ -108,7 +108,7 @@ public class Electrical
@EventHandler
public void preInit(FMLPreInitializationEvent evt)
{
modproxies = new ProxyHandler();
modproxies = new ProxyHandler();
NetworkRegistry.instance().registerGuiHandler(this, proxy);
Settings.CONFIGURATION.load();

Binary file not shown.

Binary file not shown.

Binary file not shown.

Binary file not shown.

Binary file not shown.

Binary file not shown.

Binary file not shown.

Binary file not shown.

Binary file not shown.

Binary file not shown.

View file

@ -1,2 +1,2 @@
rootProject.name = 'core'
include 'archaic', 'mechanical', 'electrical'
include 'archaic', 'mechanical', 'electrical', 'atomic'

View file

@ -0,0 +1,305 @@
# German @author Vexatos
# If a localization includes %v it is some data that is calculated. Such as attributes on a cable.
# The %v may be followed by a number if there are multiple pieces of calculated data, but it will be explained in a comment.
# A % followed by a number is used for colors. The exact usage will be outlined in the comment above the localization.
itemGroup.resonantinduction=Resonant Induction
itemGroup.resonantinduction.core=Resonant Induction Core
meta.resonantinduction.description=Resonant Induction ist eine Minecraft-Mod, die sich auf die Manipulation von Elektrizit\u00E4t und kabelloser Technologie spezialisiert. Wolltest du schon immer flammende elektrische Schocks durch deine Basis fliegen sehen? Dann bist du hier richtig!
meta.resonantinduction.credits=Dank an Archadia f\u00FCr die tollen assets!
fluid.mixture=Mixtur
toolmode.link.name=Verbinden
### Schematics
schematic.windTurbine.name=Windturbine
schematic.waterTurbine.name=Wasserturbine
### Core
misc.resonantinduction.ingot=Barren
item.resonantinduction\:ingot.name=%vbarren
item.resonantinduction\:oreDust.name=%vstaub
item.resonantinduction\:oreDust.tooltip=Shift-rechtsklicke auf einen Kessel zum Raffinieren.
item.resonantinduction\:oreRefinedDust.name=Gereinigter %vstaub
item.resonantinduction\:oreRubble.name=%vschutt
item.resonantinduction\:bucketMixture.name=Eimer mit %v
item.resonantinduction\:bucketMolten.name=Eimer mit %v
### Archaic Module
## machineMaterials
tile.resonantinduction\:gutter.name=Rinne
tile.resonantinduction\:gutter.tooltip=Ein primitiver Weg, Fl\u00FCssigkeiten zu transportieren.
tile.resonantinduction\:machineMaterial.0.name=Industrieziegel
tile.resonantinduction\:machineMaterial.1.name=Industrieziegel
tile.resonantinduction\:machineMaterial.2.name=Gemei\u00DFelter Industrieziegel
tile.resonantinduction\:machineMaterial.3.name=Industriepflasterstein
tile.resonantinduction\:machineMaterial.4.name=Br\u00FCchiger Industriestein
tile.resonantinduction\:machineMaterial.5.name=Industriestein
tile.resonantinduction\:machineMaterial.6.name=Industriesteinstufe
tile.resonantinduction\:machineMaterial.7.name=Moosiger Industriestein
tile.resonantinduction\:machineMaterial.8.name=Dunkler Stahl
tile.resonantinduction\:machineMaterial.9.name=Get\u00F6nter Stahl
tile.resonantinduction\:machineMaterial.10.name=Stahl
## Items
item.resonantinduction\:imprint.name=Pr\u00E4gung
item.resonantinduction\:hammer.name=Hammer
item.resonantinduction\:handCrank.name=Handkurbel
## Machines
tile.resonantinduction\:castingMold.name=Gussform
tile.resonantinduction\:castingMold.tooltip=Gie\u00DFe fl\u00FCssiges Metall in die Form, um einen Barren zu gie\u00Dfen.
tile.resonantinduction\:millstone.name=M\u00FChlstein
tile.resonantinduction\:millstone.tooltip=Gib etwas Schutt hinein und nutze eine Handkurbel, um den Schutt zu Staub zu mahlen.
tile.resonantinduction\:imprinter.name=Pr\u00E4ger
tile.resonantinduction\:firebox.0.name=Feuerb\u00FCchse
tile.resonantinduction\:firebox.1.name=Elektrische Feuerb\u00FCchse
tile.resonantinduction\:hotPlate.name=Heizplatte
tile.resonantinduction\:engineeringTable.name=Konstruktionstisch
engineerTable.config.inventory.true=Konstruktionstisch ist nun mit nahen Inventaren verbunden.
engineerTable.config.inventory.false=Konstruktionstisch ist nun mit nahen Inventaren getrennt.
## Transport
tile.resonantinduction\:turntable.name=Drehscheibe
tile.resonantinduction\:crate.0.name=Holzkiste
tile.resonantinduction\:crate.1.name=Eisenkiste
tile.resonantinduction\:crate.2.name=Stahlkiste
crate.orefilter.true= OreDictionary-Unterst\u00FCtzung aktiviert
crate.orefilter.false= OreDictionary-Unterst\u00FCtzung deaktiviert
crate.tooltip.amount= Menge:
tile.resonantinduction\:crate.0.tooltip=Rechtsklicke, um Items hinzuzuf\u00Fcgen, linksklicke, um Items zu entfernen, Strg-klicke, um Item-Filtermodus zu setzen
tile.resonantinduction\:crate.1.tooltip=Rechtsklicke, um Items hinzuzuf\u00Fcgen, linksklicke, um Items zu entfernen, Strg-klicke, um Item-Filtermodus zu setzen
tile.resonantinduction\:crate.2.tooltip=Rechtsklicke, um Items hinzuzuf\u00Fcgen, linksklicke, um Items zu entfernen, Strg-klicke, um Item-Filtermodus zu setzen
### Mechanical Module
## Energy
item.resonantinduction\:gear.0.name=Holzzahnrad
item.resonantinduction\:gear.1.name=Steinzahnrad
item.resonantinduction\:gear.2.name=Metallzahnrad
item.resonantinduction\:gear.10.name=K\u00FCrbiszahnrad
item.resonantinduction\:gearShaft.0.name=Holzzahnradschaft
item.resonantinduction\:gearShaft.1.name=Steinzahnradschaft
item.resonantinduction\:gearShaft.2.name=Metallzahnradschaft
tile.resonantinduction\:windTurbine.0.name=H\u00F6lzerne Windturbine
tile.resonantinduction\:windTurbine.0.tooltip=Die h\u00F6lzerne Windturbine ist leicht, fragil und dreht sich schnell.
tile.resonantinduction\:windTurbine.1.name=Steinerne Windturbine
tile.resonantinduction\:windTurbine.1.tooltip=Die steinerne Windturbine ist schwer, kr\u00E4ftig und strapazierf\u00E4hig.
tile.resonantinduction\:windTurbine.2.name=Metall-Windturbine
tile.resonantinduction\:windTurbine.2.tooltip=Die Metall-Windturbine ist kr\u00E4ftig und agil.
tile.resonantinduction\:waterTurbine.0.name=H\u00F6lzerne Wasserturbine
tile.resonantinduction\:waterTurbine.0.tooltip=Die h\u00F6lzerne Wasserturbine ist leicht und bewegt sich schnell
tile.resonantinduction\:waterTurbine.1.name=Steinerne Wasserturbine
tile.resonantinduction\:waterTurbine.1.tooltip=Die steinerne Wasserturbine ist schwer,kr\u00E4ftig und strapazierf\u00E4hig.
tile.resonantinduction\:waterTurbine.2.name=Metall-Wasserturbine
tile.resonantinduction\:waterTurbine.2.tooltip=Die Metall-Wasserturbine ist kr\u00E4ftig und agil.
## Transport
item.resonantinduction\:pipe.ceramic.name=Keramikrohr
item.resonantinduction\:pipe.bronze.name=Bronzerohr
item.resonantinduction\:pipe.plastic.name=Plastikrohr
item.resonantinduction\:pipe.iron.name=Eisenrohr
item.resonantinduction\:pipe.steel.name=Stahlrohr
item.resonantinduction\:pipe.fiberglass.name=Glasfaserrohr
tile.resonantinduction\:pump.name=Pumpe
tile.resonantinduction\:grate.name=Gitter
tile.resonantinduction\:conveyorBelt.name=Flie\u00DFband
tile.resonantinduction\:tank.name=Tank
tile.resonantinduction\:tank.tooltip=Shift-rechtsklicke, um mit enthaltener Fl\u00FCssigkeit aufzunehmen.
tile.resonantinduction\:detector.name=Detektor
tile.resonantinduction\:detector.tooltip=Sendet ein Redstone-Signal, wenn er ein Item entdeckt. Konfiguriere, um den Pr\u00E4gungsfilter zu invertieren.
tile.resonantinduction\:manipulator.name=Manipulator
tile.resonantinduction\:rejector.name=Rejektor
tile.resonantinduction\:sorter.name=Sortierer
tile.resonantinduction\:breaker.name=Blockzerst\u00F6rer
tile.resonantinduction\:placer.name=Blockplatzierer
## Machines and Processing
tile.resonantinduction\:mixer.name=Mixer
tile.resonantinduction\:mixer.tooltip=Der Mixer mischt Staub mit Wasser, um den Erzstaub zu reinigen. Der Mixer ben\u00F6tigt eine hohe Geschwindigkeit, um Staub zu reinigen.
tile.resonantinduction\:mechanicalPiston.name=Mechanischer Kolben
tile.resonantinduction\:grindingWheel.name=Mahlwerkrad
tile.resonantinduction\:grindingWheel.tooltip=Das Mahlwerkrad mahlt Erze zu Schutt und Staub. Gr\u00F6\u00DFeres Drehmoment erm\u00F6glicht schnelleres Mahlen.
tile.resonantinduction\:filter.name=Filter
resonantinduction.machine.grinder=Mahlwerk
resonantinduction.machine.crusher=Zersto\u00DFer
resonantinduction.machine.mixer=Mixer
resonantinduction.machine.sawmill=S\u00E4gewerk
resonantinduction.machine.smelter=Schmelzer
### Electrical Module
## Blocks
tile.resonantinduction\:tesla.name=Teslaspule
tile.resonantinduction\:tesla.tooltip=\u00DCbertr\u00E4gt Strom drahtlos. Verbinde mit dem Konfigurator f\u00FCr Teleportation zwischen Dimensionen.
item.resonantinduction\:levitator.name=Elektromagnetischer Levitator
tile.resonantinduction\:battery.name=Batterie
tile.resonantinduction\:armbot.name=Roboterarm
tile.resonantinduction\:encoder.name=Kodierer
item.resonantinduction\:charger.name=Ladeplatte
item.resonantinduction\:insulation.name=Isolierung
## Generators
tile.resonantinduction\:solarPanel.name=Solarmodul
tile.resonantinduction\:motor.name=Elektromotor
tile.resonantinduction\:thermopile.name=Thermos\u00E4ule
tile.resonantinduction\:thermopile.tooltip=Generiert eine Spannung proportional zu lokaler Temperaturdifferenz.
#Transport
item.resonantinduction\:disk.name=Programmplatte
## Energy
item.resonantinduction\:wire.copper.name=Kupferkabel
item.resonantinduction\:wire.tin.name=Zinnkabel
item.resonantinduction\:wire.iron.name=Eisenkabel
item.resonantinduction\:wire.aluminum.name=Aluminiumkabel
item.resonantinduction\:wire.silver.name=Silberkabel
item.resonantinduction\:wire.superconductor.name=Supraleitkabel
item.resonantinduction\:transformer.name=Transformator
item.resonantinduction\:multimeter.name=Multimeter
item.resonantinduction\:multimeter.tooltip=Multimeter ist eine Platte, die Energie- und Fl\u00FCssigkeitsinformationen eines Blocks anzeigt.
### Quantum Tier
tile.resonantinduction\:quantumGate.name=Quantentor
item.resonantinduction\:quantumGlyph.0.name=Nullum-Glyphe
item.resonantinduction\:quantumGlyph.1.name=Monogon-Glyphe
item.resonantinduction\:quantumGlyph.2.name=Digon-Glyphe
item.resonantinduction\:quantumGlyph.3.name=Trigon-Glyphe
item.resonantinduction\:quantumGlyph.4.name=Tetragon-Glyphe
## Tool-tips
tooltip.mixture=Mixtur
tooltip.molten=Geschmolzenem
tooltip.pipe.rate=Flie\u00DFrate: %v
tooltip.pipe.pressure=Max-Druck: %v
tooltip.wire.resistance=Widerstand: %v
tooltip.wire.current=Stromst\u00E4rke: %v
tooltip.wire.damage=Schaden: %v
tooltip.wire.helpText=Die Energietransferrate kann erh\u00F6ht sowie der Energieverlust reduziert werden, wenn eine h\u00F6here Spannung verwendet wird.
# %0 is the color for the charge level, %1 is grey to reset it back to normal (optional), %v0 is the current charge, %v1 is the max charge
tooltip.battery.energy=Energie: %0%v0 / %v1
tooltip.noInformation=Keine Information
tooltip.tier=Stufe
tooltip.empty=Leer
tooltip.noOutput=Kein Resultat
tooltip.noImprint=Keine Pr\u00E4gung
tooltip.graph.energy=Energie
tooltip.graph.power=Energie
tooltip.graph.capacity=Kapazit\u00E4t
tooltip.graph.voltage=Spannung
tooltip.graph.torque=Drehmoment
tooltip.graph.speed=Winkelgeschw.
tooltip.graph.fluid=Fl\u00FCssigkeit
tooltip.graph.temperature=Temperatur
tooltip.graph.pressure=Druck
## GUI Strings that can't be any other localization
gui.resonantinduction.multimeter.toggle=Wechseln
gui.resonantinduction.multimeter.toggleDetection=Erkennung wechseln
gui.resonantinduction.multimeter.toggleGraph=Graphen wechseln
gui.resonantinduction.multimeter.averageEnergy=Energiedurchschnitt:
gui.resonantinduction.multimeter.energy=Energie:
gui.resonantinduction.multimeter.redstone=Versende Redstone, wenn...
gui.resonantinduction.multimeter.logic=Logik:
gui.resonantinduction.multimeter.none=Nie
gui.resonantinduction.multimeter.lessThan=Unter
gui.resonantinduction.multimeter.lessThanOrEqual=Unter oder Gleich Wie
gui.resonantinduction.multimeter.equal=Gleich Wie
gui.resonantinduction.multimeter.greaterThanOrEqual=\u00DCber oder Gleich Wie
gui.resonantinduction.multimeter.greaterThan=\u00DCber
## Messages to players
message.multimeter.onUse=Energie: %v J
message.tesla.toggleAttack=\u00C4ndere Energieangriff auf: %v
# %v0 is the tile that's linking to the other (usually %v0 is a tesla), the others are coordinates in the standard [x, y, z]
message.tesla.pair=%v0 mit [%v1, %v2, %v3] verbunden
message.tesla.mode=Tesla-Empfangsmodus ist nun %v
### Atomic Module
## Translated by Vexatos
itemGroup.atomicscience=Atomic Science
potion.radiation=Strahlung
death.attack.radiation=%1$s starb durch Verstrahlung.
## Schematic
schematic.accelerator.name=Teilchenbeschleuniger
schematic.breedingReactor.name=Brutreaktor
schematic.fissionReactor.name=Kernreaktor
schematic.fusionReactor.name=Fusionsreaktor
## Fluids
fluid.uraniumhexafluoride=Uranhexafluorid
fluid.deuterium=Deuterium
fluid.tritium=Tritium
fluid.plasma=Plasma
fluid.steam=Dampf
fluid.toxicwaste=Giftm\u00FCll
fluid.tile.water=Wasser
item.resonantinduction\:hazmatMask.name=Chemikalienschutzmaske
item.resonantinduction\:hazmatBody.name=Chemikalienschutzjacke
item.resonantinduction\:hazmatLeggings.name=Chemikalienschutzhose
item.resonantinduction\:hazmatBoots.name=Chemikalienschutzstiefel
item.resonantinduction\:bucketToxicWaste.name=Giftm\u00FClleimer
## Cells
item.resonantinduction\:cellEmpty.name=Leere Zelle
item.resonantinduction\:cellWater.name=Wasserzelle
item.resonantinduction\:cellDeuterium.name=Deuteriumzelle
item.resonantinduction\:cellTritium.name=Tritiumzelle
item.resonantinduction\:darkMatter.name=Dunkle Materie
item.resonantinduction\:antimatter.0.name=Antimaterie
item.resonantinduction\:antimatter.0.tooltip=1 Gramm
item.resonantinduction\:antimatter.1.name=Antimaterie
item.resonantinduction\:antimatter.1.tooltip=125 Milligramm
## Uranium Related Items
tile.resonantinduction\:uraniumOre.name=Uranerz
item.resonantinduction\:yellowcake.name=Yellowcake
item.resonantinduction\:uranium.0.name=Uran-235
item.resonantinduction\:uranium.0.tooltip=Angereichertes Uran
item.resonantinduction\:uranium.1.name=Uran-238
item.resonantinduction\:uranium.1.tooltip=Bruturan
item.resonantinduction\:rodFissileFuel.name=Kernbrennstab
item.resonantinduction\:rodFissileFuel.tooltip=Die prim\u00E4re Brennstoffquelle f\u00FCr Kernreaktoren.
item.resonantinduction\:rodBreederFuel.name=Brutbrennstab
item.resonantinduction\:rodBreederFuel.tooltip=Ein Brennstoff, um zerfallene Kernbrennst\u00E4be wieder anzureichern.
item.resonantinduction\:uraniumHexafluoride.name=Uranhexafluorid
item.resonantinduction\:steam.name=Dampf
## Blocks
tile.resonantinduction\:reactorDrain.name=Reaktorabfluss
tile.resonantinduction\:reactorDrain.tooltip=Extrahiert Fl\u00FCssigkeiten aus dem Reaktor, zum Beispiel Giftm\u00FCll.
tile.resonantinduction\:nuclearBoiler.name=Nuklearheizkessel
tile.resonantinduction\:centrifuge.name=Zentrifuge
tile.resonantinduction\:reactorCell.name=Reaktorzelle
tile.resonantinduction\:reactorCell.tooltip=Reaktorzellen werden als prim\u00E4re Komponente f\u00Fcr alle Reaktorarten verwendet. Brennst\u00E4be oder Plasma kann in eine Zelle injeziert werden.
tile.resonantinduction\:plasmaHeater.name=Plasmaerhitzer
tile.resonantinduction\:reactorExpansion.name=Reaktorerweiterung
tile.resonantinduction\:electricTurbine.name=Elektrische Turbine
tile.resonantinduction\:radioactive.name=Radioaktives Material
tile.resonantinduction\:thermometer.name=Thermometer
tile.resonantinduction\:thermometer.tooltip=Das Thermometer liest die Temperatur an der aktuellen Position. Shift-rechtsklicke, um die Messung auf bestimmte Koordinaten zu beschr\u00E4nken.
tile.resonantinduction\:electromagnet.name=Elektromagnet
tile.resonantinduction\:chemicalExtractor.name=Chemischer Extraktor
tile.resonantinduction\:siren.name=Sirene
tile.resonantinduction\:electromagnetGlass.name=Electromagnetisches Glas
tile.resonantinduction\:controlRod.name=Steuerstab
tile.resonantinduction\:plasma.name=Plasma
tile.resonantinduction\:funnel.name=Dampftrichter
tile.resonantinduction\:accelerator.name=Teilchenbeschleuniger
tile.resonantinduction\:fulmination.name=Fulminationsgenerator
tile.resonantinduction\:quantumAssembler.name=Quantenassembler
tile.resonantinduction\:toxicWaste.name=Giftm\u00FCll
## Tooltips
tooltip.energy=Energie
tooltip.temperature=Temperatur
tooltip.remainingTime=Verbleibende Zeit
tooltip.trackingTemperature=Messe Temperatur bei:
tooltip.notTrackingTemperature=Misst momentan keine Temperatur.

View file

@ -0,0 +1,331 @@
# English @author Calclavia, Alex_hawks
# If a localization includes %v it is some data that is calculated. Such as attributes on a cable.
# The %v may be followed by a number if there are multiple pieces of calculated data, but it will be explained in a comment.
# A % followed by a number is used for colors. The exact usage will be outlined in the comment above the localization.
itemGroup.resonantinduction=Resonant Induction
itemGroup.resonantinduction.core=Resonant Induction Core
meta.resonantinduction.description=Resonant Induction is a Minecraft mod focusing on the manipulation of electricity and wireless technology. Ever wanted blazing electrical shocks flying off your evil lairs? You've came to the right place!
meta.resonantinduction.credits=Visit website for credits.
fluid.mixture=Mixture
toolmode.link.name=Linking
### Schematics
schematic.windTurbine.name=Wind Turbine
schematic.waterTurbine.name=Water Turbine
### Core
misc.resonantinduction.ingot=Ingot
item.resonantinduction\:ingot.name=%v Ingot
item.resonantinduction\:oreDust.name=%v Dust
item.resonantinduction\:oreDust.tooltip=Shift-right click on a cauldron to refine.
item.resonantinduction\:oreRefinedDust.name=%v Refined Dust
item.resonantinduction\:oreRubble.name=%v Rubble
item.resonantinduction\:bucketMixture.name=%v Bucket
item.resonantinduction\:bucketMolten.name=%v Bucket
### Archaic Module
## machineMaterials
tile.resonantinduction\:gutter.name=Gutter
tile.resonantinduction\:gutter.tooltip=A primitive way of transfering liquid.
tile.resonantinduction\:machineMaterial.0.name=Industrial Brick
tile.resonantinduction\:machineMaterial.1.name=Industrial Brick
tile.resonantinduction\:machineMaterial.2.name=Industrial Chiseled Brick
tile.resonantinduction\:machineMaterial.3.name=Industrial Cobblestone
tile.resonantinduction\:machineMaterial.4.name=Industrial Cracked Stone
tile.resonantinduction\:machineMaterial.5.name=Industrial Stone
tile.resonantinduction\:machineMaterial.6.name=Industrial Stone Slab
tile.resonantinduction\:machineMaterial.7.name=Industrial Mossy Stone
tile.resonantinduction\:machineMaterial.8.name=Dark Steel
tile.resonantinduction\:machineMaterial.9.name=Tinted Steel
tile.resonantinduction\:machineMaterial.10.name=Steel
## Items
item.resonantinduction\:imprint.name=Imprint
item.resonantinduction\:hammer.name=Hammer
item.resonantinduction\:handCrank.name=Hand Crank
## Machines
tile.resonantinduction\:castingMold.name=Casting Mold
tile.resonantinduction\:castingMold.tooltip=Pour molten metal into the cast to form an ingot.
tile.resonantinduction\:millstone.name=Millstone
tile.resonantinduction\:millstone.tooltip=Put some rubble in the millstone and use a hand crank to grind rubble into dust.
tile.resonantinduction\:imprinter.name=Imprinter
tile.resonantinduction\:firebox.0.name=Firebox
tile.resonantinduction\:firebox.1.name=Electric Firebox
tile.resonantinduction\:hotPlate.name=Hot Plate
tile.resonantinduction\:engineeringTable.name=Engineering Table
engineerTable.config.inventory.true=Engineering table is now connected to nearby inventories.
engineerTable.config.inventory.false=Engineering table is now disconnected from nearby inventories.
## Transport
tile.resonantinduction\:turntable.name=Turntable
tile.resonantinduction\:crate.0.name=Wooden Crate
tile.resonantinduction\:crate.1.name=Iron Crate
tile.resonantinduction\:crate.2.name=Steel Crate
info.waila.crate.stack=Item:
info.waila.crate.stored=Stored:
info.waila.crate.empty=Empty
crate.orefilter.true= Same OreName stacking enabled
crate.orefilter.false= Same OreName stacking disabled
crate.tooltip.amount= Amount:
tile.resonantinduction\:crate.0.tooltip=Right click to add items Left click to remove items Ctrl Click sets itemstack filter
tile.resonantinduction\:crate.1.tooltip=Right click to add items Left click to remove items Ctrl Click sets itemstack filter
tile.resonantinduction\:crate.2.tooltip=Right click to add items Left click to remove items Ctrl Click sets itemstack filter
tile.resonantinduction\:tank.name=Tank
tile.resonantinduction\:tank.tooltip=Shift right click to pick up with fluid contained within.
info.waila.tank.fluid=Fluid:
info.waila.tank.vol=Volume:
info.waila.tank.empty=Empty
### Mechanical Module
## Energy
item.resonantinduction\:gear.0.name=Wooden Gear
item.resonantinduction\:gear.1.name=Stone Gear
item.resonantinduction\:gear.2.name=Metal Gear
item.resonantinduction\:gear.10.name=Pumpkin Gear
item.resonantinduction\:gearShaft.0.name=Wooden Gear Shaft
item.resonantinduction\:gearShaft.1.name=Stone Gear Shaft
item.resonantinduction\:gearShaft.2.name=Metal Gear Shaft
tile.resonantinduction\:windTurbine.0.name=Wooden Wind Turbine
tile.resonantinduction\:windTurbine.0.tooltip=The wooden wind turbine is light, fragile and spins fast.
tile.resonantinduction\:windTurbine.1.name=Stone Wind Turbine
tile.resonantinduction\:windTurbine.1.tooltip=The stone turbine is heavy, strong and durable.
tile.resonantinduction\:windTurbine.2.name=Metal Wind Turbine
tile.resonantinduction\:windTurbine.2.tooltip=The metal wind turbine is strong and agile.
tile.resonantinduction\:waterTurbine.0.name=Wooden Water Turbine
tile.resonantinduction\:waterTurbine.0.tooltip=The wooden water turbine is light and moves fast.
tile.resonantinduction\:waterTurbine.1.name=Stone Water Turbine
tile.resonantinduction\:waterTurbine.1.tooltip=The stone water turbine is heavy, strong and durable.
tile.resonantinduction\:waterTurbine.2.name=Metal Water Turbine
tile.resonantinduction\:waterTurbine.2.tooltip=The metal water turbine is strong and agile.
## Transport
item.resonantinduction\:pipe.ceramic.name=Ceramic Pipe
item.resonantinduction\:pipe.bronze.name=Bronze Pipe
item.resonantinduction\:pipe.plastic.name=Plastic Pipe
item.resonantinduction\:pipe.iron.name=Iron Pipe
item.resonantinduction\:pipe.steel.name=Steel Pipe
item.resonantinduction\:pipe.fiberglass.name=Fiberglass Pipe
tile.resonantinduction\:pump.name=Pump
tile.resonantinduction\:grate.name=Grate
tile.resonantinduction\:conveyorBelt.name=Conveyor Belt
tile.resonantinduction\:detector.name=Detector
tile.resonantinduction\:detector.tooltip=Outputs a Redstone signal upon item detection. Configure to invert imprint filter.
tile.resonantinduction\:manipulator.name=Manipulator
tile.resonantinduction\:rejector.name=Rejector
tile.resonantinduction\:sorter.name=Sorter
tile.resonantinduction\:breaker.name=Breaker
tile.resonantinduction\:placer.name=Placer
## Machines and Processing
tile.resonantinduction\:mixer.name=Mixer
tile.resonantinduction\:mixer.tooltip=The mixer mixes dusts with water to wash and refine the ore dust. Mixer prefers more angular velocity (spin) to process dusts.
tile.resonantinduction\:mechanicalPiston.name=Mechanical Piston
tile.resonantinduction\:grindingWheel.name=Grinding Wheel
tile.resonantinduction\:grindingWheel.tooltip=The grinding wheel grinds ores into rubble and dust. Larger torque allows faster grinding.
tile.resonantinduction\:filter.name=Filter
resonantinduction.machine.grinder=Grinder
resonantinduction.machine.crusher=Crusher
resonantinduction.machine.mixer=Mixer
resonantinduction.machine.sawmill=Saw-mill
resonantinduction.machine.smelter=Smelter
### Electrical Module
## Blocks
tile.resonantinduction\:tesla.name=Tesla Coil
tile.resonantinduction\:tesla.tooltip=Transfer electricity wirelessly. Link with a configurator for cross dimension teleportation.
item.resonantinduction\:levitator.name=Electromagnetic Levitator
tile.resonantinduction\:battery.name=Battery
tile.resonantinduction\:armbot.name=Armbot
tile.resonantinduction\:encoder.name=Encoder
item.resonantinduction\:charger.name=Charging Plate
item.resonantinduction\:insulation.name=Insulation
tool.mode.set=Mode set to:
laser.toolmode.remove=Remove
laser.toolmode.smelt=Smelt
laser.toolmode.damage=Damage
## Generators
tile.resonantinduction\:solarPanel.name=Solar Panel
tile.resonantinduction\:motor.name=Electric Motor
tile.resonantinduction\:thermopile.name=Thermopile
tile.resonantinduction\:thermopile.tooltip=Generates a voltage proportional to local temperature difference.
#Transport
item.resonantinduction\:disk.name=Program Disk
## Energy
item.resonantinduction\:wire.copper.name=Copper Wire
item.resonantinduction\:wire.tin.name=Tin Wire
item.resonantinduction\:wire.iron.name=Iron Wire
item.resonantinduction\:wire.aluminum.name=Aluminum Wire
item.resonantinduction\:wire.silver.name=Silver Wire
item.resonantinduction\:wire.superconductor.name=Superconductor Wire
item.resonantinduction\:transformer.name=Transformer
item.resonantinduction\:multimeter.name=Multimeter
item.resonantinduction\:multimeter.tooltip=Multimeter is a panel that display the energy and fluid information of a block.
### Quantum Tier
tile.resonantinduction\:quantumGate.name=Quantum Gate
item.resonantinduction\:quantumGlyph.0.name=Nought Glyph
item.resonantinduction\:quantumGlyph.1.name=Monogon Glyph
item.resonantinduction\:quantumGlyph.2.name=Digon Glyph
item.resonantinduction\:quantumGlyph.3.name=Trigon Glyph
item.resonantinduction\:quantumGlyph.4.name=Tetragon Glyph
## Tool-tips
tooltip.mixture=Mixture
tooltip.molten=Molten
tooltip.pipe.rate=Flow Rate: %v
tooltip.pipe.pressure=Max Pressure: %v
tooltip.wire.resistance=Resistance: %v
tooltip.wire.current=Current: %v
tooltip.wire.damage=Damage: %v
tooltip.wire.helpText=Higher voltages will increase transfer rate and decrease energy loss. Shift right click to place a framed wire.
# %0 is the color for the charge level, %1 is grey to reset it back to normal (optional), %v0 is the current charge, %v1 is the max charge
tooltip.battery.energy=Energy: %0%v0 / %v1
tooltip.noInformation=No Information
tooltip.tier=Tier
tooltip.empty=Empty
tooltip.noOutput=No Output
tooltip.noImprint=No Imprint
tooltip.graph.energy=Energy
tooltip.graph.power=Power
tooltip.graph.capacity=Capacity
tooltip.graph.voltage=Voltage
tooltip.graph.torque=Torque
tooltip.graph.speed=Speed
tooltip.graph.fluid=Fluid
tooltip.graph.temperature=Temperature
tooltip.graph.pressure=Pressure
## GUI Strings that can't be any other localization
gui.resonantinduction.multimeter.toggle=Toggle
gui.resonantinduction.multimeter.toggleDetection=Toggle Detection
gui.resonantinduction.multimeter.toggleGraph=Toggle Graph
gui.resonantinduction.multimeter.capacity=Capacity:
gui.resonantinduction.multimeter.energy=Energy:
gui.resonantinduction.multimeter.redstone=Output Redstone If...
gui.resonantinduction.multimeter.logic=Logic:
gui.resonantinduction.multimeter.none=None
gui.resonantinduction.multimeter.lessThan=Less Than
gui.resonantinduction.multimeter.lessThanOrEqual=Less Than or Equal
gui.resonantinduction.multimeter.equal=Equal
gui.resonantinduction.multimeter.greaterThanOrEqual=Greater Than or Equal
gui.resonantinduction.multimeter.greaterThan=Greater Than
## Messages to players
message.multimeter.onUse=Energy: %v J
message.tesla.toggleAttack=Toggled entity attack to: %v
# %v0 is the tile that's linking to the other (usually %v0 is a tesla), the others are coordinates in the standard [x, y, z]
message.tesla.pair=Linked %v0 with [%v1, %v2, %v3]
message.tesla.mode=Tesla receive mode is now %v
### Atomic Module
potion.radiation=Radiation
death.attack.radiation=%1$s died from radiation.
## Schematic
schematic.accelerator.name=Particle Accelerator
schematic.breedingReactor.name=Breeding Reactor
schematic.fissionReactor.name=Fission Reactor
schematic.fusionReactor.name=Fusion Reactor
## Fluids
fluid.uraniumhexafluoride=Uranium Hexafluoride
fluid.deuterium=Deuterium
fluid.tritium=Tritium
fluid.plasma=Plasma
fluid.steam=Steam
fluid.toxicwaste=Toxic Waste
fluid.tile.water=Water
item.resonantinduction\:hazmatMask.name=Hazmat Mask
item.resonantinduction\:hazmatBody.name=Hazmat Body
item.resonantinduction\:hazmatLeggings.name=Hazmat Leggings
item.resonantinduction\:hazmatBoots.name=Hazmat Boots
item.resonantinduction\:bucketToxicWaste.name=Toxic Waste Bucket
## Cells
item.resonantinduction\:cellEmpty.name=Empty Cell
item.resonantinduction\:cellWater.name=Water Cell
item.resonantinduction\:cellDeuterium.name=Deuterium Cell
item.resonantinduction\:cellTritium.name=Tritium Cell
item.resonantinduction\:darkMatter.name=Dark Matter
item.resonantinduction\:antimatter.0.name=Antimatter
item.resonantinduction\:antimatter.0.tooltip=1 Gram
item.resonantinduction\:antimatter.1.name=Antimatter
item.resonantinduction\:antimatter.1.tooltip=125 Milligrams
## Uranium Related Items
item.resonantinduction\:yellowcake.name=Yellowcake
item.resonantinduction\:uranium.0.name=Uranium-235
item.resonantinduction\:uranium.0.tooltip=Enriched Uranium
item.resonantinduction\:uranium.1.name=Uranium-238
item.resonantinduction\:uranium.1.tooltip=Breeding Uranium
item.resonantinduction\:rodFissileFuel.name=Fissile Fuel Rod
item.resonantinduction\:rodFissileFuel.tooltip=The primary fuel source for fission reactors.
item.resonantinduction\:rodBreederFuel.name=Breeder Fuel Rod
item.resonantinduction\:rodBreederFuel.tooltip=The fuel source for re-breeding decayed fissile fuels.
item.resonantinduction\:uraniumHexafluoride.name=Uranium Hexafluoride
item.resonantinduction\:steam.name=Steam
## Blocks
tile.resonantinduction\:uraniumOre.name=Uranium Ore
tile.resonantinduction\:uraniumOre.tooltip=A precious and useful ore used for fission reactions.
tile.resonantinduction\:reactorDrain.name=Reactor Drain
tile.resonantinduction\:reactorDrain.tooltip=Extracts fluids out of the reactor, such as toxic waste.
tile.resonantinduction\:nuclearBoiler.name=Nuclear Boiler
tile.resonantinduction\:nuclearBoiler.tooltip=Boils yellowcake into uranium hexaflouride gas.
tile.resonantinduction\:centrifuge.name=Centrifuge
tile.resonantinduction\:centrifuge.tooltip=Refines Uranium Hexafluoride gas into usable uranium.
tile.resonantinduction\:reactorCell.name=Reactor Cell
tile.resonantinduction\:reactorCell.tooltip=The primary components for all types of reactors. Fuel rods or plasma may be injected into the cell.
tile.resonantinduction\:plasmaHeater.name=Plasma Heater
tile.resonantinduction\:plasmaHeater.tooltip=A plasma heater is used to heat deuterium and tritium to plasma state for fusion power. Plasma must be moved into the reactor cell.
tile.resonantinduction\:electricTurbine.name=Electric Turbine
tile.resonantinduction\:electricTurbine.tooltip=Transform the kinetic energy from moving steam into electrical energy.
tile.resonantinduction\:radioactive.name=Radioactive Waste
tile.resonantinduction\:radioactive.tooltip=Generates harmful radiation and spreads around the world, mutating organisms.
tile.resonantinduction\:thermometer.name=Thermometer
tile.resonantinduction\:thermometer.tooltip=Reads the temperature at the current coordinate. Shift-right click to lock the reading to a specific coordinate.
tile.resonantinduction\:electromagnet.name=Electromagnet
tile.resonantinduction\:electromagnet.tooltip=Creates an electromagnetic field preventing plasma and particles from getting near.
tile.resonantinduction\:chemicalExtractor.name=Chemical Extractor
tile.resonantinduction\:chemicalExtractor.tooltip=Extracts uranium ores to yellowcake, water to deuterium and deuterium to tritium.
tile.resonantinduction\:siren.name=Siren
tile.resonantinduction\:siren.tooltip=Creates an alarm with customizable pitch and volume with a Redstone signal.
tile.resonantinduction\:controlRod.name=Control Rod
tile.resonantinduction\:controlRod.tooltip=Suppresses fission reaction in adjacent reactor cells.
tile.resonantinduction\:plasma.name=Plasma
tile.resonantinduction\:plasma.tooltip=Generates extreme heat for boiling water.
tile.resonantinduction\:funnel.name=Gas Funnel
tile.resonantinduction\:funnel.tooltip=Captures gas to allow it to be transported with piping.
tile.resonantinduction\:accelerator.name=Particle Accelerator
tile.resonantinduction\:accelerator.tooltip=Accelerates particles and creates antimatter and dark matter.
tile.resonantinduction\:fulmination.name=Fulmination Generator
tile.resonantinduction\:fulmination.tooltip=Transforms the kinetic energy from explosions into electrical energy.
tile.resonantinduction\:quantumAssembler.name=Quantum Assembler
tile.resonantinduction\:quantumAssembler.tooltip=Reassembles Dark Matter atoms into usable materials.
tile.resonantinduction\:toxicWaste.name=Toxic Waste
tile.resonantinduction\:toxicWaste.tooltip=Toxic, nuclear waste that pollutes the world.
## Tooltips
tooltip.energy=Energy
tooltip.temperature=Temperature
tooltip.remainingTime=Remaining Time
tooltip.trackingTemperature=Tracking temperature at:
tooltip.notTrackingTemperature=Not tracking temperature.

View file

@ -0,0 +1,51 @@
# spolszczenie wykonane przez unekpl
itemGroup.atomicscience=Atomic Science
potion.radiation=Napromieniowanie
death.attack.radiation=%1$s umar\u0142 z napromieniowania.
item.resonantinduction\:hazmatMask.name=Maska hazmat
item.resonantinduction\:hazmatBody.name=Napier\u015Bnik hazmat
item.resonantinduction\:hazmatLeggings.name=Nogawice hazmat
item.resonantinduction\:hazmatBoots.name=Buty hazmat
item.resonantinduction\:thermometer.name=Termometr kieszonkowy
item.resonantinduction\:bucketToxicWaste.name=Wiadro z odpadami toksycznymi
## Cells
item.resonantinduction\:cellEmpty.name=Pusta kom\u00F3rka
item.resonantinduction\:cellWater.name=Kom\u00F3rka a wod\u0105
item.resonantinduction\:cellDeuterium.name=Kom\u00F3rka z deuterem
item.resonantinduction\:strangeMatter.name=Materia dziwna
item.resonantinduction\:antimatter.name=Antymateria
## Uranium Related Items
tile.resonantinduction\:oreUranium.name=Ruda uranu
item.resonantinduction\:yellowcake.name=Yellowcake
item.resonantinduction\:uranium.0.name=Uran-235
item.resonantinduction\:uranium.1.name=Uran-238
item.resonantinduction\:rodFissileFuel.name=Rozszczepialny pr\u0119t paliwa
item.resonantinduction\:rodBreederFuel.name=Powielaj\u0105cy pr\u0119t paliwa
item.resonantinduction\:uraniumHexafluoride.name=Heksafluorek uranu
item.resonantinduction\:steam.name=Para wodna
## Blocks
tile.resonantinduction\:reactorTap.name=Odp\u0142yw reaktora
tile.resonantinduction\:nuclearBoiler.name=Bojler wodny wrz\u0105cy
tile.resonantinduction\:centrifuge.name=Centryfuga
tile.resonantinduction\:fissionReactor.name=Reaktor rozszczepieniowy
tile.resonantinduction\:fusionReactor.name=Reaktor fuzyjny
tile.resonantinduction\:reactorExpansion.name=Rozszerzenie reaktora
tile.resonantinduction\:turbine.name=Turbina reaktora
tile.resonantinduction\:radioactive.name=Materia\u0142 radioaktywny
tile.resonantinduction\:thermometer.name=Termometr
tile.resonantinduction\:electromagnet.name=Elektromagnes
tile.resonantinduction\:chemicalExtractor.name=Ekstraktor chemiczny
tile.resonantinduction\:siren.name=Syrena alarmowa
tile.resonantinduction\:electromagnetGlass.name=Elektromagnetyczne szk\u0142o
tile.resonantinduction\:controlRod.name=Pr\u0119t kontrolny
tile.resonantinduction\:plasma.name=Plazma
tile.resonantinduction\:funnel.name=Lejek do pary wodnej
tile.resonantinduction\:accelerator.name=Przyspieszacz cz\u0105steczek
tile.resonantinduction\:instantBuilder.name=Reaktor w pude\u0142ku
tile.resonantinduction\:fulmination.name=Generator fulminacyjny
tile.resonantinduction\:atomicAssembler.name=Wytwarzacz atomowy
tile.resonantinduction\:toxicWaste.name=Odpad toksyczny

Binary file not shown.

After

Width:  |  Height:  |  Size: 1.9 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 992 B

Binary file not shown.

After

Width:  |  Height:  |  Size: 3.6 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 3 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 9.2 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 789 B

Binary file not shown.

After

Width:  |  Height:  |  Size: 1.8 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 2.4 KiB

Some files were not shown because too many files have changed in this diff Show more