From 1b820de08a05070909a267e17f033fcf58ac8710 Mon Sep 17 00:00:00 2001 From: NotAPenguin Date: Mon, 2 Sep 2024 23:17:17 +0200 Subject: The Great Renaming (#3014) * move kekztech to a single root dir * move detrav to a single root dir * move gtnh-lanthanides to a single root dir * move tectech and delete some gross reflection in gt++ * remove more reflection inside gt5u * delete more reflection in gt++ * fix imports * move bartworks and bwcrossmod * fix proxies * move galactigreg and ggfab * move gtneioreplugin * try to fix gt++ bee loader * apply the rename rules to BW * apply rename rules to bwcrossmod * apply rename rules to detrav scanner mod * apply rename rules to galacticgreg * apply rename rules to ggfab * apply rename rules to goodgenerator * apply rename rules to gtnh-lanthanides * apply rename rules to gt++ * apply rename rules to kekztech * apply rename rules to kubatech * apply rename rules to tectech * apply rename rules to gt apply the rename rules to gt * fix tt import * fix mui hopefully * fix coremod except intergalactic * rename assline recipe class * fix a class name i stumbled on * rename StructureUtility to GTStructureUtility to prevent conflict with structurelib * temporary rename of GTTooltipDataCache to old name * fix gt client/server proxy names --- .../api/objects/AE2DigitalChestHandler.java | 6 +- .../java/gregtech/api/objects/GTArrayList.java | 73 +++ .../java/gregtech/api/objects/GTChunkManager.java | 204 +++++++ .../gregtech/api/objects/GTCopiedBlockTexture.java | 36 ++ .../java/gregtech/api/objects/GTCoverDefault.java | 81 +++ .../java/gregtech/api/objects/GTCoverNone.java | 237 ++++++++ src/main/java/gregtech/api/objects/GTFluid.java | 36 ++ src/main/java/gregtech/api/objects/GTHashSet.java | 91 +++ .../java/gregtech/api/objects/GTItemStack.java | 107 ++++ .../java/gregtech/api/objects/GTItemStack2.java | 41 ++ .../java/gregtech/api/objects/GTMultiTexture.java | 27 + .../gregtech/api/objects/GTRenderedTexture.java | 33 ++ .../java/gregtech/api/objects/GTSidedTexture.java | 48 ++ .../gregtech/api/objects/GTStdRenderedTexture.java | 46 ++ .../java/gregtech/api/objects/GTUODimension.java | 54 ++ .../gregtech/api/objects/GTUODimensionList.java | 648 +++++++++++++++++++++ src/main/java/gregtech/api/objects/GTUOFluid.java | 69 +++ .../java/gregtech/api/objects/GT_ArrayList.java | 73 --- .../java/gregtech/api/objects/GT_ChunkManager.java | 204 ------- .../api/objects/GT_CopiedBlockTexture.java | 35 -- .../gregtech/api/objects/GT_Cover_Default.java | 81 --- .../java/gregtech/api/objects/GT_Cover_None.java | 237 -------- src/main/java/gregtech/api/objects/GT_Fluid.java | 36 -- src/main/java/gregtech/api/objects/GT_HashSet.java | 91 --- .../java/gregtech/api/objects/GT_ItemStack.java | 107 ---- .../java/gregtech/api/objects/GT_ItemStack2.java | 41 -- .../java/gregtech/api/objects/GT_MultiTexture.java | 26 - .../gregtech/api/objects/GT_RenderedTexture.java | 33 -- .../java/gregtech/api/objects/GT_SidedTexture.java | 48 -- .../api/objects/GT_StdRenderedTexture.java | 46 -- .../java/gregtech/api/objects/GT_UO_Dimension.java | 54 -- .../gregtech/api/objects/GT_UO_DimensionList.java | 648 --------------------- .../java/gregtech/api/objects/GT_UO_Fluid.java | 69 --- src/main/java/gregtech/api/objects/ItemData.java | 2 +- .../java/gregtech/api/objects/MaterialStack.java | 4 +- .../overclockdescriber/EUNoOverclockDescriber.java | 38 +- .../overclockdescriber/EUOverclockDescriber.java | 34 +- .../FusionOverclockDescriber.java | 16 +- .../overclockdescriber/OverclockDescriber.java | 36 +- .../SteamOverclockDescriber.java | 20 +- 40 files changed, 1909 insertions(+), 1907 deletions(-) create mode 100644 src/main/java/gregtech/api/objects/GTArrayList.java create mode 100644 src/main/java/gregtech/api/objects/GTChunkManager.java create mode 100644 src/main/java/gregtech/api/objects/GTCopiedBlockTexture.java create mode 100644 src/main/java/gregtech/api/objects/GTCoverDefault.java create mode 100644 src/main/java/gregtech/api/objects/GTCoverNone.java create mode 100644 src/main/java/gregtech/api/objects/GTFluid.java create mode 100644 src/main/java/gregtech/api/objects/GTHashSet.java create mode 100644 src/main/java/gregtech/api/objects/GTItemStack.java create mode 100644 src/main/java/gregtech/api/objects/GTItemStack2.java create mode 100644 src/main/java/gregtech/api/objects/GTMultiTexture.java create mode 100644 src/main/java/gregtech/api/objects/GTRenderedTexture.java create mode 100644 src/main/java/gregtech/api/objects/GTSidedTexture.java create mode 100644 src/main/java/gregtech/api/objects/GTStdRenderedTexture.java create mode 100644 src/main/java/gregtech/api/objects/GTUODimension.java create mode 100644 src/main/java/gregtech/api/objects/GTUODimensionList.java create mode 100644 src/main/java/gregtech/api/objects/GTUOFluid.java delete mode 100644 src/main/java/gregtech/api/objects/GT_ArrayList.java delete mode 100644 src/main/java/gregtech/api/objects/GT_ChunkManager.java delete mode 100644 src/main/java/gregtech/api/objects/GT_CopiedBlockTexture.java delete mode 100644 src/main/java/gregtech/api/objects/GT_Cover_Default.java delete mode 100644 src/main/java/gregtech/api/objects/GT_Cover_None.java delete mode 100644 src/main/java/gregtech/api/objects/GT_Fluid.java delete mode 100644 src/main/java/gregtech/api/objects/GT_HashSet.java delete mode 100644 src/main/java/gregtech/api/objects/GT_ItemStack.java delete mode 100644 src/main/java/gregtech/api/objects/GT_ItemStack2.java delete mode 100644 src/main/java/gregtech/api/objects/GT_MultiTexture.java delete mode 100644 src/main/java/gregtech/api/objects/GT_RenderedTexture.java delete mode 100644 src/main/java/gregtech/api/objects/GT_SidedTexture.java delete mode 100644 src/main/java/gregtech/api/objects/GT_StdRenderedTexture.java delete mode 100644 src/main/java/gregtech/api/objects/GT_UO_Dimension.java delete mode 100644 src/main/java/gregtech/api/objects/GT_UO_DimensionList.java delete mode 100644 src/main/java/gregtech/api/objects/GT_UO_Fluid.java (limited to 'src/main/java/gregtech/api/objects') diff --git a/src/main/java/gregtech/api/objects/AE2DigitalChestHandler.java b/src/main/java/gregtech/api/objects/AE2DigitalChestHandler.java index c2e0556de9..3ede25f5ea 100644 --- a/src/main/java/gregtech/api/objects/AE2DigitalChestHandler.java +++ b/src/main/java/gregtech/api/objects/AE2DigitalChestHandler.java @@ -4,7 +4,7 @@ import net.minecraft.tileentity.TileEntity; import net.minecraftforge.common.util.ForgeDirection; import gregtech.api.metatileentity.BaseMetaTileEntity; -import gregtech.common.tileentities.storage.GT_MetaTileEntity_DigitalChestBase; +import gregtech.common.tileentities.storage.MTEDigitalChestBase; public class AE2DigitalChestHandler implements appeng.api.storage.IExternalStorageHandler { @@ -12,14 +12,14 @@ public class AE2DigitalChestHandler implements appeng.api.storage.IExternalStora public boolean canHandle(final TileEntity te, final ForgeDirection d, final appeng.api.storage.StorageChannel chan, final appeng.api.networking.security.BaseActionSource mySrc) { return chan == appeng.api.storage.StorageChannel.ITEMS && te instanceof BaseMetaTileEntity - && ((BaseMetaTileEntity) te).getMetaTileEntity() instanceof GT_MetaTileEntity_DigitalChestBase; + && ((BaseMetaTileEntity) te).getMetaTileEntity() instanceof MTEDigitalChestBase; } @Override public appeng.api.storage.IMEInventory getInventory(final TileEntity te, final ForgeDirection d, final appeng.api.storage.StorageChannel chan, final appeng.api.networking.security.BaseActionSource src) { if (chan == appeng.api.storage.StorageChannel.ITEMS) { - return ((GT_MetaTileEntity_DigitalChestBase) (((BaseMetaTileEntity) te).getMetaTileEntity())); + return ((MTEDigitalChestBase) (((BaseMetaTileEntity) te).getMetaTileEntity())); } return null; } diff --git a/src/main/java/gregtech/api/objects/GTArrayList.java b/src/main/java/gregtech/api/objects/GTArrayList.java new file mode 100644 index 0000000000..33fbb18571 --- /dev/null +++ b/src/main/java/gregtech/api/objects/GTArrayList.java @@ -0,0 +1,73 @@ +package gregtech.api.objects; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.Objects; + +import com.google.common.collect.Collections2; + +public class GTArrayList extends ArrayList { + + private static final long serialVersionUID = 1L; + private int size_sS; + + private final boolean mAllowNulls; + + public GTArrayList(boolean aAllowNulls, int aCapacity) { + super(aCapacity); + mAllowNulls = aAllowNulls; + } + + @SafeVarargs + public GTArrayList(boolean aAllowNulls, E... aArray) { + super(Arrays.asList(aArray)); + mAllowNulls = aAllowNulls; + if (!mAllowNulls) { + size_sS = size(); + for (int i = 0; i < size_sS; i++) if (get(i) == null) { + remove(i--); + size_sS = size(); + } + } + } + + public GTArrayList(boolean aAllowNulls, Collection aList) { + super(aList); + mAllowNulls = aAllowNulls; + if (!mAllowNulls) { + size_sS = size(); + for (int i = 0; i < size_sS; i++) if (get(i) == null) { + remove(i--); + size_sS = size(); + } + } + } + + @Override + public E set(int aIndex, E aElement) { + if (mAllowNulls || aElement != null) return super.set(aIndex, aElement); + return null; + } + + @Override + public boolean add(E aElement) { + if (mAllowNulls || aElement != null) return super.add(aElement); + return false; + } + + @Override + public void add(int aIndex, E aElement) { + if (mAllowNulls || aElement != null) super.add(aIndex, aElement); + } + + @Override + public boolean addAll(Collection aList) { + return super.addAll(Collections2.filter(aList, Objects::nonNull)); + } + + @Override + public boolean addAll(int aIndex, Collection aList) { + return super.addAll(aIndex, Collections2.filter(aList, Objects::nonNull)); + } +} diff --git a/src/main/java/gregtech/api/objects/GTChunkManager.java b/src/main/java/gregtech/api/objects/GTChunkManager.java new file mode 100644 index 0000000000..59bc90aa1c --- /dev/null +++ b/src/main/java/gregtech/api/objects/GTChunkManager.java @@ -0,0 +1,204 @@ +package gregtech.api.objects; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.ChunkCoordIntPair; +import net.minecraft.world.World; +import net.minecraftforge.common.ForgeChunkManager; +import net.minecraftforge.common.ForgeChunkManager.Ticket; + +import com.google.common.collect.ArrayListMultimap; +import com.google.common.collect.ListMultimap; + +import gregtech.GTMod; +import gregtech.api.enums.GTValues; +import gregtech.api.interfaces.IChunkLoader; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.util.GTLog; + +/** + * Handles re-initialization of chunks after a server restart. + */ +public class GTChunkManager + implements ForgeChunkManager.OrderedLoadingCallback, ForgeChunkManager.PlayerOrderedLoadingCallback { + + private final Map registeredTickets = new HashMap<>(); + public static GTChunkManager instance = new GTChunkManager(); + + public static void init() { + ForgeChunkManager.setForcedChunkLoadingCallback(GTMod.instance, instance); + } + + @Override + public void ticketsLoaded(List tickets, World world) {} + + /** + * Determines if tickets should be kept. Based on if the ticket is a machine or a working-chunk ticket. + * Working-chunk tickets are tossed and recreated when the machine reactivates. + * Machine tickets are kept only if the config {@code alwaysReloadChunkloaders} is true. + * Otherwise, machine chunks are tossed and recreated only when the machine reactivates, + * similarly to a Passive Anchor. + * + * @param tickets The tickets that you will want to select from. + * The list is immutable and cannot be manipulated directly. Copy it first. + * @param world The world + * @param maxTicketCount The maximum number of tickets that will be allowed. + * @return list of tickets + */ + + @Override + public List ticketsLoaded(List tickets, World world, int maxTicketCount) { + List validTickets = new ArrayList<>(); + if (GTValues.alwaysReloadChunkloaders) { + for (Ticket ticket : tickets) { + int x = ticket.getModData() + .getInteger("OwnerX"); + int y = ticket.getModData() + .getInteger("OwnerY"); + int z = ticket.getModData() + .getInteger("OwnerZ"); + if (y > 0) { + TileEntity tile = world.getTileEntity(x, y, z); + if (tile instanceof IGregTechTileEntity && ((IGregTechTileEntity) tile).isAllowedToWork()) { + ForgeChunkManager.forceChunk(ticket, new ChunkCoordIntPair(x >> 4, z >> 4)); + if (!registeredTickets.containsKey(tile)) { + registeredTickets.put(tile, ticket); + if (((IGregTechTileEntity) tile).getMetaTileEntity() instanceof IChunkLoader) + ForgeChunkManager.forceChunk( + ticket, + ((IChunkLoader) ((IGregTechTileEntity) tile).getMetaTileEntity()).getActiveChunk()); + validTickets.add(ticket); + } + } + } + } + } + return validTickets; + } + + /** + * Determines if player tickets should be kept. This is where a ticket list per-player would be created and + * maintained. When a player joins, an event occurs, their name/UUID/etc is compared against tickets on this list + * and those tickets are reactivated. + * Since that info would be maintained/dealt with on a per-player startup, the list returned back to Forge is empty. + * + * @param tickets The tickets that you will want to select from. + * The list is immutable and cannot be manipulated directly. Copy it first. + * @param world The world + * @return the list of string-ticket paris + */ + @Override + public ListMultimap playerTicketsLoaded(ListMultimap tickets, World world) { + // Not currently used, so just return an empty list. + return ArrayListMultimap.create(); + } + + /** + * Requests a chunk to be loaded for this machine. May pass a {@code null} chunk to load just the machine itself if + * {@code alwaysReloadChunkloaders} is enabled in config. + * + * @param owner owner of the TileEntity + * @param chunkXZ chunk coordinates + * @param player player + * @return if the chunk was loaded successfully + */ + public static boolean requestPlayerChunkLoad(TileEntity owner, ChunkCoordIntPair chunkXZ, String player) { + if (!GTValues.enableChunkloaders) return false; + if (!GTValues.alwaysReloadChunkloaders && chunkXZ == null) return false; + if (GTValues.debugChunkloaders && chunkXZ != null) + GTLog.out.println("GT_ChunkManager: Chunk request: (" + chunkXZ.chunkXPos + ", " + chunkXZ.chunkZPos + ")"); + if (instance.registeredTickets.containsKey(owner)) { + ForgeChunkManager.forceChunk(instance.registeredTickets.get(owner), chunkXZ); + } else { + Ticket ticket; + if (player.equals("")) ticket = ForgeChunkManager + .requestTicket(GTMod.instance, owner.getWorldObj(), ForgeChunkManager.Type.NORMAL); + else ticket = ForgeChunkManager + .requestPlayerTicket(GTMod.instance, player, owner.getWorldObj(), ForgeChunkManager.Type.NORMAL); + if (ticket == null) { + if (GTValues.debugChunkloaders) + GTLog.out.println("GT_ChunkManager: ForgeChunkManager.requestTicket failed"); + return false; + } + if (GTValues.debugChunkloaders) GTLog.out.println( + "GT_ChunkManager: ticket issued for machine at: (" + owner.xCoord + + ", " + + owner.yCoord + + ", " + + owner.zCoord + + ")"); + NBTTagCompound tag = ticket.getModData(); + tag.setInteger("OwnerX", owner.xCoord); + tag.setInteger("OwnerY", owner.yCoord); + tag.setInteger("OwnerZ", owner.zCoord); + ForgeChunkManager.forceChunk(ticket, chunkXZ); + if (GTValues.alwaysReloadChunkloaders) + ForgeChunkManager.forceChunk(ticket, new ChunkCoordIntPair(owner.xCoord >> 4, owner.zCoord >> 4)); + instance.registeredTickets.put(owner, ticket); + } + return true; + } + + @SuppressWarnings("UnusedReturnValue") + public static boolean requestChunkLoad(TileEntity owner, ChunkCoordIntPair chunkXZ) { + return requestPlayerChunkLoad(owner, chunkXZ, ""); + } + + public static void releaseChunk(TileEntity owner, ChunkCoordIntPair chunkXZ) { + if (!GTValues.enableChunkloaders) return; + Ticket ticket = instance.registeredTickets.get(owner); + if (ticket != null) { + if (GTValues.debugChunkloaders) GTLog.out + .println("GT_ChunkManager: Chunk release: (" + chunkXZ.chunkXPos + ", " + chunkXZ.chunkZPos + ")"); + ForgeChunkManager.unforceChunk(ticket, chunkXZ); + } + } + + public static void releaseTicket(TileEntity owner) { + if (!GTValues.enableChunkloaders) return; + Ticket ticket = instance.registeredTickets.get(owner); + if (ticket != null) { + if (GTValues.debugChunkloaders) { + GTLog.out.println( + "GT_ChunkManager: ticket released by machine at: (" + owner.xCoord + + ", " + + owner.yCoord + + ", " + + owner.zCoord + + ")"); + for (ChunkCoordIntPair chunk : ticket.getChunkList()) GTLog.out + .println("GT_ChunkManager: Chunk release: (" + chunk.chunkXPos + ", " + chunk.chunkZPos + ")"); + } + ForgeChunkManager.releaseTicket(ticket); + instance.registeredTickets.remove(owner); + } + } + + public static void printTickets() { + GTLog.out.println("GT_ChunkManager: Start forced chunks dump:"); + instance.registeredTickets.forEach((machine, ticket) -> { + GTLog.out.print( + "GT_ChunkManager: Chunks forced by the machine at (" + machine.xCoord + + ", " + + machine.yCoord + + ", " + + machine.zCoord + + ")"); + if (ticket.isPlayerTicket()) GTLog.out.print(" Owner: " + ticket.getPlayerName()); + GTLog.out.print(" :"); + for (ChunkCoordIntPair c : ticket.getChunkList()) { + GTLog.out.print("("); + GTLog.out.print(c.chunkXPos); + GTLog.out.print(", "); + GTLog.out.print(c.chunkZPos); + GTLog.out.print("), "); + } + }); + GTLog.out.println("GT_ChunkManager: End forced chunks dump:"); + } +} diff --git a/src/main/java/gregtech/api/objects/GTCopiedBlockTexture.java b/src/main/java/gregtech/api/objects/GTCopiedBlockTexture.java new file mode 100644 index 0000000000..79be90c3b6 --- /dev/null +++ b/src/main/java/gregtech/api/objects/GTCopiedBlockTexture.java @@ -0,0 +1,36 @@ +package gregtech.api.objects; + +import net.minecraft.block.Block; + +import gregtech.api.enums.Dyes; +import gregtech.api.interfaces.ITexture; +import gregtech.common.render.GTCopiedBlockTextureRender; + +/** + * @deprecated Replaced by the {@link gregtech.api.render.TextureFactory} API. + */ +@Deprecated +public class GTCopiedBlockTexture extends GTCopiedBlockTextureRender implements ITexture { + + // Backwards Compat + @Deprecated + public short[] mRGBa; + + public GTCopiedBlockTexture(Block aBlock, int ordinalSide, int aMeta, short[] aRGBa, boolean aAllowAlpha) { + super(aBlock, ordinalSide, aMeta, aRGBa, aAllowAlpha); + GTCopiedBlockTexture.this.mRGBa = aRGBa; + } + + public GTCopiedBlockTexture(Block aBlock, int ordinalSide, int aMeta, short[] aRGBa) { + this(aBlock, ordinalSide, aMeta, aRGBa, true); + } + + public GTCopiedBlockTexture(Block aBlock, int ordinalSide, int aMeta) { + this(aBlock, ordinalSide, aMeta, Dyes._NULL.mRGBa); + } + + @Override + public boolean isOldTexture() { + return true; + } +} diff --git a/src/main/java/gregtech/api/objects/GTCoverDefault.java b/src/main/java/gregtech/api/objects/GTCoverDefault.java new file mode 100644 index 0000000000..6e9664c355 --- /dev/null +++ b/src/main/java/gregtech/api/objects/GTCoverDefault.java @@ -0,0 +1,81 @@ +package gregtech.api.objects; + +import net.minecraft.entity.player.EntityPlayer; +import net.minecraftforge.common.util.ForgeDirection; +import net.minecraftforge.fluids.Fluid; + +import gregtech.api.interfaces.tileentity.ICoverable; +import gregtech.api.util.CoverBehavior; +import gregtech.api.util.GTUtility; + +public class GTCoverDefault extends CoverBehavior { + + /** + * This is the Dummy, if there is a generic Cover without behavior + */ + public GTCoverDefault() { + super(); + } + + @Override + public boolean isSimpleCover() { + return true; + } + + @Override + public int onCoverScrewdriverclick(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity, + EntityPlayer aPlayer, float aX, float aY, float aZ) { + aCoverVariable = ((aCoverVariable + 1) & 15); + GTUtility.sendChatToPlayer( + aPlayer, + ((aCoverVariable & 1) != 0 ? GTUtility.trans("128.1", "Redstone ") : "") + + ((aCoverVariable & 2) != 0 ? GTUtility.trans("129.1", "Energy ") : "") + + ((aCoverVariable & 4) != 0 ? GTUtility.trans("130.1", "Fluids ") : "") + + ((aCoverVariable & 8) != 0 ? GTUtility.trans("131.1", "Items ") : "")); + return aCoverVariable; + } + + @Override + public boolean letsRedstoneGoIn(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return (aCoverVariable & 1) != 0; + } + + @Override + public boolean letsRedstoneGoOut(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return (aCoverVariable & 1) != 0; + } + + @Override + public boolean letsEnergyIn(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return (aCoverVariable & 2) != 0; + } + + @Override + public boolean letsEnergyOut(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return (aCoverVariable & 2) != 0; + } + + @Override + public boolean letsFluidIn(ForgeDirection side, int aCoverID, int aCoverVariable, Fluid aFluid, + ICoverable aTileEntity) { + return (aCoverVariable & 4) != 0; + } + + @Override + public boolean letsFluidOut(ForgeDirection side, int aCoverID, int aCoverVariable, Fluid aFluid, + ICoverable aTileEntity) { + return (aCoverVariable & 4) != 0; + } + + @Override + public boolean letsItemsIn(ForgeDirection side, int aCoverID, int aCoverVariable, int aSlot, + ICoverable aTileEntity) { + return (aCoverVariable & 8) != 0; + } + + @Override + public boolean letsItemsOut(ForgeDirection side, int aCoverID, int aCoverVariable, int aSlot, + ICoverable aTileEntity) { + return (aCoverVariable & 8) != 0; + } +} diff --git a/src/main/java/gregtech/api/objects/GTCoverNone.java b/src/main/java/gregtech/api/objects/GTCoverNone.java new file mode 100644 index 0000000000..2c07538186 --- /dev/null +++ b/src/main/java/gregtech/api/objects/GTCoverNone.java @@ -0,0 +1,237 @@ +package gregtech.api.objects; + +import static gregtech.api.enums.GTValues.E; + +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import net.minecraftforge.common.util.ForgeDirection; +import net.minecraftforge.fluids.Fluid; + +import gregtech.api.interfaces.tileentity.ICoverable; +import gregtech.api.util.CoverBehavior; +import gregtech.api.util.ISerializableObject; + +public class GTCoverNone extends CoverBehavior { + + /** + * This is the Dummy, if there is no Cover + */ + public GTCoverNone() {} + + @Override + public float getBlastProofLevel(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return 10.0F; + } + + @Override + public boolean letsRedstoneGoIn(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return true; + } + + @Override + public boolean letsRedstoneGoOut(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return true; + } + + @Override + public boolean letsEnergyIn(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return true; + } + + @Override + public boolean letsEnergyOut(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return true; + } + + @Override + public boolean letsFluidIn(ForgeDirection side, int aCoverID, int aCoverVariable, Fluid aFluid, + ICoverable aTileEntity) { + return true; + } + + @Override + public boolean letsFluidOut(ForgeDirection side, int aCoverID, int aCoverVariable, Fluid aFluid, + ICoverable aTileEntity) { + return true; + } + + @Override + public boolean letsItemsIn(ForgeDirection side, int aCoverID, int aCoverVariable, int aSlot, + ICoverable aTileEntity) { + return true; + } + + @Override + public boolean letsItemsOut(ForgeDirection side, int aCoverID, int aCoverVariable, int aSlot, + ICoverable aTileEntity) { + return true; + } + + @Override + public boolean isGUIClickable(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return true; + } + + @Override + public boolean manipulatesSidedRedstoneOutput(ForgeDirection side, int aCoverID, int aCoverVariable, + ICoverable aTileEntity) { + return false; + } + + @Override + public boolean onCoverRightclick(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity, + EntityPlayer aPlayer, float aX, float aY, float aZ) { + return false; + } + + @Override + public boolean onCoverRemoval(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity, + boolean aForced) { + return true; + } + + @Override + public int doCoverThings(ForgeDirection side, byte aInputRedstone, int aCoverID, int aCoverVariable, + ICoverable aTileEntity, long aTimer) { + return 0; + } + + @Override + public boolean isSimpleCover() { + return true; + } + + @Override + protected boolean isRedstoneSensitiveImpl(ForgeDirection side, int aCoverID, + ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity, long aTimer) { + return false; + } + + @Override + protected ISerializableObject.LegacyCoverData doCoverThingsImpl(ForgeDirection side, byte aInputRedstone, + int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity, long aTimer) { + return aCoverVariable; + } + + @Override + protected boolean onCoverRightClickImpl(ForgeDirection side, int aCoverID, + ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity, EntityPlayer aPlayer, float aX, + float aY, float aZ) { + return false; + } + + @Override + protected ISerializableObject.LegacyCoverData onCoverScrewdriverClickImpl(ForgeDirection side, int aCoverID, + ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity, EntityPlayer aPlayer, float aX, + float aY, float aZ) { + return aCoverVariable; + } + + @Override + protected boolean onCoverShiftRightClickImpl(ForgeDirection side, int aCoverID, + ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity, EntityPlayer aPlayer) { + return false; + } + + @Override + protected boolean onCoverRemovalImpl(ForgeDirection side, int aCoverID, + ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity, boolean aForced) { + return true; + } + + @Override + protected String getDescriptionImpl(ForgeDirection side, int aCoverID, + ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity) { + return E; + } + + @Override + protected float getBlastProofLevelImpl(ForgeDirection side, int aCoverID, + ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity) { + return 10.0F; + } + + @Override + protected boolean letsRedstoneGoInImpl(ForgeDirection side, int aCoverID, + ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity) { + return true; + } + + @Override + protected boolean letsRedstoneGoOutImpl(ForgeDirection side, int aCoverID, + ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity) { + return true; + } + + @Override + protected boolean letsEnergyInImpl(ForgeDirection side, int aCoverID, + ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity) { + return true; + } + + @Override + protected boolean letsEnergyOutImpl(ForgeDirection side, int aCoverID, + ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity) { + return true; + } + + @Override + protected boolean letsFluidInImpl(ForgeDirection side, int aCoverID, + ISerializableObject.LegacyCoverData aCoverVariable, Fluid aFluid, ICoverable aTileEntity) { + return true; + } + + @Override + protected boolean letsFluidOutImpl(ForgeDirection side, int aCoverID, + ISerializableObject.LegacyCoverData aCoverVariable, Fluid aFluid, ICoverable aTileEntity) { + return true; + } + + @Override + protected boolean letsItemsInImpl(ForgeDirection side, int aCoverID, + ISerializableObject.LegacyCoverData aCoverVariable, int aSlot, ICoverable aTileEntity) { + return true; + } + + @Override + protected boolean letsItemsOutImpl(ForgeDirection side, int aCoverID, + ISerializableObject.LegacyCoverData aCoverVariable, int aSlot, ICoverable aTileEntity) { + return true; + } + + @Override + protected boolean manipulatesSidedRedstoneOutputImpl(ForgeDirection side, int aCoverID, + ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity) { + return false; + } + + @Override + protected boolean alwaysLookConnectedImpl(ForgeDirection side, int aCoverID, + ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity) { + return false; + } + + @Override + protected byte getRedstoneInputImpl(ForgeDirection side, byte aInputRedstone, int aCoverID, + ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity) { + return aInputRedstone; + } + + @Override + protected int getTickRateImpl(ForgeDirection side, int aCoverID, ISerializableObject.LegacyCoverData aCoverVariable, + ICoverable aTileEntity) { + return 0; + } + + @Override + protected byte getLensColorImpl(ForgeDirection side, int aCoverID, + ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity) { + return -1; + } + + @Override + protected ItemStack getDropImpl(ForgeDirection side, int aCoverID, + ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity) { + return null; + } +} diff --git a/src/main/java/gregtech/api/objects/GTFluid.java b/src/main/java/gregtech/api/objects/GTFluid.java new file mode 100644 index 0000000000..9ffeac5b8f --- /dev/null +++ b/src/main/java/gregtech/api/objects/GTFluid.java @@ -0,0 +1,36 @@ +package gregtech.api.objects; + +import static gregtech.api.enums.Mods.GregTech; + +import net.minecraftforge.fluids.Fluid; + +import gregtech.api.GregTechAPI; +import gregtech.api.fluid.GTFluidFactory; + +/** + * @deprecated use {@link GTFluidFactory#builder} + */ +@Deprecated +public class GTFluid extends Fluid implements Runnable { + + public final String mTextureName; + private final short[] mRGBa; + + public GTFluid(String aName, String aTextureName, short[] aRGBa) { + super(aName); + mRGBa = aRGBa; + mTextureName = aTextureName; + GregTechAPI.sGTBlockIconload.add(this); + } + + @Override + public int getColor() { + return (Math.max(0, Math.min(255, mRGBa[0])) << 16) | (Math.max(0, Math.min(255, mRGBa[1])) << 8) + | Math.max(0, Math.min(255, mRGBa[2])); + } + + @Override + public void run() { + setIcons(GregTechAPI.sBlockIcons.registerIcon(GregTech.getResourcePath("fluids", "fluid." + mTextureName))); + } +} diff --git a/src/main/java/gregtech/api/objects/GTHashSet.java b/src/main/java/gregtech/api/objects/GTHashSet.java new file mode 100644 index 0000000000..df012c05f7 --- /dev/null +++ b/src/main/java/gregtech/api/objects/GTHashSet.java @@ -0,0 +1,91 @@ +package gregtech.api.objects; + +import java.util.AbstractSet; +import java.util.Collection; +import java.util.HashMap; +import java.util.Iterator; +import java.util.LinkedHashMap; +import java.util.Map; + +import net.minecraft.item.ItemStack; + +import gregtech.api.GregTechAPI; +import gregtech.api.util.GTUtility; + +public class GTHashSet extends AbstractSet { + + private static final Object OBJECT = new Object(); + private final transient HashMap map; + + public GTHashSet() { + map = new HashMap<>(); + GregTechAPI.sItemStackMappings.add(map); + } + + public GTHashSet(Collection c) { + map = new HashMap<>(Math.max((int) (c.size() / .75f) + 1, 16)); + addAll(c); + GregTechAPI.sItemStackMappings.add(map); + } + + public GTHashSet(int initialCapacity, float loadFactor) { + map = new HashMap<>(initialCapacity, loadFactor); + GregTechAPI.sItemStackMappings.add(map); + } + + public GTHashSet(int initialCapacity) { + map = new HashMap<>(initialCapacity); + GregTechAPI.sItemStackMappings.add(map); + } + + GTHashSet(int initialCapacity, float loadFactor, boolean dummy) { + map = new LinkedHashMap<>(initialCapacity, loadFactor); + GregTechAPI.sItemStackMappings.add(map); + } + + public Map getMap() { + return map; + } + + @SuppressWarnings("unchecked") // The downcasting below will throw ClassCastException unless E is GT_ItemStack. + @Override + public Iterator iterator() { + return (Iterator) map.keySet() + .iterator(); + } + + @Override + public int size() { + return map.size(); + } + + @Override + public boolean isEmpty() { + return map.isEmpty(); + } + + @Override + public boolean contains(Object o) { + return map.containsKey(o); + } + + public boolean add(ItemStack aStack) { + if (GTUtility.isStackInvalid(aStack)) return false; + return map.put(new GTItemStack(aStack), OBJECT) == null; + } + + @Override + public boolean add(E e) { + return map.put(e, OBJECT) == null; + } + + @Override + public boolean remove(Object o) { + return map.remove(o) == OBJECT; + } + + @Override + public void clear() { + map.clear(); + } +} diff --git a/src/main/java/gregtech/api/objects/GTItemStack.java b/src/main/java/gregtech/api/objects/GTItemStack.java new file mode 100644 index 0000000000..3ddfcd706a --- /dev/null +++ b/src/main/java/gregtech/api/objects/GTItemStack.java @@ -0,0 +1,107 @@ +package gregtech.api.objects; + +import net.minecraft.init.Items; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; + +import gregtech.api.enums.GTValues; +import gregtech.api.util.GTUtility; +import gregtech.api.util.item.ItemHolder; +import it.unimi.dsi.fastutil.Hash; + +/** + * An optimization of {@link ItemStack} to have a better {@code hashcode} and {@code equals} in order to improve + * {@code HashMap} and {@code Set} performance + */ +public class GTItemStack extends ItemHolder { + + /** + * A better {@link Hash.Strategy} for {@link ItemStack}. Implementation originally from {@code GT_ItemStack2}. + */ + public static final Hash.Strategy ITEMSTACK_HASH_STRATEGY2 = new Hash.Strategy<>() { + + @Override + public int hashCode(ItemStack o) { + return o.getItem() + .hashCode() * 38197 + Items.feather.getDamage(o); + } + + @Override + public boolean equals(ItemStack a, ItemStack b) { + if (a == b) return true; + if (a == null || b == null) return false; + return a.getItem() == b.getItem() && Items.feather.getDamage(a) == Items.feather.getDamage(b); + } + }; + + public final Item mItem; + public final byte mStackSize; + public final short mMetaData; + + public GTItemStack(Item aItem, long aStackSize, long aMetaData) { + super(new ItemStack(aItem, 1, (int) aMetaData)); + mItem = aItem; + mStackSize = (byte) aStackSize; + mMetaData = (short) aMetaData; + } + + public GTItemStack(ItemStack aStack) { + this(aStack, false); + } + + public GTItemStack(ItemStack aStack, boolean wildcard) { + this( + aStack == null ? null : aStack.getItem(), + aStack == null ? 0 : aStack.stackSize, + aStack == null ? 0 : wildcard ? GTValues.W : Items.feather.getDamage(aStack)); + } + + public GTItemStack(int aHashCode) { + this(GTUtility.intToStack(aHashCode)); + } + + public final ItemStack toStack() { + if (mItem == null) return null; + return new ItemStack(mItem, 1, mMetaData); + } + + public final boolean isStackEqual(ItemStack aStack) { + return GTUtility.areStacksEqual(toStack(), aStack); + } + + public final boolean isStackEqual(GTItemStack aStack) { + return GTUtility.areStacksEqual(toStack(), aStack.toStack()); + } + + @Override + public boolean equals(Object aStack) { + if (aStack == this) return true; + if (aStack instanceof GTItemStack) { + return ((GTItemStack) aStack).mItem == mItem && ((GTItemStack) aStack).mMetaData == mMetaData; + } + return false; + } + + @Override + public int hashCode() { + return GTUtility.stackToInt(toStack()); + } + + /** + * @see #internalCopyStack(ItemStack, boolean) + */ + public static ItemStack internalCopyStack(ItemStack aStack) { + return internalCopyStack(aStack, false); + } + + /** + * Replicates the copy behavior of {@link #toStack()} but for normal {@link ItemStack}s. + * + * @param aStack the stack to copy + * @param wildcard whether to use wildcard damage value + * @return a copy of the stack with stack size 1 and no NBT + */ + public static ItemStack internalCopyStack(ItemStack aStack, boolean wildcard) { + return new ItemStack(aStack.getItem(), 1, wildcard ? GTValues.W : Items.feather.getDamage(aStack)); + } +} diff --git a/src/main/java/gregtech/api/objects/GTItemStack2.java b/src/main/java/gregtech/api/objects/GTItemStack2.java new file mode 100644 index 0000000000..798915d848 --- /dev/null +++ b/src/main/java/gregtech/api/objects/GTItemStack2.java @@ -0,0 +1,41 @@ +package gregtech.api.objects; + +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; + +/** + * GT_ItemStack, but with a better hashCode(). Due to this change, it should not be placed in the same hash based data + * structure with GT_ItemStack. It also shouldn't be used to construct search query into a hash based data structure + * that contains GT_ItemStack. + * + * @deprecated See {@link GTItemStack#ITEMSTACK_HASH_STRATEGY2} + */ +@Deprecated +public class GTItemStack2 extends GTItemStack { + + public GTItemStack2(Item aItem, long aStackSize, long aMetaData) { + super(aItem, aStackSize, aMetaData); + } + + public GTItemStack2(ItemStack aStack) { + super(aStack); + } + + public GTItemStack2(ItemStack aStack, boolean wildcard) { + super(aStack, wildcard); + } + + @Override + public boolean equals(Object aStack) { + if (aStack == this) return true; + if (aStack instanceof GTItemStack) { + return ((GTItemStack) aStack).mItem == mItem && ((GTItemStack) aStack).mMetaData == mMetaData; + } + return false; + } + + @Override + public int hashCode() { + return mItem.hashCode() * 38197 + mMetaData; + } +} diff --git a/src/main/java/gregtech/api/objects/GTMultiTexture.java b/src/main/java/gregtech/api/objects/GTMultiTexture.java new file mode 100644 index 0000000000..ecd2f55661 --- /dev/null +++ b/src/main/java/gregtech/api/objects/GTMultiTexture.java @@ -0,0 +1,27 @@ +package gregtech.api.objects; + +import gregtech.api.interfaces.ITexture; +import gregtech.common.render.GTMultiTextureRender; + +/** + *

+ * Lets Multiple ITextures Render overlay over each other.< + *

+ *

+ * I should have done this much earlier... + *

+ * + * @deprecated Replaced by the {@link gregtech.api.render.TextureFactory} API. + */ +@Deprecated +public class GTMultiTexture extends GTMultiTextureRender implements ITexture { + + public GTMultiTexture(ITexture... aTextures) { + super(aTextures); + } + + @Override + public boolean isOldTexture() { + return true; + } +} diff --git a/src/main/java/gregtech/api/objects/GTRenderedTexture.java b/src/main/java/gregtech/api/objects/GTRenderedTexture.java new file mode 100644 index 0000000000..a4d0a064ff --- /dev/null +++ b/src/main/java/gregtech/api/objects/GTRenderedTexture.java @@ -0,0 +1,33 @@ +package gregtech.api.objects; + +import gregtech.api.enums.Dyes; +import gregtech.api.interfaces.IColorModulationContainer; +import gregtech.api.interfaces.IIconContainer; +import gregtech.api.interfaces.ITexture; + +@Deprecated +public class GTRenderedTexture extends gregtech.common.render.GTRenderedTexture + implements ITexture, IColorModulationContainer { + + @Deprecated + public short[] mRGBa; + + public GTRenderedTexture(IIconContainer aIcon, short[] aRGBa, boolean aAllowAlpha) { + super(aIcon, aRGBa, aAllowAlpha, false, true, false); + if (aRGBa.length != 4) throw new IllegalArgumentException("RGBa doesn't have 4 Values @ GT_RenderedTexture"); + mRGBa = aRGBa; + } + + public GTRenderedTexture(IIconContainer aIcon, short[] aRGBa) { + this(aIcon, aRGBa, true); + } + + public GTRenderedTexture(IIconContainer aIcon) { + this(aIcon, Dyes._NULL.mRGBa); + } + + @Override + public boolean isOldTexture() { + return true; + } +} diff --git a/src/main/java/gregtech/api/objects/GTSidedTexture.java b/src/main/java/gregtech/api/objects/GTSidedTexture.java new file mode 100644 index 0000000000..d7b2291386 --- /dev/null +++ b/src/main/java/gregtech/api/objects/GTSidedTexture.java @@ -0,0 +1,48 @@ +package gregtech.api.objects; + +import gregtech.api.enums.Dyes; +import gregtech.api.interfaces.IColorModulationContainer; +import gregtech.api.interfaces.IIconContainer; +import gregtech.api.interfaces.ITexture; +import gregtech.common.render.GTSidedTextureRender; + +/** + * @deprecated Replaced by the {@link gregtech.api.render.TextureFactory} API. + */ +@Deprecated +public class GTSidedTexture extends GTSidedTextureRender implements ITexture, IColorModulationContainer { + + @Deprecated + public short[] mRGBa; + + public GTSidedTexture(IIconContainer aIcon0, IIconContainer aIcon1, IIconContainer aIcon2, IIconContainer aIcon3, + IIconContainer aIcon4, IIconContainer aIcon5, short[] aRGBa, boolean aAllowAlpha) { + super(aIcon0, aIcon1, aIcon2, aIcon3, aIcon4, aIcon5, aRGBa, aAllowAlpha); + + // Backwards Compat + GTSidedTexture.this.mRGBa = aRGBa; + } + + public GTSidedTexture(IIconContainer aIcon0, IIconContainer aIcon1, IIconContainer aIcon2, IIconContainer aIcon3, + IIconContainer aIcon4, IIconContainer aIcon5, short[] aRGBa) { + this(aIcon0, aIcon1, aIcon2, aIcon3, aIcon4, aIcon5, aRGBa, true); + } + + public GTSidedTexture(IIconContainer aIcon0, IIconContainer aIcon1, IIconContainer aIcon2, IIconContainer aIcon3, + IIconContainer aIcon4, IIconContainer aIcon5) { + this(aIcon0, aIcon1, aIcon2, aIcon3, aIcon4, aIcon5, Dyes._NULL.mRGBa); + } + + public GTSidedTexture(IIconContainer aBottom, IIconContainer aTop, IIconContainer aSides, short[] aRGBa) { + this(aBottom, aTop, aSides, aSides, aSides, aSides, aRGBa); + } + + public GTSidedTexture(IIconContainer aBottom, IIconContainer aTop, IIconContainer aSides) { + this(aBottom, aTop, aSides, Dyes._NULL.mRGBa); + } + + @Override + public boolean isOldTexture() { + return true; + } +} diff --git a/src/main/java/gregtech/api/objects/GTStdRenderedTexture.java b/src/main/java/gregtech/api/objects/GTStdRenderedTexture.java new file mode 100644 index 0000000000..11a3a4818f --- /dev/null +++ b/src/main/java/gregtech/api/objects/GTStdRenderedTexture.java @@ -0,0 +1,46 @@ +package gregtech.api.objects; + +import net.minecraft.block.Block; +import net.minecraft.client.renderer.RenderBlocks; +import net.minecraftforge.common.util.ForgeDirection; + +import gregtech.api.enums.Dyes; +import gregtech.api.interfaces.IIconContainer; +import gregtech.api.util.LightingHelper; + +/** + * This ITexture implementation extends the GT_RenderedTexture class to render with bottom side flipped as with dumb + * blocks rendering. It is used in Ore blocks rendering so they better blends with dumb block ores from vanilla or other + * mods, when seen from bottom. + * + * @deprecated Replaced by the {@link gregtech.api.render.TextureFactory} API. + */ +@Deprecated +public class GTStdRenderedTexture extends GTRenderedTexture { + + @SuppressWarnings("unused") + public GTStdRenderedTexture(IIconContainer aIcon, short[] aRGBa, boolean aAllowAlpha) { + super(aIcon, aRGBa, aAllowAlpha); + } + + public GTStdRenderedTexture(IIconContainer aIcon, short[] aRGBa) { + super(aIcon, aRGBa, true); + } + + @SuppressWarnings("unused") + public GTStdRenderedTexture(IIconContainer aIcon) { + super(aIcon, Dyes._NULL.mRGBa); + } + + @Override + public void renderYNeg(RenderBlocks aRenderer, Block aBlock, int aX, int aY, int aZ) { + LightingHelper lighting = new LightingHelper(aRenderer); + lighting.setupLightingYNeg(aBlock, aX, aY, aZ) + .setupColor(ForgeDirection.DOWN, mRGBa); + aRenderer.renderFaceYNeg(aBlock, aX, aY, aZ, mIconContainer.getIcon()); + if (mIconContainer.getOverlayIcon() != null) { + lighting.setupColor(ForgeDirection.DOWN, 0xffffff); + aRenderer.renderFaceYNeg(aBlock, aX, aY, aZ, mIconContainer.getOverlayIcon()); + } + } +} diff --git a/src/main/java/gregtech/api/objects/GTUODimension.java b/src/main/java/gregtech/api/objects/GTUODimension.java new file mode 100644 index 0000000000..2fe10196bd --- /dev/null +++ b/src/main/java/gregtech/api/objects/GTUODimension.java @@ -0,0 +1,54 @@ +package gregtech.api.objects; + +import java.util.Random; + +import net.minecraftforge.common.config.ConfigCategory; + +import com.google.common.collect.BiMap; +import com.google.common.collect.HashBiMap; + +public class GTUODimension { + + private final BiMap fFluids; + private int maxChance; + public String Dimension = "null"; + + public GTUODimension(ConfigCategory aConfigCategory) { // TODO CONFIGURE + fFluids = HashBiMap.create(); + if (aConfigCategory.containsKey("Dimension")) { + aConfigCategory.get("Dimension").comment = "Dimension ID or Class Name"; + Dimension = aConfigCategory.get("Dimension") + .getString(); + } + maxChance = 0; + // GT_FML_LOGGER.info("GT UO "+aConfigCategory.getName()+" Dimension:"+Dimension); + for (int i = 0; i < aConfigCategory.getChildren() + .size(); i++) { + GTUOFluid fluid = new GTUOFluid( + (ConfigCategory) aConfigCategory.getChildren() + .toArray()[i]); + fFluids.put(fluid.Registry, fluid); + maxChance += fluid.Chance; + } + } + + public GTUOFluid getRandomFluid(Random aRandom) { + int random = aRandom.nextInt(1000); + for (BiMap.Entry fl : fFluids.entrySet()) { + int chance = fl.getValue().Chance * 1000 / maxChance; + if (random <= chance) return fl.getValue(); + // GT_FML_LOGGER.info("GT UO "+fl.getValue().Registry+" Chance:"+chance+" Random:"+random); + random -= chance; + } + return null; + } + + public String getUOFluidKey(GTUOFluid uoFluid) { + return fFluids.inverse() + .get(uoFluid); + } + + public GTUOFluid getUOFluid(String key) { + return fFluids.get(key); + } +} diff --git a/src/main/java/gregtech/api/objects/GTUODimensionList.java b/src/main/java/gregtech/api/objects/GTUODimensionList.java new file mode 100644 index 0000000000..60d11fdaa7 --- /dev/null +++ b/src/main/java/gregtech/api/objects/GTUODimensionList.java @@ -0,0 +1,648 @@ +package gregtech.api.objects; + +import static gregtech.api.enums.Dimensions.AlphaCentauriBb; +import static gregtech.api.enums.Dimensions.BarnardaC; +import static gregtech.api.enums.Dimensions.BarnardaE; +import static gregtech.api.enums.Dimensions.BarnardaF; +import static gregtech.api.enums.Dimensions.Callisto; +import static gregtech.api.enums.Dimensions.Europa; +import static gregtech.api.enums.Dimensions.Io; +import static gregtech.api.enums.Dimensions.Makemake; +import static gregtech.api.enums.Dimensions.Mars; +import static gregtech.api.enums.Dimensions.Mercury; +import static gregtech.api.enums.Dimensions.Miranda; +import static gregtech.api.enums.Dimensions.Moon; +import static gregtech.api.enums.Dimensions.Oberon; +import static gregtech.api.enums.Dimensions.Overworld; +import static gregtech.api.enums.Dimensions.Pluto; +import static gregtech.api.enums.Dimensions.Proteus; +import static gregtech.api.enums.Dimensions.Ross128b; +import static gregtech.api.enums.Dimensions.Ross128ba; +import static gregtech.api.enums.Dimensions.TCetiE; +import static gregtech.api.enums.Dimensions.Titan; +import static gregtech.api.enums.Dimensions.Triton; +import static gregtech.api.enums.Dimensions.Venus; +import static gregtech.api.enums.UndergroundFluidNames.carbonDioxide; +import static gregtech.api.enums.UndergroundFluidNames.carbonMonoxide; +import static gregtech.api.enums.UndergroundFluidNames.chlorobenzene; +import static gregtech.api.enums.UndergroundFluidNames.deuterium; +import static gregtech.api.enums.UndergroundFluidNames.distilledWater; +import static gregtech.api.enums.UndergroundFluidNames.ethane; +import static gregtech.api.enums.UndergroundFluidNames.ethylene; +import static gregtech.api.enums.UndergroundFluidNames.fluorine; +import static gregtech.api.enums.UndergroundFluidNames.heavyOil; +import static gregtech.api.enums.UndergroundFluidNames.helium3; +import static gregtech.api.enums.UndergroundFluidNames.hydrofluoricAcid; +import static gregtech.api.enums.UndergroundFluidNames.hydrogen; +import static gregtech.api.enums.UndergroundFluidNames.hydrogenSulfide; +import static gregtech.api.enums.UndergroundFluidNames.lava; +import static gregtech.api.enums.UndergroundFluidNames.lightOil; +import static gregtech.api.enums.UndergroundFluidNames.liquidAir; +import static gregtech.api.enums.UndergroundFluidNames.mediumOil; +import static gregtech.api.enums.UndergroundFluidNames.methane; +import static gregtech.api.enums.UndergroundFluidNames.moltenCopper; +import static gregtech.api.enums.UndergroundFluidNames.moltenIron; +import static gregtech.api.enums.UndergroundFluidNames.moltenLead; +import static gregtech.api.enums.UndergroundFluidNames.moltenTin; +import static gregtech.api.enums.UndergroundFluidNames.naturalGas; +import static gregtech.api.enums.UndergroundFluidNames.nitrogen; +import static gregtech.api.enums.UndergroundFluidNames.oil; +import static gregtech.api.enums.UndergroundFluidNames.oxygen; +import static gregtech.api.enums.UndergroundFluidNames.saltWater; +import static gregtech.api.enums.UndergroundFluidNames.sulfuricAcid; +import static gregtech.api.enums.UndergroundFluidNames.unknownWater; +import static gregtech.api.enums.UndergroundFluidNames.veryHeavyOil; + +import net.minecraftforge.common.DimensionManager; +import net.minecraftforge.common.config.ConfigCategory; +import net.minecraftforge.common.config.Configuration; + +import com.google.common.collect.BiMap; +import com.google.common.collect.HashBiMap; + +import gregtech.api.enums.Dimensions; +import gregtech.api.enums.UndergroundFluidNames; + +public class GTUODimensionList { + + private Configuration fConfig; + private String fCategory; + private final BiMap fDimensionList; + + public int[] blackList = new int[0]; + + public GTUODimensionList() { + fDimensionList = HashBiMap.create(); + } + + public void save() { + fConfig.save(); + } + + public GTUODimension GetDimension(int aDimension) { + if (CheckBlackList(aDimension)) return null; + if (fDimensionList.containsKey(Integer.toString(aDimension))) + return fDimensionList.get(Integer.toString(aDimension)); + for (BiMap.Entry dl : fDimensionList.entrySet()) + if (DimensionManager.getProvider(aDimension) + .getClass() + .getName() + .contains(dl.getValue().Dimension)) return dl.getValue(); + return fDimensionList.get("Default"); + } + + private boolean CheckBlackList(int aDimensionId) { + try { + return java.util.Arrays.binarySearch(blackList, aDimensionId) >= 0; + } catch (Exception e) { + e.printStackTrace(); + return false; + } + } + + public void SetConfigValues(String aDimensionName, String aDimension, String aName, String aRegistry, + int aMinAmount, int aMaxAmount, int aChance, int aDecreasePerOperationAmount) { + String Category = fCategory + "." + aDimensionName; + fConfig.get(Category, "Dimension", aDimension) + .getString(); + Category += "." + aName; + fConfig.get(Category, "Registry", aRegistry) + .getString(); + fConfig.get(Category, "MinAmount", aMinAmount) + .getInt(aMinAmount); + fConfig.get(Category, "MaxAmount", aMaxAmount) + .getInt(aMaxAmount); + fConfig.get(Category, "Chance", aChance) + .getInt(aChance); + fConfig.get(Category, "DecreasePerOperationAmount", aDecreasePerOperationAmount) + .getInt(aDecreasePerOperationAmount); + // IT IS IN BUCKETS!!! + } + + private void setOverworldValues() { + new ConfigSetter().dimension(Overworld) + .fluid(naturalGas) + .chance(20) + .decreaseAmount(5) + .maxAmount(350) + .minAmount(10) + .writeToConfig(); + + new ConfigSetter().dimension(Overworld) + .fluid(lightOil) + .chance(20) + .decreaseAmount(5) + .maxAmount(350) + .minAmount(10) + .writeToConfig(); + + new ConfigSetter().dimension(Overworld) + .fluid(mediumOil) + .chance(20) + .decreaseAmount(5) + .maxAmount(625) + .minAmount(0) + .writeToConfig(); + + new ConfigSetter().dimension(Overworld) + .fluid(heavyOil) + .chance(20) + .decreaseAmount(5) + .maxAmount(625) + .minAmount(0) + .writeToConfig(); + + new ConfigSetter().dimension(Overworld) + .fluid(oil) + .chance(20) + .decreaseAmount(5) + .maxAmount(625) + .minAmount(0) + .writeToConfig(); + } + + private void setMoonValues() { + new ConfigSetter().dimension(Moon) + .fluid(helium3) + .chance(100) + .decreaseAmount(5) + .maxAmount(425) + .minAmount(0) + .writeToConfig(); + + new ConfigSetter().dimension(Moon) + .fluid(saltWater) + .chance(20) + .decreaseAmount(5) + .maxAmount(200) + .minAmount(0) + .writeToConfig(); + } + + private void setMercuryValues() { + new ConfigSetter().dimension(Mercury) + .fluid(helium3) + .chance(100) + .decreaseAmount(5) + .maxAmount(800) + .minAmount(0) + .writeToConfig(); + + new ConfigSetter().dimension(Mercury) + .fluid(moltenIron) + .chance(30) + .decreaseAmount(5) + .maxAmount(400) + .minAmount(0) + .writeToConfig(); + } + + private void setVenusValues() { + new ConfigSetter().dimension(Venus) + .fluid(moltenLead) + .chance(100) + .decreaseAmount(5) + .maxAmount(1600) + .minAmount(0) + .writeToConfig(); + + new ConfigSetter().dimension(Venus) + .fluid(sulfuricAcid) + .chance(100) + .decreaseAmount(5) + .maxAmount(250) + .minAmount(0) + .writeToConfig(); + + new ConfigSetter().dimension(Venus) + .fluid(carbonDioxide) + .chance(100) + .decreaseAmount(5) + .maxAmount(1500) + .minAmount(0) + .writeToConfig(); + } + + private void setMarsValues() { + new ConfigSetter().dimension(Mars) + .fluid(saltWater) + .chance(100) + .decreaseAmount(5) + .maxAmount(400) + .minAmount(0) + .writeToConfig(); + + new ConfigSetter().dimension(Mars) + .fluid(chlorobenzene) + .chance(100) + .decreaseAmount(5) + .maxAmount(400) + .minAmount(0) + .writeToConfig(); + } + + private void setIoValues() { + new ConfigSetter().dimension(Io) + .fluid(moltenLead) + .chance(20) + .decreaseAmount(5) + .maxAmount(650) + .minAmount(0) + .writeToConfig(); + + new ConfigSetter().dimension(Io) + .fluid(sulfuricAcid) + .chance(80) + .decreaseAmount(5) + .maxAmount(350) + .minAmount(0) + .writeToConfig(); + + new ConfigSetter().dimension(Io) + .fluid(carbonDioxide) + .chance(80) + .decreaseAmount(5) + .maxAmount(750) + .minAmount(0) + .writeToConfig(); + } + + private void setEuropaValues() { + new ConfigSetter().dimension(Europa) + .fluid(saltWater) + .chance(100) + .decreaseAmount(5) + .maxAmount(800) + .minAmount(0) + .writeToConfig(); + + new ConfigSetter().dimension(Europa) + .fluid(veryHeavyOil) + .chance(20) + .decreaseAmount(5) + .maxAmount(200) + .minAmount(0) + .writeToConfig(); + + new ConfigSetter().dimension(Europa) + .fluid(distilledWater) + .chance(80) + .decreaseAmount(5) + .maxAmount(3500) + .minAmount(0) + .writeToConfig(); + } + + private void setCallistoValues() { + new ConfigSetter().dimension(Callisto) + .fluid(oxygen) + .chance(100) + .decreaseAmount(5) + .maxAmount(200) + .minAmount(0) + .writeToConfig(); + + new ConfigSetter().dimension(Callisto) + .fluid(liquidAir) + .chance(100) + .decreaseAmount(5) + .maxAmount(200) + .minAmount(0) + .writeToConfig(); + } + + private void setTitanValues() { + new ConfigSetter().dimension(Titan) + .fluid(methane) + .chance(100) + .decreaseAmount(5) + .maxAmount(800) + .minAmount(0) + .writeToConfig(); + + new ConfigSetter().dimension(Titan) + .fluid(ethane) + .chance(100) + .decreaseAmount(5) + .maxAmount(200) + .minAmount(0) + .writeToConfig(); + } + + private void setMirandaValues() { + new ConfigSetter().dimension(Miranda) + .fluid(hydrogenSulfide) + .chance(100) + .decreaseAmount(5) + .maxAmount(900) + .minAmount(0) + .writeToConfig(); + } + + private void setOberonValues() { + new ConfigSetter().dimension(Oberon) + .fluid(carbonMonoxide) + .chance(100) + .decreaseAmount(5) + .maxAmount(2000) + .minAmount(0) + .writeToConfig(); + } + + private void setTritonValues() { + new ConfigSetter().dimension(Triton) + .fluid(nitrogen) + .chance(100) + .decreaseAmount(5) + .maxAmount(800) + .minAmount(0) + .writeToConfig(); + + new ConfigSetter().dimension(Triton) + .fluid(ethylene) + .chance(100) + .decreaseAmount(5) + .maxAmount(800) + .minAmount(0) + .writeToConfig(); + } + + private void setProteusValues() { + new ConfigSetter().dimension(Proteus) + .fluid(deuterium) + .chance(100) + .decreaseAmount(5) + .maxAmount(700) + .minAmount(0) + .writeToConfig(); + } + + private void setPlutoValues() { + new ConfigSetter().dimension(Pluto) + .fluid(nitrogen) + .chance(100) + .decreaseAmount(5) + .maxAmount(800) + .minAmount(0) + .writeToConfig(); + + new ConfigSetter().dimension(Pluto) + .fluid(oxygen) + .chance(100) + .decreaseAmount(5) + .maxAmount(800) + .minAmount(0) + .writeToConfig(); + + new ConfigSetter().dimension(Pluto) + .fluid(liquidAir) + .chance(40) + .decreaseAmount(5) + .maxAmount(300) + .minAmount(4) + .writeToConfig(); + + new ConfigSetter().dimension(Pluto) + .fluid(fluorine) + .chance(80) + .decreaseAmount(5) + .maxAmount(800) + .minAmount(4) + .writeToConfig(); + } + + private void setMakeMakeValues() { + new ConfigSetter().dimension(Makemake) + .fluid(hydrofluoricAcid) + .chance(80) +