generated from tilera/1710mod
371 lines
15 KiB
Java
371 lines
15 KiB
Java
package mffs;
|
|
|
|
import calclavia.lib.CalculationHelper;
|
|
import icbm.api.IBlockFrequency;
|
|
import java.util.ArrayList;
|
|
import java.util.HashMap;
|
|
import java.util.List;
|
|
import java.util.Set;
|
|
import mffs.api.IProjector;
|
|
import mffs.api.fortron.IFortronFrequency;
|
|
import mffs.api.modules.IModuleAcceptor;
|
|
import mffs.api.security.IInterdictionMatrix;
|
|
import mffs.api.security.Permission;
|
|
import mffs.fortron.FrequencyGrid;
|
|
import mffs.item.module.projector.ItemModeCustom;
|
|
import net.minecraft.block.Block;
|
|
import net.minecraft.entity.player.EntityPlayer;
|
|
import net.minecraft.inventory.IInventory;
|
|
import net.minecraft.item.ItemBlock;
|
|
import net.minecraft.item.ItemStack;
|
|
import net.minecraft.nbt.NBTTagCompound;
|
|
import net.minecraft.tileentity.TileEntity;
|
|
import net.minecraft.world.IBlockAccess;
|
|
import net.minecraft.world.World;
|
|
import net.minecraftforge.common.util.ForgeDirection;
|
|
import net.minecraftforge.event.entity.player.PlayerInteractEvent;
|
|
import universalelectricity.core.vector.Vector3;
|
|
|
|
public class MFFSHelper {
|
|
public static void
|
|
transferFortron(final IFortronFrequency transferer,
|
|
final Set<IFortronFrequency> frequencyTiles,
|
|
final TransferMode transferMode, final int limit) {
|
|
if (transferer != null && frequencyTiles.size() > 1) {
|
|
int totalFortron = 0;
|
|
int totalCapacity = 0;
|
|
for (final IFortronFrequency machine : frequencyTiles) {
|
|
if (machine != null) {
|
|
totalFortron += machine.getFortronEnergy();
|
|
totalCapacity += machine.getFortronCapacity();
|
|
}
|
|
}
|
|
if (totalFortron > 0 && totalCapacity > 0) {
|
|
switch (transferMode) {
|
|
case EQUALIZE: {
|
|
for (final IFortronFrequency machine : frequencyTiles) {
|
|
if (machine != null) {
|
|
final double capacityPercentage =
|
|
machine.getFortronCapacity() / (double)totalCapacity;
|
|
final int amountToSet = (int)(totalFortron * capacityPercentage);
|
|
doTransferFortron(transferer, machine,
|
|
amountToSet - machine.getFortronEnergy(),
|
|
limit);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case DISTRIBUTE: {
|
|
final int amountToSet2 = totalFortron / frequencyTiles.size();
|
|
for (final IFortronFrequency machine2 : frequencyTiles) {
|
|
if (machine2 != null) {
|
|
doTransferFortron(transferer, machine2,
|
|
amountToSet2 - machine2.getFortronEnergy(),
|
|
limit);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case DRAIN: {
|
|
frequencyTiles.remove(transferer);
|
|
for (final IFortronFrequency machine : frequencyTiles) {
|
|
if (machine != null) {
|
|
final double capacityPercentage =
|
|
machine.getFortronCapacity() / (double)totalCapacity;
|
|
final int amountToSet = (int)(totalFortron * capacityPercentage);
|
|
if (amountToSet - machine.getFortronEnergy() <= 0) {
|
|
continue;
|
|
}
|
|
doTransferFortron(transferer, machine,
|
|
amountToSet - machine.getFortronEnergy(),
|
|
limit);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case FILL: {
|
|
if (transferer.getFortronEnergy() < transferer.getFortronCapacity()) {
|
|
frequencyTiles.remove(transferer);
|
|
final int requiredFortron =
|
|
transferer.getFortronCapacity() - transferer.getFortronEnergy();
|
|
for (final IFortronFrequency machine2 : frequencyTiles) {
|
|
if (machine2 != null) {
|
|
final int amountToConsume =
|
|
Math.min(requiredFortron, machine2.getFortronEnergy());
|
|
final int amountToSet =
|
|
-machine2.getFortronEnergy() - amountToConsume;
|
|
if (amountToConsume <= 0) {
|
|
continue;
|
|
}
|
|
doTransferFortron(transferer, machine2,
|
|
amountToSet - machine2.getFortronEnergy(),
|
|
limit);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public static void doTransferFortron(final IFortronFrequency transferer,
|
|
final IFortronFrequency receiver,
|
|
int joules, final int limit) {
|
|
if (transferer != null && receiver != null) {
|
|
final TileEntity tileEntity = (TileEntity)transferer;
|
|
final World world = tileEntity.getWorldObj();
|
|
boolean isCamo = false;
|
|
if (transferer instanceof IModuleAcceptor) {
|
|
isCamo =
|
|
(((IModuleAcceptor)transferer)
|
|
.getModuleCount(ModularForceFieldSystem.itemModuleCamouflage,
|
|
new int[0]) > 0);
|
|
}
|
|
if (joules > 0) {
|
|
joules = Math.min(joules, limit);
|
|
int toBeInjected = receiver.provideFortron(
|
|
transferer.requestFortron(joules, false), false);
|
|
toBeInjected = transferer.requestFortron(
|
|
receiver.provideFortron(toBeInjected, true), true);
|
|
if (world.isRemote && toBeInjected > 0 && !isCamo) {
|
|
ModularForceFieldSystem.proxy.renderBeam(
|
|
world, Vector3.add(new Vector3(tileEntity), 0.5),
|
|
Vector3.add(new Vector3((TileEntity)receiver), 0.5), 0.6f, 0.6f,
|
|
1.0f, 20);
|
|
}
|
|
} else {
|
|
joules = Math.min(Math.abs(joules), limit);
|
|
int toBeEjected = transferer.provideFortron(
|
|
receiver.requestFortron(joules, false), false);
|
|
toBeEjected = receiver.requestFortron(
|
|
transferer.provideFortron(toBeEjected, true), true);
|
|
if (world.isRemote && toBeEjected > 0 && !isCamo) {
|
|
ModularForceFieldSystem.proxy.renderBeam(
|
|
world, Vector3.add(new Vector3((TileEntity)receiver), 0.5),
|
|
Vector3.add(new Vector3(tileEntity), 0.5), 0.6f, 0.6f, 1.0f, 20);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public static IInterdictionMatrix
|
|
getNearestInterdictionMatrix(final World world, final Vector3 position) {
|
|
for (final IBlockFrequency frequencyTile : FrequencyGrid.instance().get()) {
|
|
if (((TileEntity)frequencyTile).getWorldObj() == world &&
|
|
frequencyTile instanceof IInterdictionMatrix) {
|
|
final IInterdictionMatrix interdictionMatrix =
|
|
(IInterdictionMatrix)frequencyTile;
|
|
if (interdictionMatrix.isActive() &&
|
|
position.distanceTo(new Vector3((TileEntity)interdictionMatrix)) <=
|
|
interdictionMatrix.getActionRange()) {
|
|
return interdictionMatrix;
|
|
}
|
|
continue;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public static boolean
|
|
isPermittedByInterdictionMatrix(final IInterdictionMatrix interdictionMatrix,
|
|
final String username,
|
|
final Permission... permissions) {
|
|
if (interdictionMatrix != null && interdictionMatrix.isActive() &&
|
|
interdictionMatrix.getBiometricIdentifier() != null) {
|
|
for (final Permission permission : permissions) {
|
|
if (!interdictionMatrix.getBiometricIdentifier().isAccessGranted(
|
|
username, permission)) {
|
|
return interdictionMatrix.getModuleCount(
|
|
ModularForceFieldSystem.itemModuleInvert, new int[0]) > 0;
|
|
}
|
|
}
|
|
}
|
|
return interdictionMatrix.getModuleCount(
|
|
ModularForceFieldSystem.itemModuleInvert, new int[0]) <= 0;
|
|
}
|
|
|
|
public static List<String> splitStringPerWord(final String string,
|
|
final int wordsPerLine) {
|
|
final String[] words = string.split(" ");
|
|
final List<String> lines = new ArrayList<>();
|
|
for (int lineCount = 0;
|
|
lineCount < Math.ceil(words.length / (float)wordsPerLine);
|
|
++lineCount) {
|
|
String stringInLine = "";
|
|
for (int i = lineCount * wordsPerLine;
|
|
i < Math.min(wordsPerLine + lineCount * wordsPerLine, words.length);
|
|
++i) {
|
|
stringInLine = stringInLine + words[i] + " ";
|
|
}
|
|
lines.add(stringInLine.trim());
|
|
}
|
|
return lines;
|
|
}
|
|
|
|
public static ItemStack getFirstItemBlock(final TileEntity tileEntity,
|
|
final ItemStack itemStack) {
|
|
return getFirstItemBlock(tileEntity, itemStack, true);
|
|
}
|
|
|
|
public static ItemStack getFirstItemBlock(final TileEntity tileEntity,
|
|
final ItemStack itemStack,
|
|
final boolean recur) {
|
|
if (tileEntity instanceof IProjector) {
|
|
for (final int i : ((IProjector)tileEntity).getModuleSlots()) {
|
|
final ItemStack checkStack =
|
|
getFirstItemBlock(i, (IInventory)tileEntity, itemStack);
|
|
if (checkStack != null) {
|
|
return checkStack;
|
|
}
|
|
}
|
|
} else if (tileEntity instanceof IInventory) {
|
|
final IInventory inventory = (IInventory)tileEntity;
|
|
for (int j = 0; j < inventory.getSizeInventory(); ++j) {
|
|
final ItemStack checkStack2 =
|
|
getFirstItemBlock(j, inventory, itemStack);
|
|
if (checkStack2 != null) {
|
|
return checkStack2;
|
|
}
|
|
}
|
|
}
|
|
if (recur) {
|
|
for (int k = 0; k < 6; ++k) {
|
|
final ForgeDirection direction = ForgeDirection.getOrientation(k);
|
|
final Vector3 vector = new Vector3(tileEntity);
|
|
vector.modifyPositionFromSide(direction);
|
|
final TileEntity checkTile =
|
|
vector.getTileEntity((IBlockAccess)tileEntity.getWorldObj());
|
|
if (checkTile != null) {
|
|
final ItemStack checkStack =
|
|
getFirstItemBlock(checkTile, itemStack, false);
|
|
if (checkStack != null) {
|
|
return checkStack;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public static ItemStack getFirstItemBlock(final int i,
|
|
final IInventory inventory,
|
|
final ItemStack itemStack) {
|
|
final ItemStack checkStack = inventory.getStackInSlot(i);
|
|
if (checkStack != null && checkStack.getItem() instanceof ItemBlock &&
|
|
(itemStack == null || checkStack.isItemEqual(itemStack))) {
|
|
return checkStack;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public static Block getFilterBlock(final ItemStack itemStack) {
|
|
if (itemStack != null && itemStack.getItem() instanceof ItemBlock) {
|
|
final Block block = Block.getBlockFromItem(itemStack.getItem());
|
|
if (block.renderAsNormalBlock()) {
|
|
return block;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public static ItemStack getCamoBlock(final IProjector projector,
|
|
final Vector3 position) {
|
|
if (projector != null && !((TileEntity)projector).getWorldObj().isRemote &&
|
|
projector != null &&
|
|
projector.getModuleCount(ModularForceFieldSystem.itemModuleCamouflage,
|
|
new int[0]) > 0) {
|
|
if (projector.getMode() instanceof ItemModeCustom) {
|
|
final HashMap<Vector3, int[]> fieldMap =
|
|
((ItemModeCustom)projector.getMode())
|
|
.getFieldBlockMap(projector, projector.getModeStack());
|
|
if (fieldMap != null) {
|
|
final Vector3 fieldCenter = new Vector3((TileEntity)projector)
|
|
.add(projector.getTranslation());
|
|
final Vector3 relativePosition =
|
|
position.clone().subtract(fieldCenter);
|
|
CalculationHelper.rotateByAngle(relativePosition,
|
|
-projector.getRotationYaw(),
|
|
-projector.getRotationPitch());
|
|
final int[] blockInfo = fieldMap.get(relativePosition.round());
|
|
if (blockInfo != null && blockInfo[0] > 0) {
|
|
return new ItemStack(Block.getBlockById(blockInfo[0]), 1,
|
|
blockInfo[1]);
|
|
}
|
|
}
|
|
}
|
|
for (final int i : projector.getModuleSlots()) {
|
|
final ItemStack checkStack = projector.getStackInSlot(i);
|
|
final Block block = getFilterBlock(checkStack);
|
|
if (block != null) {
|
|
return checkStack;
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public static NBTTagCompound getNBTTagCompound(final ItemStack itemStack) {
|
|
if (itemStack != null) {
|
|
if (itemStack.getTagCompound() == null) {
|
|
itemStack.setTagCompound(new NBTTagCompound());
|
|
}
|
|
return itemStack.getTagCompound();
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public static boolean hasPermission(final World world, final Vector3 position,
|
|
final Permission permission,
|
|
final EntityPlayer player) {
|
|
final IInterdictionMatrix interdictionMatrix =
|
|
getNearestInterdictionMatrix(world, position);
|
|
return interdictionMatrix == null ||
|
|
isPermittedByInterdictionMatrix(interdictionMatrix,
|
|
player.getDisplayName(), permission);
|
|
}
|
|
|
|
public static boolean hasPermission(final World world, final Vector3 position,
|
|
final PlayerInteractEvent.Action action,
|
|
final EntityPlayer player) {
|
|
final IInterdictionMatrix interdictionMatrix =
|
|
getNearestInterdictionMatrix(world, position);
|
|
return interdictionMatrix == null ||
|
|
hasPermission(world, position, interdictionMatrix, action, player);
|
|
}
|
|
|
|
public static boolean
|
|
hasPermission(final World world, final Vector3 position,
|
|
final IInterdictionMatrix interdictionMatrix,
|
|
final PlayerInteractEvent.Action action,
|
|
final EntityPlayer player) {
|
|
boolean hasPermission = true;
|
|
if (action == PlayerInteractEvent.Action.RIGHT_CLICK_BLOCK &&
|
|
position.getTileEntity((IBlockAccess)world) != null &&
|
|
interdictionMatrix.getModuleCount(
|
|
ModularForceFieldSystem.itemModuleBlockAccess, new int[0]) > 0) {
|
|
hasPermission = false;
|
|
if (isPermittedByInterdictionMatrix(interdictionMatrix,
|
|
player.getDisplayName(),
|
|
Permission.BLOCK_ACCESS)) {
|
|
hasPermission = true;
|
|
}
|
|
}
|
|
if (hasPermission &&
|
|
interdictionMatrix.getModuleCount(
|
|
ModularForceFieldSystem.itemModuleBlockAlter, new int[0]) > 0 &&
|
|
(player.getCurrentEquippedItem() != null ||
|
|
action == PlayerInteractEvent.Action.LEFT_CLICK_BLOCK)) {
|
|
hasPermission = false;
|
|
if (isPermittedByInterdictionMatrix(interdictionMatrix,
|
|
player.getDisplayName(),
|
|
Permission.BLOCK_ALTER)) {
|
|
hasPermission = true;
|
|
}
|
|
}
|
|
return hasPermission;
|
|
}
|
|
}
|