| package net.darkhax.tesla.lib; | |
| import java.util.ArrayList; | |
| import java.util.List; | |
| import net.darkhax.tesla.api.ITeslaConsumer; | |
| import net.darkhax.tesla.api.ITeslaHolder; | |
| import net.darkhax.tesla.api.ITeslaProducer; | |
| import net.darkhax.tesla.capability.TeslaCapabilities; | |
| import net.minecraft.client.resources.I18n; | |
| import net.minecraft.tileentity.TileEntity; | |
| import net.minecraft.util.EnumFacing; | |
| import net.minecraft.util.math.BlockPos; | |
| import net.minecraft.world.World; | |
| import net.minecraftforge.common.capabilities.Capability; | |
| import net.minecraftforge.common.capabilities.ICapabilityProvider; | |
| public class TeslaUtils { | |
| /** | |
| * The smallest unit of power measurement. | |
| */ | |
| public static final int TESLA = 1; | |
| /** | |
| * The amount of Tesla in a KiloTesla. One thousand. | |
| */ | |
| public static final int KILOTESLA = 1000; | |
| /** | |
| * The amount of Telsa in a MegaTesla. One Million. | |
| */ | |
| public static final int MEGATESLA = 1000000; | |
| /** | |
| * The amount of Tesla in a GigaTesla. One Billion. | |
| */ | |
| public static final int GIGATESLA = 1000000000; | |
| /** | |
| * The amount of Telsa in a TeraTesla. One Trillion. | |
| */ | |
| public static final long TERATESLA = 1000000000000L; | |
| /** | |
| * The amount of Tesla in a PentaTesla. One Quadrilli.on | |
| */ | |
| public static final long PENTATESLA = 1000000000000000L; | |
| /** | |
| * The amount of Tesla in a ExaTesla. One Quintilian. | |
| * | |
| * The ExaTesla should not be treated as the largest unit of Tesla. The naming scheme can | |
| * go on indefinitely. The next unit would be a ZettaTesla, followed by YottaTesla, | |
| * BronoTesla, GeopTesla and so on. While it is possible to define these measurements, | |
| * there really isn't a point. | |
| */ | |
| public static final long EXATESLA = 1000000000000000000L; | |
| /** | |
| * Converts an amount of Tesla units into a human readable String. The string amount is | |
| * only rounded to one decimal place. | |
| * | |
| * @param tesla The amount of Tesla units to display. | |
| * @return A human readable display of the Tesla units. | |
| */ | |
| public static String getDisplayableTeslaCount (long tesla) { | |
| if (tesla < 1000) | |
| return tesla + " T"; | |
| final int exp = (int) (Math.log(tesla) / Math.log(1000)); | |
| final char unitType = "KMGTPE".charAt(exp - 1); | |
| return String.format("%.1f %sT", tesla / Math.pow(1000, exp), unitType); | |
| } | |
| /** | |
| * Gets the abbreviated name of the best unit to describe the provided power. For example, | |
| * anything less than 1000 will return t for tesla, while anything between 999 and one | |
| * million will return kt for kilo tesla. This method has support for up to Exatesla. | |
| * | |
| * @param tesla The amount of Tesla to get the unit for. | |
| * @return The abbreviated name for the unit used to describe the provided power amount. | |
| */ | |
| public static String getUnitType (long tesla) { | |
| if (tesla < 1000) | |
| return tesla + "t"; | |
| final int exp = (int) (Math.log(tesla) / Math.log(1000)); | |
| return "kmgtpe".charAt(exp - 1) + "t"; | |
| } | |
| /** | |
| * Gets the name of the the power unit that best represents the amount of provided power. | |
| * The name will be translated to the local language, or english if that language is not | |
| * yet supported. | |
| * | |
| * @param tesla The amount of Tesla to get the unit name for. | |
| * @return The name of the power unit that best represents the amount of power provided. | |
| */ | |
| public static String getLocalizedUnitType (long tesla) { | |
| return I18n.format("unit.tesla." + getUnitType(tesla)); | |
| } | |
| /** | |
| * Checks if a capability provider has support for Tesla. | |
| * | |
| * @param provider The provider to check. ItemStack/TileEntity/Entity and so on. | |
| * @param side The side to check. | |
| * @return Whether or not the provider has support for Tesla. | |
| */ | |
| public static boolean hasTeslaSupport (ICapabilityProvider provider, EnumFacing side) { | |
| return isTeslaHolder(provider, side) || isTeslaConsumer(provider, side) || isTeslaProducer(provider, side); | |
| } | |
| /** | |
| * Checks if a capability provider is a Tesla holder. | |
| * | |
| * @param provider The provider to check. ItemStack/TileEntity/Entity and so on. | |
| * @param side The side to check. | |
| * @return Whether or not the provider is a Tesla holder. | |
| */ | |
| public static boolean isTeslaHolder (ICapabilityProvider provider, EnumFacing side) { | |
| return provider.hasCapability(TeslaCapabilities.CAPABILITY_HOLDER, side); | |
| } | |
| /** | |
| * Checks if a capability provider is a Tesla consumer. | |
| * | |
| * @param provider The provider to check. ItemStack/TileEntity/Entity and so on. | |
| * @param side The side to check. | |
| * @return Whether or not the provider is a Tesla consumer. | |
| */ | |
| public static boolean isTeslaConsumer (ICapabilityProvider provider, EnumFacing side) { | |
| return provider.hasCapability(TeslaCapabilities.CAPABILITY_CONSUMER, side); | |
| } | |
| /** | |
| * Checks if a capability provider is a Tesla producer. | |
| * | |
| * @param provider The provider to check. ItemStack/TileEntity/Entity and so on. | |
| * @param side The side to check. | |
| * @return Whether or not the provider is a Tesla producer. | |
| */ | |
| public static boolean isTeslaProducer (ICapabilityProvider provider, EnumFacing side) { | |
| return provider.hasCapability(TeslaCapabilities.CAPABILITY_PRODUCER, side); | |
| } | |
| /** | |
| * Gets an ITeslaHolder implementation from the capability provider. | |
| * | |
| * @param provider The provider to get the capability from. | |
| * @param side The side to access; | |
| * @return A Tesla holder implementation, or null if none could be found. | |
| */ | |
| public static ITeslaHolder getTeslaHolder (ICapabilityProvider provider, EnumFacing side) { | |
| return (ITeslaHolder) provider.getCapability(TeslaCapabilities.CAPABILITY_HOLDER, side); | |
| } | |
| /** | |
| * Gets an ITeslaConsumer implementation from the capability provider. | |
| * | |
| * @param provider The provider to get the capability from. | |
| * @param side The side to access; | |
| * @return A Tesla consumer implementation, or null if none could be found. | |
| */ | |
| public static ITeslaConsumer getTeslaConsumer (ICapabilityProvider provider, EnumFacing side) { | |
| return (ITeslaConsumer) provider.getCapability(TeslaCapabilities.CAPABILITY_HOLDER, side); | |
| } | |
| /** | |
| * Gets an ITeslaProducer implementation from the capability provider. | |
| * | |
| * @param provider The provider to get the capability from. | |
| * @param side The side to access; | |
| * @return A Tesla producer implementation, or null if none could be found. | |
| */ | |
| public static ITeslaProducer getTeslaProducer (ICapabilityProvider provider, EnumFacing side) { | |
| return (ITeslaProducer) provider.getCapability(TeslaCapabilities.CAPABILITY_HOLDER, side); | |
| } | |
| /** | |
| * Gets the capacity of a provider. | |
| * | |
| * @param provider The provider to access. | |
| * @param side The side to access. | |
| * @return The capacity of the provider. 0 if it has no capacity. | |
| */ | |
| public static long getCapacity (ICapabilityProvider provider, EnumFacing side) { | |
| return isTeslaHolder(provider, side) ? getTeslaHolder(provider, side).getCapacity() : 0; | |
| } | |
| /** | |
| * Gets the stored power of a provider. | |
| * | |
| * @param provider The provider to access. | |
| * @param side The side to access. | |
| * @return The amount of power stored. | |
| */ | |
| public static long getStoredPower (ICapabilityProvider provider, EnumFacing side) { | |
| return isTeslaHolder(provider, side) ? getTeslaHolder(provider, side).getStoredPower() : 0; | |
| } | |
| /** | |
| * Attempt to give power to a provider. | |
| * | |
| * @param power The amount of power to offer. | |
| * @param simulated Whether or not this is being called as part of a simulation. | |
| * Simulations are used to get information without affecting the Tesla Producer. | |
| * @return The amount of power that the consumer accepts. | |
| */ | |
| public static long givePower (ICapabilityProvider provider, EnumFacing side, long power, boolean simulated) { | |
| return isTeslaConsumer(provider, side) ? getTeslaConsumer(provider, side).givePower(power, simulated) : 0; | |
| } | |
| /** | |
| * Attempts to take power from a provider. | |
| * | |
| * @param power The amount of power to request. | |
| * @param simulated Whether or not this is being called as part of a simulation. | |
| * Simulations are used to get information without affecting the Tesla Producer. | |
| * @return The amount of power that the Tesla Producer will give. | |
| */ | |
| public static long takePower (ICapabilityProvider provider, EnumFacing side, long power, boolean simulated) { | |
| return isTeslaProducer(provider, side) ? getTeslaProducer(provider, side).takePower(power, simulated) : 0; | |
| } | |
| /** | |
| * Gets a list of all capabilities that touch a BlockPos. This will search for tile | |
| * entities touching the BlockPos and then query them for access to their capabilities. | |
| * | |
| * @param capability The capability you want to retrieve. | |
| * @param world The world that this is happening in. | |
| * @param pos The position to search around. | |
| * @return A list of all capabilities that are being held by connected blocks. | |
| */ | |
| public static <T> List<T> getConnectedCapabilities (Capability<T> capability, World world, BlockPos pos) { | |
| final List<T> capabilities = new ArrayList<T>(); | |
| for (final EnumFacing side : EnumFacing.values()) { | |
| final TileEntity tile = world.getTileEntity(pos.offset(side)); | |
| if (tile != null && !tile.isInvalid() && tile.hasCapability(capability, side.getOpposite())) | |
| capabilities.add(tile.getCapability(capability, side.getOpposite())); | |
| } | |
| return capabilities; | |
| } | |
| /** | |
| * Attempts to give power to all consumers touching the given BlockPos. | |
| * | |
| * @param world The world that this is happening in. | |
| * @param pos The position to search around. | |
| * @param amount The amount of power to offer to each individual face. | |
| * @param simulated Whether or not this is being ran as part of a simulation. | |
| * @return The amount of power that was consumed. | |
| */ | |
| public static long distributePowerToAllFaces (World world, BlockPos pos, long amount, boolean simulated) { | |
| long consumedPower = 0L; | |
| for (final ITeslaConsumer consumer : getConnectedCapabilities(TeslaCapabilities.CAPABILITY_CONSUMER, world, pos)) | |
| consumedPower += consumer.givePower(amount, simulated); | |
| return consumedPower; | |
| } | |
| /** | |
| * Attempts to consume power from all producers touching the given BlockPos. | |
| * | |
| * @param world The world that this is happening in. | |
| * @param pos The position to search around. | |
| * @param amount The amount of power to request from each individual face. | |
| * @param simulated Whether or not this is being ran as part of a simulation. | |
| * @return The amount of power that was successfully consumed. | |
| */ | |
| public static long consumePowerFromAllFaces (World world, BlockPos pos, long amount, boolean simulated) { | |
| long recievedPower = 0L; | |
| for (final ITeslaProducer producer : getConnectedCapabilities(TeslaCapabilities.CAPABILITY_PRODUCER, world, pos)) | |
| recievedPower += producer.takePower(amount, simulated); | |
| return recievedPower; | |
| } | |
| } |