public FluidLoader(FMLPreInitializationEvent event) {
if (FluidRegistry.isFluidRegistered(fluidMercury)) {
event
.getModLog()
.info("Found fluid {}, the registration is canceled. ", fluidMercury.getName());
fluidMercury = FluidRegistry.getFluid(fluidMercury.getName());
} else {
FluidRegistry.registerFluid(fluidMercury);
}
}
private static String getFluidName(FluidStack fluidStack) {
final Fluid fluid = fluidStack.getFluid();
String localizedName = fluid.getLocalizedName(fluidStack);
if (!Strings.isNullOrEmpty(localizedName)
&& !localizedName.equals(fluid.getUnlocalizedName())) {
return fluid.getRarity(fluidStack).rarityColor.toString() + localizedName;
} else {
return EnumChatFormatting.OBFUSCATED + "LOLNOPE" + EnumChatFormatting.RESET;
}
}
/**
* @param add
* @param internalFluidIndex
* @param fluid
* @return amount added
*/
public int addFluid(int add, Fluid fluid) {
if (hasFluid(fluid) != -1) {
int newAmount = internalFluids.get(hasFluid(fluid)).amount + add;
Fluid fluidToAdd = FluidRegistry.getFluid(fluid.getName());
internalFluids.set(hasFluid(fluid), new FluidStack(fluidToAdd, newAmount));
return add;
} else {
internalFluids.add(new FluidStack(FluidRegistry.getFluid(fluid.getName()), add));
return add;
}
}
@Override
protected void readEntityFromNBT(NBTTagCompound nbt) {
if (nbt.hasKey("Fluid")) {
fluid = FluidRegistry.getFluid(nbt.getString("Fluid"));
dataManager.set(COLOR, fluid.getColor());
isFluid = true;
} else if (nbt.hasKey("Potion")) {
potion = PotionType.getPotionTypeForName(nbt.getString("Potion"));
dataManager.set(COLOR, fluid.getColor());
isFluid = false;
} else setDead();
dataManager.setDirty(COLOR);
}
public static String getFluidName(Fluid fluid) {
String name = "" + END;
if (fluid.getRarity() == EnumRarity.uncommon) {
name += YELLOW;
} else if (fluid.getRarity() == EnumRarity.rare) {
name += BRIGHT_BLUE;
} else if (fluid.getRarity() == EnumRarity.epic) {
name += PINK;
}
name += fluid.getLocalizedName() + END;
return name;
}
public ArrayList<String> getDisplayTags(NBTTagCompound nbt) {
ArrayList li = new ArrayList();
Fluid f = ReikaNBTHelper.getFluidFromNBT(nbt);
if (f != null) {
String fluid = f.getLocalizedName();
int amt = nbt.getInteger("lvl");
if (amt > 0) {
String amount = String.format("%d", amt / 1000);
String contents = "Contents: " + amount + "B of " + fluid;
li.add(contents);
}
}
return li;
}
public static String addFluid(String name, Fluid globalFluid, int volume, int bottleMeta) {
if (!FluidDictionary.instance.fluidExists(name)) {
globalFluid = new FluidMari(name, bottleMeta).setUnlocalizedName(name);
FluidRegistry.registerFluid(globalFluid);
FluidDictionary.instance.addFluid(name, globalFluid);
}
Fluid fluid = FluidDictionary.getFluid(name);
if (volume != -1) {
registerHeatBottle(fluid.getName(), volume, bottleMeta);
}
return FluidDictionary.getFluid(name).getName();
}
private static boolean isBlackListed(Fluid fluid) {
for (String name : ConfigCore.blacklistedAlloys) {
if (name.equals(fluid.getName())) return true;
}
return false;
}
public float getMultiplierForInput(ItemStack input, Fluid output) {
if (output != null) {
for (IRecipe recipe : recipes) {
RecipeOutput out = recipe.getOutputs()[0];
if (out.getFluidOutput().getFluid().getID() == output.getID()) {
for (RecipeInput ri : recipe.getInputs()) {
if (ri.isInput(input)) {
return ri.getMulitplier();
}
}
}
}
}
// no fluid or not an input for this fluid: best guess
// (after all, the item IS in the input slot)
float found = -1f;
for (IRecipe recipe : recipes) {
for (RecipeInput ri : recipe.getInputs()) {
if (ri.isInput(input)) {
if (found < 0f || found > ri.getMulitplier()) {
found = ri.getMulitplier();
}
}
}
}
return found > 0 ? found : 0;
}
public IBakedModel bake(
IModelState state,
VertexFormat format,
Function<ResourceLocation, TextureAtlasSprite> bakedTextureGetter) {
ImmutableMap<TransformType, TRSRTransformation> map =
IPerspectiveAwareModel.MapWrapper.getTransforms(state);
return new BakedFluid(
state.apply(Optional.<IModelPart>absent()),
map,
format,
fluid.getColor(),
bakedTextureGetter.apply(fluid.getStill()),
bakedTextureGetter.apply(fluid.getFlowing()),
fluid.isGaseous(),
Optional.<IExtendedBlockState>absent());
}
private void renderLiquid(TileEntity tile, double par2, double par4, double par6) {
GL11.glTranslated(par2, par4, par6);
TileEntityFillingStation tr = (TileEntityFillingStation) tile;
double dx = 0;
double dz = 0;
double ddx = 0;
double ddz = 0;
switch (tr.getBlockMetadata()) {
case 0:
dx = 0.25;
break;
case 1:
ddx = 0.25;
break;
case 2:
dz = 0.25;
break;
case 3:
ddz = 0.25;
break;
}
if (!tr.isEmpty() && tr.isInWorld()) {
Fluid f = tr.getFluid();
if (!f.equals(FluidRegistry.LAVA)) {
GL11.glEnable(GL11.GL_BLEND);
}
ReikaLiquidRenderer.bindFluidTexture(f);
IIcon ico = f.getIcon();
float u = ico.getMinU();
float v = ico.getMinV();
float du = ico.getMaxU();
float dv = ico.getMaxV();
double h = 0.0625 + 14D / 16D * tr.getLevel() / tr.CAPACITY;
Tessellator v5 = Tessellator.instance;
if (f.getLuminosity() > 0) ReikaRenderHelper.disableLighting();
v5.startDrawingQuads();
v5.setNormal(0, 1, 0);
v5.addVertexWithUV(dx + 0, h, -ddz + 1, u, dv);
v5.addVertexWithUV(-ddx + 1, h, -ddz + 1, du, dv);
v5.addVertexWithUV(-ddx + 1, h, dz + 0, du, v);
v5.addVertexWithUV(dx + 0, h, dz + 0, u, v);
v5.draw();
ReikaRenderHelper.enableLighting();
}
GL11.glTranslated(-par2, -par4, -par6);
GL11.glDisable(GL11.GL_BLEND);
}
@Override
public boolean outputOpen(ForgeDirection to) {
if (!super.outputOpen(to)) return false;
FluidTankInfo[] tanks = transport.getTankInfo(ForgeDirection.UNKNOWN);
// center tank
if (tanks == null || tanks[0] == null || tanks[0].fluid == null || tanks[0].fluid.amount == 0)
return true;
Fluid fluidInTank = tanks[0].fluid.getFluid();
boolean[] validDirections = new boolean[ForgeDirection.values().length];
boolean[] filteredDirections = new boolean[ForgeDirection.values().length];
boolean filterForLiquid = false;
// check every direction
// perhaps we should/can cache this?
for (ForgeDirection dir : ForgeDirection.VALID_DIRECTIONS) {
validDirections[dir.ordinal()] = false;
filteredDirections[dir.ordinal()] = false;
if (Utils.checkPipesConnections(container.getTile(dir), container)) {
for (int slot = 0; slot < 9; ++slot) {
Fluid fluid = fluids[dir.ordinal() * 9 + slot];
if (fluid != null) {
filteredDirections[dir.ordinal()] = true;
if (fluidInTank.getID() == fluid.getID()) {
validDirections[dir.ordinal()] = true;
filterForLiquid = true;
}
}
}
}
}
// the direction is filtered and liquids match
if (filteredDirections[to.ordinal()] && validDirections[to.ordinal()]) return true;
// we havent found a filter for this liquid and the direction is free
if (!filterForLiquid && !filteredDirections[to.ordinal()]) return true;
// we have a filter for the liquid, but not a valid Direction :/
return false;
}
public int getCapacity(Fluid f) {
if (power < MINPOWER || torque < MINTORQUE) return 0;
int log2 = (int) (ReikaMathLibrary.logbase(torque, 2) / 2);
long power = ReikaMathLibrary.longpow(10, log2);
int factor = f.isGaseous() ? 8 : 1;
long frac = factor * (power / 40);
return (int) Math.min(frac, tank.getCapacity());
}
@Override
public String toString() {
String name1 = inputFluid.getLocalizedName();
String name2 = outputFluid.getLocalizedName();
return name1
+ " ("
+ this.getRequiredAmount()
+ " mB) + ["
+ minTorque
+ " Nm & "
+ minPower
+ "W] -> "
+ name2
+ " ("
+ this.getProductionAmount()
+ " mB)";
}
@Override
public boolean isValidFluid(Fluid f) {
if (f.equals(FluidRegistry.getFluid("rc jet fuel"))) return false;
if (f.equals(FluidRegistry.getFluid("rc lubricant"))) return false;
if (f.equals(FluidRegistry.getFluid("rc ethanol"))) return false;
if (f.equals(FluidRegistry.getFluid("bioethanol"))) return false;
if (f.equals(FluidRegistry.getFluid("fuel"))) return false;
if (f.equals(FluidRegistry.getFluid("rocket fuel"))) return false;
if (f.equals(FluidRegistry.getFluid("rc co2"))) return false;
if (f.equals(FluidRegistry.getFluid("rc hot co2"))) return false;
if (f.equals(FluidRegistry.getFluid("chlorine"))) return false;
if (f.equals(FluidRegistry.getFluid("rc oxygen"))) return false;
return true;
}
public BlockFluidRasa(Fluid fluid, Material material) {
super(fluid, material);
this.fluidName = fluid.getName();
icons = new IIcon[2];
textures = new String[2];
}
public static void registerAsContainer(Fluid fluid) {
FluidStack stack =
FluidRegistry.getFluidStack(fluid.getName(), FluidContainerRegistry.BUCKET_VOLUME);
stack = stack.copy();
stack.amount = cell.volume;
FluidContainerRegistry.registerFluidContainer(
new FluidContainerData(
stack, new ItemStack(cell, 1, LiquidRegistry.getID(stack)), new ItemStack(cell, 1, 0)));
}
private void registerLiquids() {
highPressureWater = new FluidMari(FluidDictionary.hp_water, -1);
if (!FluidRegistry.registerFluid(highPressureWater))
highPressureWater = FluidRegistry.getFluid(FluidDictionary.hp_water);
highPressureWaterBlock =
new BlockFluidMari(highPressureWater, Material.water).setBlockName("highPressureWater");
GameRegistry.registerBlock(highPressureWaterBlock, "Mariculture_highPressureWaterBlock");
highPressureWater.setBlock(highPressureWaterBlock);
registerHeatBottle(FluidDictionary.hp_water, 1000, FluidContainerMeta.BOTTLE_HP_WATER);
}
@Override
public void registerFuel(Fluid fluid, int mLPerBucket) {
if (fluid == null) throw new NullPointerException("Fluid can't be null!");
if (mLPerBucket < 0) throw new IllegalArgumentException("mLPerBucket can't be < 0");
if (liquidFuels.containsKey(fluid)) {
Log.info(
"Overriding liquid fuel entry "
+ fluid.getLocalizedName(new FluidStack(fluid, 1))
+ " ("
+ fluid.getName()
+ ") with a fuel value of "
+ mLPerBucket
+ " (previously "
+ liquidFuels.get(fluid)
+ ")");
if (mLPerBucket == 0) liquidFuels.remove(fluid);
}
if (mLPerBucket > 0) liquidFuels.put(fluid, mLPerBucket);
}
@Override
public boolean canDrain(ForgeDirection from, Fluid fluid) {
if (getConectionMode(from) == ConnectionMode.INPUT
|| getConectionMode(from) == ConnectionMode.DISABLED
|| tank.getFluid() == null
|| fluid == null) {
return false;
}
return tank.getFluid().getFluid().getID() == fluid.getID();
}
@SuppressWarnings("ConstantConditions")
private void effect(EntityLivingBase e) {
if (isFluid)
e.getCapability(ArbitraryCaps.CAPABILITY_ARBITRARY_STATS, null)
.addFluidDebuff(fluid, fluid.getViscosity() / 200);
else {
potion.getEffects().forEach(eff -> e.addPotionEffect(new PotionEffect(eff)));
custom.forEach(eff -> e.addPotionEffect(new PotionEffect(eff)));
}
}
@Override
@SideOnly(Side.CLIENT)
public void addInformation(
ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4) {
if (par1ItemStack != null) {
String mobName = getMobTypeFromStack(par1ItemStack);
if (mobName != null) {
par3List.add(EntityUtil.getDisplayNameForEntity(mobName));
} else {
par3List.add(EnderIO.lang.localize("item.itemSoulVessel.tooltip.empty"));
}
float health = getHealthFromStack(par1ItemStack);
if (health >= 0) {
float maxHealth = getMaxHealthFromStack(par1ItemStack);
String msg = EnderIO.lang.localize("item.itemSoulVessel.tooltip.health");
if (maxHealth >= 0) {
par3List.add(String.format("%s %3.1f/%3.1f", msg, health, maxHealth));
} else {
par3List.add(String.format("%s %3.1f", msg, health));
}
}
String fluidName = getFluidNameFromStack(par1ItemStack);
if (fluidName != null) {
Fluid fluid = FluidRegistry.getFluid(fluidName);
if (fluid != null) {
par3List.add(
EnderIO.lang.localize("item.itemSoulVessel.tooltip.fluidname")
+ " "
+ fluid.getLocalizedName());
}
}
DyeColor color = getColorFromStack(par1ItemStack);
if (color != null) {
par3List.add(
EnderIO.lang.localize("item.itemSoulVessel.tooltip.color")
+ " "
+ color.getLocalisedName());
}
}
}
@Override
public boolean canFill(ForgeDirection from, Fluid fluid) {
if ((fluid == null)) {
return true;
} else if (fluid.getBlock() == Blocks.lava || fluid == ModFluids.ActiveLava) {
return true;
}
return false;
}
@Override
public String getItemStackDisplayName(ItemStack item) {
int id = item.getItemDamage();
if (id != 0) {
String ret = LiquidRegistry.getName(id), t = getLocalizedName(ret);
if (t != null && !t.isEmpty()) return EnumChatFormatting.RESET + t + EnumChatFormatting.RESET;
Fluid liquid = FluidRegistry.getFluid(ret);
if (liquid != null) ret = liquid.getLocalizedName();
_prefix = true;
t = super.getItemStackDisplayName(item);
_prefix = false;
t = t != null ? t.trim() : "";
ret = (t.isEmpty() ? "" : t + " ") + ret;
t = super.getItemStackDisplayName(item);
t = t != null ? t.trim() : "";
ret += t.isEmpty() ? " " + getTranslatedBucketName() : " " + t;
return ret;
}
return super.getItemStackDisplayName(item);
}
@Override
public void refresh() {
toolTip.clear();
int amount = 0;
if (getFluid() != null && getFluid().amount > 0 && getFluid().getFluid() != null) {
Fluid fluidType = getFluidType();
EnumRarity rarity = fluidType.getRarity();
if (rarity == null) rarity = EnumRarity.common;
ToolTipLine fluidName =
new ToolTipLine(fluidType.getLocalizedName(), rarity.rarityColor);
fluidName.setSpacing(2);
toolTip.add(fluidName);
amount = getFluid().amount;
} else {
toolTip.add(new ToolTipLine(StringUtil.localize("gui.empty")));
}
if (Config.tooltipLiquidAmount)
toolTip.add(
new ToolTipLine(String.format(Locale.ENGLISH, "%,d / %,d", amount, getCapacity())));
}
private void renderLiquidPart(
IBlockAccess world,
int x,
int y,
int z,
Block block,
RenderBlocks renderer,
CastingChannelLogic logic) {
FluidStack liquid = logic.liquid;
int color = block.colorMultiplier(world, x, y, z);
float red = (color >> 16 & 0xFF) / 255.0F;
float green = (color >> 8 & 0xFF) / 255.0F;
float blue = (color & 0xFF) / 255.0F;
Fluid fluid = liquid.getFluid();
if (fluid.canBePlacedInWorld())
BlockSkinRenderHelper.renderMetadataBlock(
Block.blocksList[fluid.getBlockID()], 0, x, y, z, renderer, world);
else
BlockSkinRenderHelper.renderLiquidBlock(
fluid.getStillIcon(), fluid.getFlowingIcon(), x, y, z, renderer, world);
}
public static ItemStack createFilledTank(Fluid fluid) {
final int tankCapacity = TileEntityTank.getTankCapacity();
FluidStack stack = FluidRegistry.getFluidStack(fluid.getName(), tankCapacity);
if (stack == null) return null;
FluidTank tank = new FluidTank(tankCapacity);
tank.setFluid(stack);
ItemStack item = new ItemStack(OpenBlocks.Blocks.tank);
saveTank(item, tank);
return item;
}
/**
* Returns index of internalFluids based on the fluid passed in the arguments. If the fluid is not
* in the internalFluids it will return -1
*
* @param fluid
* @return
*/
public int hasFluid(Fluid fluid) {
int i = 0;
if (!internalFluids.isEmpty()) {
while (i <= internalFluids.size() - 1) {
if (fluid.getName() == internalFluids.get(i).getFluid().getName()) {
return i;
}
i++;
}
}
return -1;
}
private DisplayInteger[] getListAndRender(RenderData data, Fluid fluid, World world) {
if (cachedCenterFluids.containsKey(data) && cachedCenterFluids.get(data).containsKey(fluid)) {
return cachedCenterFluids.get(data).get(fluid);
}
Model3D toReturn = new Model3D();
toReturn.baseBlock = Blocks.water;
toReturn.setTexture(fluid.getIcon());
final int stages = getStages(data.height);
DisplayInteger[] displays = new DisplayInteger[stages];
if (cachedCenterFluids.containsKey(data)) {
cachedCenterFluids.get(data).put(fluid, displays);
} else {
HashMap<Fluid, DisplayInteger[]> map = new HashMap<Fluid, DisplayInteger[]>();
map.put(fluid, displays);
cachedCenterFluids.put(data, map);
}
for (int i = 0; i < stages; i++) {
displays[i] = DisplayInteger.createAndStart();
if (fluid.getIcon() != null) {
toReturn.minX = 0 + .01;
toReturn.minY = 0 + .01;
toReturn.minZ = 0 + .01;
toReturn.maxX = data.length - .01;
toReturn.maxY = ((float) i / (float) stages) * (data.height - 2) - .01;
toReturn.maxZ = data.width - .01;
MekanismRenderer.renderObject(toReturn);
}
GL11.glEndList();
}
return displays;
}
private void drawFluids(int recipe) {
CentrifugeRecipe r = (CentrifugeRecipe) arecipes.get(recipe);
ItemStack in = r.input;
FluidStack fs = RecipesCentrifuge.getRecipes().getFluidResult(in);
if (fs != null) {
Fluid f = fs.getFluid();
IIcon ico = f.getIcon();
float u = ico.getMinU();
float v = ico.getMinV();
float du = ico.getMaxU();
float dv = ico.getMaxV();
ReikaTextureHelper.bindTerrainTexture();
Tessellator v5 = Tessellator.instance;
v5.startDrawingQuads();
int x = 147;
for (int i = 0; i < 4; i++) {
int y = 1 + i * 16;
v5.addVertexWithUV(x, y, 0, u, v);
v5.addVertexWithUV(x, y + 16, 0, u, dv);
v5.addVertexWithUV(x + 16, y + 16, 0, du, dv);
v5.addVertexWithUV(x + 16, y, 0, du, v);
}
v5.addVertexWithUV(x, 65, 0, u, v);
v5.addVertexWithUV(x, 68, 0, u, dv);
v5.addVertexWithUV(x + 16, 68, 0, du, dv);
v5.addVertexWithUV(x + 16, 65, 0, du, v);
v5.draw();
FontRenderer fr = Minecraft.getMinecraft().fontRenderer;
String s =
f.getLocalizedName()
+ " ("
+ fs.amount
+ " mB) ("
+ RecipesCentrifuge.getRecipes().getFluidChance(in)
+ "%)";
int l = fr.getStringWidth(s);
fr.drawString(s, 166 - l, 70, 0);
}
}
