134 lines
4.6 KiB
Java
134 lines
4.6 KiB
Java
package com.pahimar.ee3.exchange;
|
|
|
|
import net.minecraft.item.ItemStack;
|
|
import net.minecraftforge.fluids.FluidContainerRegistry;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.List;
|
|
|
|
public class EnergyHelper
|
|
{
|
|
|
|
public static List<WrappedStack> filterStacksByEmc(List<WrappedStack> unfilteredStacks, EnergyValue filterValue)
|
|
{
|
|
List<WrappedStack> filteredStacks = new ArrayList<WrappedStack>();
|
|
|
|
for (WrappedStack stack : unfilteredStacks)
|
|
{
|
|
if (EnergyRegistry.getInstance().hasEnergyValue(stack))
|
|
{
|
|
EnergyValue value = EnergyRegistry.getInstance().getEnergyValue(stack);
|
|
boolean satisfiesFilter = true;
|
|
float[] valueSubValues = value.components;
|
|
float[] filterValueSubValues = filterValue.components;
|
|
|
|
for (int i = 0; i < valueSubValues.length; i++)
|
|
{
|
|
if (Float.compare(valueSubValues[i], filterValueSubValues[i]) < 0)
|
|
{
|
|
satisfiesFilter = false;
|
|
}
|
|
}
|
|
|
|
if (satisfiesFilter)
|
|
{
|
|
filteredStacks.add(stack);
|
|
}
|
|
}
|
|
}
|
|
|
|
return filteredStacks;
|
|
}
|
|
|
|
@SuppressWarnings("unused")
|
|
public static List<WrappedStack> filterStacksByEmcAndRange(float start, float end, EnergyValue filterValue)
|
|
{
|
|
return filterStacksByEmc(EnergyRegistry.getInstance().getStacksInRange(start, end), filterValue);
|
|
}
|
|
|
|
public static EnergyValue computeEnergyValueFromList(List<WrappedStack> wrappedStacks)
|
|
{
|
|
float[] computedSubValues = new float[EnergyType.TYPES.length];
|
|
|
|
for (WrappedStack wrappedStack : wrappedStacks)
|
|
{
|
|
EnergyValue wrappedStackValue;
|
|
int stackSize = -1;
|
|
if (wrappedStack.getWrappedStack() instanceof ItemStack)
|
|
{
|
|
ItemStack itemStack = (ItemStack) wrappedStack.getWrappedStack();
|
|
|
|
// Check if we are dealing with a potential fluid
|
|
if (FluidContainerRegistry.getFluidForFilledItem(itemStack) != null)
|
|
{
|
|
if (itemStack.getItem().getContainerItem(itemStack) != null)
|
|
{
|
|
stackSize = FluidContainerRegistry.getFluidForFilledItem(itemStack).amount;
|
|
wrappedStackValue = EnergyRegistry.getInstance().getEnergyValue(FluidContainerRegistry.getFluidForFilledItem(itemStack));
|
|
}
|
|
else
|
|
{
|
|
wrappedStackValue = EnergyRegistry.getInstance().getEnergyValue(wrappedStack);
|
|
}
|
|
}
|
|
// If we are dealing with a "tool" (container item), assume it's value is 0 (since it won't be used up in the recipe)
|
|
else if (itemStack.getItem() != null && itemStack.getItem().getContainerItem(itemStack) != null)
|
|
{
|
|
wrappedStackValue = new EnergyValue(0);
|
|
}
|
|
else
|
|
{
|
|
wrappedStackValue = EnergyRegistry.getInstance().getEnergyValue(wrappedStack);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
wrappedStackValue = EnergyRegistry.getInstance().getEnergyValue(wrappedStack);
|
|
}
|
|
|
|
if (wrappedStackValue != null)
|
|
{
|
|
if (stackSize == -1)
|
|
{
|
|
stackSize = wrappedStack.getStackSize();
|
|
}
|
|
|
|
for (EnergyType emcType : EnergyType.TYPES)
|
|
{
|
|
computedSubValues[emcType.ordinal()] += wrappedStackValue.components[emcType.ordinal()] * stackSize;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
|
|
return new EnergyValue(computedSubValues);
|
|
}
|
|
|
|
public static EnergyValue factorEnergyValue(EnergyValue EnergyValue, int factor)
|
|
{
|
|
return factorEnergyValue(EnergyValue, (float) factor);
|
|
}
|
|
|
|
public static EnergyValue factorEnergyValue(EnergyValue EnergyValue, float factor)
|
|
{
|
|
|
|
if ((Float.compare(factor, 0f) != 0) && (EnergyValue != null))
|
|
{
|
|
float[] factorSubValues = EnergyValue.components;
|
|
|
|
for (int i = 0; i < factorSubValues.length; i++)
|
|
{
|
|
factorSubValues[i] = factorSubValues[i] * 1f / factor;
|
|
}
|
|
|
|
return new EnergyValue(factorSubValues);
|
|
}
|
|
else
|
|
{
|
|
return EnergyValue;
|
|
}
|
|
}
|
|
}
|