From 311ab89f93558233a40079f7cb16605b141b5346 Mon Sep 17 00:00:00 2001 From: Johann Bernhardt Date: Sun, 12 Dec 2021 19:38:06 +0100 Subject: Move sources and resources --- .../gtPlusPlus/api/damage/DamageTeslaTower.java | 24 ++ .../java/gtPlusPlus/api/enums/ParticleNames.java | 37 ++ src/main/java/gtPlusPlus/api/enums/Quality.java | 62 +++ .../api/helpers/GregtechPlusPlus_API.java | 203 ++++++++++ .../gtPlusPlus/api/helpers/MaterialHelper.java | 76 ++++ .../gtPlusPlus/api/interfaces/IChunkLoader.java | 33 ++ .../api/interfaces/IComparableRecipe.java | 8 + .../gtPlusPlus/api/interfaces/IEntityCatcher.java | 21 + .../gtPlusPlus/api/interfaces/IGeneratorWorld.java | 17 + .../api/interfaces/IGregtechPacketEntity.java | 13 + .../gtPlusPlus/api/interfaces/IGregtechPower.java | 145 +++++++ .../gtPlusPlus/api/interfaces/ILazyCoverable.java | 144 +++++++ .../java/gtPlusPlus/api/interfaces/IPlugin.java | 40 ++ .../api/interfaces/IRandomGenerator.java | 55 +++ .../gtPlusPlus/api/interfaces/ITexturedBlock.java | 14 + .../gtPlusPlus/api/interfaces/ITileTooltip.java | 7 + .../java/gtPlusPlus/api/interfaces/IToolable.java | 17 + .../api/interfaces/RunnableWithInfo.java | 12 + .../gtPlusPlus/api/objects/GregtechException.java | 28 ++ src/main/java/gtPlusPlus/api/objects/Logger.java | 179 ++++++++ .../java/gtPlusPlus/api/objects/data/AutoMap.java | 345 ++++++++++++++++ .../api/objects/data/ConcurrentHashSet.java | 18 + .../gtPlusPlus/api/objects/data/ConcurrentSet.java | 53 +++ .../gtPlusPlus/api/objects/data/FlexiblePair.java | 39 ++ .../java/gtPlusPlus/api/objects/data/ObjMap.java | 285 +++++++++++++ .../java/gtPlusPlus/api/objects/data/Pair.java | 35 ++ .../java/gtPlusPlus/api/objects/data/Quad.java | 45 +++ .../api/objects/data/ReverseAutoMap.java | 175 ++++++++ .../java/gtPlusPlus/api/objects/data/Triplet.java | 27 ++ .../gtPlusPlus/api/objects/data/TypeCounter.java | 178 ++++++++ .../api/objects/data/WeightedCollection.java | 102 +++++ .../api/objects/data/weakref/WeakAutoMap.java | 12 + .../gtPlusPlus/api/objects/minecraft/AABB.java | 65 +++ .../api/objects/minecraft/BTF_FluidTank.java | 188 +++++++++ .../api/objects/minecraft/BTF_Inventory.java | 228 +++++++++++ .../gtPlusPlus/api/objects/minecraft/BlockPos.java | 250 ++++++++++++ .../api/objects/minecraft/CubicObject.java | 62 +++ .../api/objects/minecraft/DimChunkPos.java | 52 +++ .../api/objects/minecraft/FakeBlockPos.java | 253 ++++++++++++ .../api/objects/minecraft/FakeWorld.java | 173 ++++++++ .../gtPlusPlus/api/objects/minecraft/FluidGT6.java | 31 ++ .../objects/minecraft/FormattedTooltipString.java | 25 ++ .../api/objects/minecraft/GenericStack.java | 42 ++ .../api/objects/minecraft/ItemPackage.java | 58 +++ .../api/objects/minecraft/ItemStackData.java | 35 ++ .../objects/minecraft/NoConflictGTRecipeMap.java | 123 ++++++ .../api/objects/minecraft/SafeTexture.java | 64 +++ .../api/objects/minecraft/ShapedRecipe.java | 250 ++++++++++++ .../api/objects/minecraft/TexturePackage.java | 55 +++ .../api/objects/minecraft/ThreadPooCollector.java | 111 +++++ .../minecraft/multi/NoEUBonusMultiBehaviour.java | 27 ++ .../multi/NoOutputBonusMultiBehaviour.java | 27 ++ .../multi/NoSpeedBonusMultiBehaviour.java | 27 ++ .../minecraft/multi/SpecialMultiBehaviour.java | 44 ++ .../api/objects/random/CSPRNG_DO_NOT_USE.java | 271 +++++++++++++ .../api/objects/random/UUIDGenerator.java | 449 +++++++++++++++++++++ .../java/gtPlusPlus/api/objects/random/XSTR.java | 278 +++++++++++++ .../java/gtPlusPlus/api/plugin/Sample_Plugin.java | 47 +++ .../api/thermal/energy/IThermalConnection.java | 7 + .../api/thermal/energy/IThermalContainerItem.java | 15 + .../api/thermal/energy/IThermalHandler.java | 15 + .../api/thermal/energy/IThermalProvider.java | 13 + .../api/thermal/energy/IThermalReceiver.java | 13 + .../api/thermal/energy/IThermalStorage.java | 13 + .../api/thermal/energy/ThermalStorage.java | 116 ++++++ .../api/thermal/energy/ThermalStorageAdv.java | 34 ++ .../api/thermal/sample/ItemThermalContainer.java | 84 ++++ .../api/thermal/sample/TileThermalHandler.java | 42 ++ .../api/thermal/tileentity/IThermalInfo.java | 13 + 69 files changed, 6049 insertions(+) create mode 100644 src/main/java/gtPlusPlus/api/damage/DamageTeslaTower.java create mode 100644 src/main/java/gtPlusPlus/api/enums/ParticleNames.java create mode 100644 src/main/java/gtPlusPlus/api/enums/Quality.java create mode 100644 src/main/java/gtPlusPlus/api/helpers/GregtechPlusPlus_API.java create mode 100644 src/main/java/gtPlusPlus/api/helpers/MaterialHelper.java create mode 100644 src/main/java/gtPlusPlus/api/interfaces/IChunkLoader.java create mode 100644 src/main/java/gtPlusPlus/api/interfaces/IComparableRecipe.java create mode 100644 src/main/java/gtPlusPlus/api/interfaces/IEntityCatcher.java create mode 100644 src/main/java/gtPlusPlus/api/interfaces/IGeneratorWorld.java create mode 100644 src/main/java/gtPlusPlus/api/interfaces/IGregtechPacketEntity.java create mode 100644 src/main/java/gtPlusPlus/api/interfaces/IGregtechPower.java create mode 100644 src/main/java/gtPlusPlus/api/interfaces/ILazyCoverable.java create mode 100644 src/main/java/gtPlusPlus/api/interfaces/IPlugin.java create mode 100644 src/main/java/gtPlusPlus/api/interfaces/IRandomGenerator.java create mode 100644 src/main/java/gtPlusPlus/api/interfaces/ITexturedBlock.java create mode 100644 src/main/java/gtPlusPlus/api/interfaces/ITileTooltip.java create mode 100644 src/main/java/gtPlusPlus/api/interfaces/IToolable.java create mode 100644 src/main/java/gtPlusPlus/api/interfaces/RunnableWithInfo.java create mode 100644 src/main/java/gtPlusPlus/api/objects/GregtechException.java create mode 100644 src/main/java/gtPlusPlus/api/objects/Logger.java create mode 100644 src/main/java/gtPlusPlus/api/objects/data/AutoMap.java create mode 100644 src/main/java/gtPlusPlus/api/objects/data/ConcurrentHashSet.java create mode 100644 src/main/java/gtPlusPlus/api/objects/data/ConcurrentSet.java create mode 100644 src/main/java/gtPlusPlus/api/objects/data/FlexiblePair.java create mode 100644 src/main/java/gtPlusPlus/api/objects/data/ObjMap.java create mode 100644 src/main/java/gtPlusPlus/api/objects/data/Pair.java create mode 100644 src/main/java/gtPlusPlus/api/objects/data/Quad.java create mode 100644 src/main/java/gtPlusPlus/api/objects/data/ReverseAutoMap.java create mode 100644 src/main/java/gtPlusPlus/api/objects/data/Triplet.java create mode 100644 src/main/java/gtPlusPlus/api/objects/data/TypeCounter.java create mode 100644 src/main/java/gtPlusPlus/api/objects/data/WeightedCollection.java create mode 100644 src/main/java/gtPlusPlus/api/objects/data/weakref/WeakAutoMap.java create mode 100644 src/main/java/gtPlusPlus/api/objects/minecraft/AABB.java create mode 100644 src/main/java/gtPlusPlus/api/objects/minecraft/BTF_FluidTank.java create mode 100644 src/main/java/gtPlusPlus/api/objects/minecraft/BTF_Inventory.java create mode 100644 src/main/java/gtPlusPlus/api/objects/minecraft/BlockPos.java create mode 100644 src/main/java/gtPlusPlus/api/objects/minecraft/CubicObject.java create mode 100644 src/main/java/gtPlusPlus/api/objects/minecraft/DimChunkPos.java create mode 100644 src/main/java/gtPlusPlus/api/objects/minecraft/FakeBlockPos.java create mode 100644 src/main/java/gtPlusPlus/api/objects/minecraft/FakeWorld.java create mode 100644 src/main/java/gtPlusPlus/api/objects/minecraft/FluidGT6.java create mode 100644 src/main/java/gtPlusPlus/api/objects/minecraft/FormattedTooltipString.java create mode 100644 src/main/java/gtPlusPlus/api/objects/minecraft/GenericStack.java create mode 100644 src/main/java/gtPlusPlus/api/objects/minecraft/ItemPackage.java create mode 100644 src/main/java/gtPlusPlus/api/objects/minecraft/ItemStackData.java create mode 100644 src/main/java/gtPlusPlus/api/objects/minecraft/NoConflictGTRecipeMap.java create mode 100644 src/main/java/gtPlusPlus/api/objects/minecraft/SafeTexture.java create mode 100644 src/main/java/gtPlusPlus/api/objects/minecraft/ShapedRecipe.java create mode 100644 src/main/java/gtPlusPlus/api/objects/minecraft/TexturePackage.java create mode 100644 src/main/java/gtPlusPlus/api/objects/minecraft/ThreadPooCollector.java create mode 100644 src/main/java/gtPlusPlus/api/objects/minecraft/multi/NoEUBonusMultiBehaviour.java create mode 100644 src/main/java/gtPlusPlus/api/objects/minecraft/multi/NoOutputBonusMultiBehaviour.java create mode 100644 src/main/java/gtPlusPlus/api/objects/minecraft/multi/NoSpeedBonusMultiBehaviour.java create mode 100644 src/main/java/gtPlusPlus/api/objects/minecraft/multi/SpecialMultiBehaviour.java create mode 100644 src/main/java/gtPlusPlus/api/objects/random/CSPRNG_DO_NOT_USE.java create mode 100644 src/main/java/gtPlusPlus/api/objects/random/UUIDGenerator.java create mode 100644 src/main/java/gtPlusPlus/api/objects/random/XSTR.java create mode 100644 src/main/java/gtPlusPlus/api/plugin/Sample_Plugin.java create mode 100644 src/main/java/gtPlusPlus/api/thermal/energy/IThermalConnection.java create mode 100644 src/main/java/gtPlusPlus/api/thermal/energy/IThermalContainerItem.java create mode 100644 src/main/java/gtPlusPlus/api/thermal/energy/IThermalHandler.java create mode 100644 src/main/java/gtPlusPlus/api/thermal/energy/IThermalProvider.java create mode 100644 src/main/java/gtPlusPlus/api/thermal/energy/IThermalReceiver.java create mode 100644 src/main/java/gtPlusPlus/api/thermal/energy/IThermalStorage.java create mode 100644 src/main/java/gtPlusPlus/api/thermal/energy/ThermalStorage.java create mode 100644 src/main/java/gtPlusPlus/api/thermal/energy/ThermalStorageAdv.java create mode 100644 src/main/java/gtPlusPlus/api/thermal/sample/ItemThermalContainer.java create mode 100644 src/main/java/gtPlusPlus/api/thermal/sample/TileThermalHandler.java create mode 100644 src/main/java/gtPlusPlus/api/thermal/tileentity/IThermalInfo.java (limited to 'src/main/java/gtPlusPlus/api') diff --git a/src/main/java/gtPlusPlus/api/damage/DamageTeslaTower.java b/src/main/java/gtPlusPlus/api/damage/DamageTeslaTower.java new file mode 100644 index 0000000000..f35c9cbc6b --- /dev/null +++ b/src/main/java/gtPlusPlus/api/damage/DamageTeslaTower.java @@ -0,0 +1,24 @@ +package gtPlusPlus.api.damage; + +import net.minecraft.entity.Entity; +import net.minecraft.entity.EntityLivingBase; +import net.minecraft.util.ChatComponentTranslation; +import net.minecraft.util.IChatComponent; + +import gtPlusPlus.core.world.damage.BaseCustomDamageSource; + +public class DamageTeslaTower extends BaseCustomDamageSource{ + + public DamageTeslaTower(Entity transmitter) { + super("plasmabolt", transmitter, null); + this.setDamageBypassesArmor(); + this.setDamageIsAbsolute(); + } + + @Override + public IChatComponent func_151519_b(EntityLivingBase target) { + String s = "death.attack." + this.damageType; + return new ChatComponentTranslation(s, target.getCommandSenderName(), "Plasma"); + } + +} diff --git a/src/main/java/gtPlusPlus/api/enums/ParticleNames.java b/src/main/java/gtPlusPlus/api/enums/ParticleNames.java new file mode 100644 index 0000000000..d082cd6779 --- /dev/null +++ b/src/main/java/gtPlusPlus/api/enums/ParticleNames.java @@ -0,0 +1,37 @@ +package gtPlusPlus.api.enums; + +public enum ParticleNames { + + explode, + largeexplode, + hugeexplosion, + bubble, + splash, + suspended, + depthsuspend, + crit, + magicCrit, + smoke, + largesmoke, + spell, + instantSpell, + mobSpell, + dripWater, + dripLava, + townaura, + note, + portal, + enchantmenttable, + flame, + lava, + footstep, + cloud, + reddust, + snowballpoof, + snowshovel, + slime, + heart, + iconcrack_, + tilecrack_; + +} diff --git a/src/main/java/gtPlusPlus/api/enums/Quality.java b/src/main/java/gtPlusPlus/api/enums/Quality.java new file mode 100644 index 0000000000..050f335b5e --- /dev/null +++ b/src/main/java/gtPlusPlus/api/enums/Quality.java @@ -0,0 +1,62 @@ +package gtPlusPlus.api.enums; + +import net.minecraft.util.EnumChatFormatting; + +import gtPlusPlus.core.util.math.MathUtils; + +public enum Quality { + + // Magic Blue + // Rare Yellow + // Set Green + // Unique Gold/Purple + // Trade-off Brown + + POOR("Poor", EnumChatFormatting.GRAY), COMMON("Common", EnumChatFormatting.WHITE), UNCOMMON("Uncommon", + EnumChatFormatting.DARK_GREEN), MAGIC("Magic", EnumChatFormatting.BLUE), RARE("Rare", + EnumChatFormatting.YELLOW), UNIQUE("Unique", EnumChatFormatting.GOLD), ARTIFACT("Artifact", + EnumChatFormatting.AQUA), SET("Set Piece", EnumChatFormatting.GREEN), TRADEOFF("Trade-off", + EnumChatFormatting.DARK_RED), EPIC("Epic", EnumChatFormatting.LIGHT_PURPLE); + + private String LOOT; + private EnumChatFormatting COLOUR; + + private Quality(final String lootTier, final EnumChatFormatting tooltipColour) { + this.LOOT = lootTier; + this.COLOUR = tooltipColour; + } + + public String getQuality() { + return this.LOOT; + } + + protected EnumChatFormatting getColour() { + return this.COLOUR; + } + + public String formatted() { + return this.COLOUR + this.LOOT; + } + + public static Quality getRandomQuality() { + final int lootChance = MathUtils.randInt(0, 100); + if (lootChance <= 10) { + return Quality.POOR; + } else if (lootChance <= 45) { + return Quality.COMMON; + } else if (lootChance <= 65) { + return Quality.UNCOMMON; + } else if (lootChance <= 82) { + return Quality.MAGIC; + } else if (lootChance <= 92) { + return Quality.EPIC; + } else if (lootChance <= 97) { + return Quality.RARE; + } else if (lootChance <= 99) { + return Quality.ARTIFACT; + } else { + return null; + } + } + +} diff --git a/src/main/java/gtPlusPlus/api/helpers/GregtechPlusPlus_API.java b/src/main/java/gtPlusPlus/api/helpers/GregtechPlusPlus_API.java new file mode 100644 index 0000000000..6fe4209efe --- /dev/null +++ b/src/main/java/gtPlusPlus/api/helpers/GregtechPlusPlus_API.java @@ -0,0 +1,203 @@ +package gtPlusPlus.api.helpers; + +import java.util.HashMap; + +import gtPlusPlus.api.objects.Logger; +import gtPlusPlus.api.objects.data.WeightedCollection; +import gtPlusPlus.api.objects.minecraft.multi.SpecialMultiBehaviour; +import gtPlusPlus.core.util.minecraft.ItemUtils; +import gtPlusPlus.xmod.gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Energy_RTG; +import gtPlusPlus.xmod.gregtech.api.util.SpecialBehaviourTooltipHandler; +import net.minecraft.block.Block; +import net.minecraft.item.ItemStack; + +public class GregtechPlusPlus_API { + + public static class Multiblock_API { + + private static final HashMap mSpecialBehaviourItemMap = new HashMap(); + + /** + * Register a special behaviour for GT++ Multis to listen use. + * @param aBehaviour - An Object which has extended {@link SpecialMultiBehaviour}'s base implementation. + * @return - Did this behaviour register properly? + */ + public static boolean registerSpecialMultiBehaviour(SpecialMultiBehaviour aBehaviour) { + if (aBehaviour.getTriggerItem() == null || aBehaviour.getTriggerItemTooltip() == null || aBehaviour.getTriggerItemTooltip().length() <= 0) { + Logger.INFO("Failed to attach custom multiblock logic to "+ItemUtils.getItemName(aBehaviour.getTriggerItem())); + return false; + } + mSpecialBehaviourItemMap.put("UniqueKey_"+aBehaviour.hashCode(), aBehaviour); + SpecialBehaviourTooltipHandler.addTooltipForItem(aBehaviour.getTriggerItem(), aBehaviour.getTriggerItemTooltip()); + Logger.INFO("Attached custom multiblock logic to "+ItemUtils.getItemName(aBehaviour.getTriggerItem())); + return true; + } + + public static final HashMap getSpecialBehaviourItemMap() { + return mSpecialBehaviourItemMap; + } + + /** + * Allows RTG Fuel pellets from other mods to be used in the RTG hatch. + * @param aStack - The Pellet Stack, sanitsed after passing through. + * @param aFuelValue - The Fuel Value of the Pellet to be added to the energy storage. + * @return - Did register? + */ + public static boolean registerPelletForRtgHatch(ItemStack aStack, long aFuelValue) { + return GT_MetaTileEntity_Hatch_Energy_RTG.registerPelletForHatch(aStack, aFuelValue); + } + + } + + public static class VoidMiner_API { + + private static final HashMap>> mMinerLootCache; + + static { + mMinerLootCache = new HashMap>>(); + } + + + /** + * + * Registers an ore block for a dimension. Uses a default weight of 100. + * @param aDim - The Dimension ID + * @param aOredictName - The OreDict name of the Ore to be mined. + * @return - If there was a valid Block found in the OreDict for the provided name. + */ + public static boolean registerOreForVoidMiner(int aDim, String aOredictName) { + return registerOreForVoidMiner(aDim, aOredictName, 100); + } + + /** + * + * Registers an ore block for a dimension. Uses a default weight of 100. + * @param aDim - The Dimension ID + * @param aOredictName - The OreDict name of the Ore to be mined. + * @param aWeight - The weight of this ore Block. + * @return - If there was a valid Block found in the OreDict for the provided name. + */ + public static boolean registerOreForVoidMiner(int aDim, String aOredictName, int aWeight) { + Block b = null; + ItemStack[] aValidItems = ItemUtils.validItemsForOreDict(aOredictName); + for (ItemStack g : aValidItems) { + if (g != null) { + b = Block.getBlockFromItem(g.getItem()); + if (b != null) { + break; + } + } + } + if (b != null) { + registerOreForVoidMiner(aDim, b, aWeight); + return true; + } + return false; + } + + + /** + * Registers an ore block for a dimension. Uses a default weight of 100. + * @param aDim - The Dimension ID + * @param aOreBlock - The Ore Block to be mined. + */ + public static void registerOreForVoidMiner(int aDim, Block aOreBlock) { + registerOreForVoidMiner(aDim, aOreBlock, 100); + } + + /** + * Registers an ore block for a dimension. + * @param aDim - The Dimension ID + * @param aOreBlock - The Ore Block to be mined. + * @param aWeight - The weight of this ore Block. + */ + public static void registerOreForVoidMiner(int aDim, Block aOreBlock, int aWeight) { + GregtechPlusPlus_API_Internal.writeBlockToDimensionInCache(aDim, 0, aOreBlock, aWeight); + } + + /** + * Registers a surface block for a dimension. Uses a default weight of 100. + * @param aDim - The Dimension ID + * @param aDirtBlock - The Dirt/Grass Block to be mined. + */ + public static void registerEarthSurfaceForVoidMiner(int aDim, Block aDirtBlock) { + registerEarthSurfaceForVoidMiner(aDim, aDirtBlock, 100); + } + + /** + * Registers a surface block for a dimension. + * @param aDim - The Dimension ID + * @param aDirtBlock - The Dirt/Grass Block to be mined. + * @param aWeight - The weight of this Dirt/Grass Block. + */ + public static void registerEarthSurfaceForVoidMiner(int aDim, Block aDirtBlock, int aWeight) { + GregtechPlusPlus_API_Internal.writeBlockToDimensionInCache(aDim, 0, aDirtBlock, aWeight); + } + + /** + * Registers a stone block for a dimension. Uses a default weight of 100. + * @param aDim - The Dimension ID + * @param aStoneBlock - The Stone Block to be mined. + */ + public static void registerEarthStoneForVoidMiner(int aDim, Block aStoneBlock) { + registerEarthStoneForVoidMiner(aDim, aStoneBlock, 100); + } + + /** + * Registers a stone block for a dimension. + * @param aDim - The Dimension ID + * @param aStoneBlock - The Stone Block to be mined. + * @param aWeight - The weight of this Stone Block. + */ + public static void registerEarthStoneForVoidMiner(int aDim, Block aStoneBlock, int aWeight) { + GregtechPlusPlus_API_Internal.writeBlockToDimensionInCache(aDim, 0, aStoneBlock, aWeight); + } + + + + + public static WeightedCollection getAllRegisteredOresForDimension(int aDim) { + return mMinerLootCache.get(aDim).get("ore"); + } + + public static WeightedCollection getAllRegisteredDirtTypesForDimension(int aDim) { + return mMinerLootCache.get(aDim).get("dirt"); + } + + public static WeightedCollection getAllRegisteredStoneTypesForDimension(int aDim) { + return mMinerLootCache.get(aDim).get("stone"); + } + + public static final HashMap>> getVoidMinerLootCache() { + return mMinerLootCache; + } + + } + + + private static class GregtechPlusPlus_API_Internal { + + private static void writeBlockToDimensionInCache(int aDim, int aType, Block aBlock, int aWeight) { + HashMap> aDimMap = VoidMiner_API.mMinerLootCache.get(aDim); + if (aDimMap == null) { + aDimMap = new HashMap>(); + } + WeightedCollection aMappedBlocks = getBlockMap(aType, aDimMap); + aMappedBlocks.put(aWeight, aBlock); + + } + + private static WeightedCollection getBlockMap(int aType, HashMap> aDimMap){ + WeightedCollection aMappedBlocks; + String aTypeName = ((aType == 0) ? "ore" : (aType == 1) ? "dirt" : (aType == 2) ? "stone" : "error"); + aMappedBlocks = aDimMap.get(aTypeName); + if (aMappedBlocks == null) { + aMappedBlocks = new WeightedCollection(); + } + return aMappedBlocks; + } + + } + + +} diff --git a/src/main/java/gtPlusPlus/api/helpers/MaterialHelper.java b/src/main/java/gtPlusPlus/api/helpers/MaterialHelper.java new file mode 100644 index 0000000000..9d2e894d99 --- /dev/null +++ b/src/main/java/gtPlusPlus/api/helpers/MaterialHelper.java @@ -0,0 +1,76 @@ +package gtPlusPlus.api.helpers; + +import net.minecraft.item.ItemStack; + +import java.lang.reflect.Constructor; +import java.lang.reflect.InvocationTargetException; + +import gregtech.api.enums.Materials; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.metatileentity.implementations.GT_MetaPipeEntity_Fluid; +import gregtech.api.util.GT_OreDictUnificator; +import gtPlusPlus.core.material.Material; +import gtPlusPlus.core.recipe.common.CI; +import gtPlusPlus.core.util.Utils; +import gtPlusPlus.core.util.minecraft.ItemUtils; + +public class MaterialHelper { + + public static ItemStack getComponentFromMaterial(OrePrefixes oreprefix, Material material, int amount){ + return ItemUtils.getOrePrefixStack(oreprefix, material, amount); + } + public static ItemStack getComponentFromGtMaterial(OrePrefixes oreprefix, Materials material, int amount){ + return ItemUtils.getGregtechOreStack(oreprefix, material, amount); + } + + /** + * Generates a 16 Fluid Pipe + * @see {@code Example: Copper 16x Pipe (Materials.Copper, Materials.Copper.mName, "Copper", ID, 60, 1000, true)} + * @param aMaterial - Pipe Material + * @param name - Pipe Internal name + * @param displayName - Pipe Display Name + * @param aID - Pipe's Meta ID + * @param baseCapacity - Pipes Base Capacity + * @param heatCapacity - Pipe Max Temp + * @param gasProof - Is Gas Proof? + * @return A boolean which corresponds to whether or not the Pipe was registered to the Ore Dictionary. + */ + public static boolean generateHexadecuplePipe(Materials aMaterial, String name, String displayName, int aID, + int baseCapacity, int heatCapacity, boolean gasProof) { + if (Utils.getGregtechVersionAsInt() >= 50930) { + try { + Class aPipeEntity = GT_MetaPipeEntity_Fluid.class; + Constructor constructor = aPipeEntity + .getConstructor(new Class[] { int.class, String.class, String.class, float.class, + Materials.class, int.class, int.class, boolean.class, int.class }); + if (constructor != null) { + GT_MetaPipeEntity_Fluid aPipe; + aPipe = constructor.newInstance(aID, "GT_Pipe_" + name + "_Hexadecuple", + "Hexadecuple " + displayName + " Fluid Pipe", 1.0F, aMaterial, baseCapacity, heatCapacity, + gasProof, 16); + return GT_OreDictUnificator.registerOre("pipeHexadecuple" + aMaterial, aPipe.getStackForm(1L)); + } + + } catch (NoSuchMethodException | SecurityException | InstantiationException | IllegalAccessException + | IllegalArgumentException | InvocationTargetException e) { + } + } + return false; + } + + public static ItemStack getCells(Materials aMaterial, int i) { + return ItemUtils.getOrePrefixStack(OrePrefixes.cell, aMaterial, i); + } + public static ItemStack getDust(Materials aMaterial, int i) { + return ItemUtils.getOrePrefixStack(OrePrefixes.dust, aMaterial, i); + } + public static ItemStack getDustSmall(Materials aMaterial, int i) { + return ItemUtils.getOrePrefixStack(OrePrefixes.dustSmall, aMaterial, i); + } + public static ItemStack getDustTiny(Materials aMaterial, int i) { + return ItemUtils.getOrePrefixStack(OrePrefixes.dustTiny, aMaterial, i); + } + public static ItemStack getGems(Materials aMaterial, int i) { + return ItemUtils.getOrePrefixStack(OrePrefixes.gem, aMaterial, i); + } +} diff --git a/src/main/java/gtPlusPlus/api/interfaces/IChunkLoader.java b/src/main/java/gtPlusPlus/api/interfaces/IChunkLoader.java new file mode 100644 index 0000000000..c04e25f570 --- /dev/null +++ b/src/main/java/gtPlusPlus/api/interfaces/IChunkLoader.java @@ -0,0 +1,33 @@ +package gtPlusPlus.api.interfaces; + +import java.util.Set; + +import net.minecraft.world.ChunkCoordIntPair; + +public interface IChunkLoader { + + public long getTicksRemaining(); + + public void setTicksRemaining(long aTicks); + + public ChunkCoordIntPair getResidingChunk(); + + public void setResidingChunk(ChunkCoordIntPair aCurrentChunk); + + public boolean getChunkLoadingActive(); + + public void setChunkLoadingActive(boolean aActive); + + public boolean getDoesWorkChunkNeedReload(); + + public void setDoesWorkChunkNeedReload(boolean aActive); + + public boolean addChunkToLoadedList(ChunkCoordIntPair aActiveChunk); + + public boolean removeChunkFromLoadedList(ChunkCoordIntPair aActiveChunk); + + public Set getManagedChunks(); + + public int getChunkloaderTier(); + +} diff --git a/src/main/java/gtPlusPlus/api/interfaces/IComparableRecipe.java b/src/main/java/gtPlusPlus/api/interfaces/IComparableRecipe.java new file mode 100644 index 0000000000..ddbf9f38bb --- /dev/null +++ b/src/main/java/gtPlusPlus/api/interfaces/IComparableRecipe.java @@ -0,0 +1,8 @@ +package gtPlusPlus.api.interfaces; + +import gregtech.api.util.GT_Recipe; +import gregtech.api.util.GTPP_Recipe; + +public interface IComparableRecipe extends Comparable{ + +} diff --git a/src/main/java/gtPlusPlus/api/interfaces/IEntityCatcher.java b/src/main/java/gtPlusPlus/api/interfaces/IEntityCatcher.java new file mode 100644 index 0000000000..5ab90d47ce --- /dev/null +++ b/src/main/java/gtPlusPlus/api/interfaces/IEntityCatcher.java @@ -0,0 +1,21 @@ +package gtPlusPlus.api.interfaces; + +import net.minecraft.entity.Entity; +import net.minecraft.item.ItemStack; +import net.minecraft.world.World; + +import gtPlusPlus.api.objects.minecraft.BlockPos; + +public interface IEntityCatcher { + + public boolean hasEntity(ItemStack aStack); + + public Entity getStoredEntity(World aWorld, ItemStack aStack); + + public boolean setStoredEntity(World aWorld, ItemStack aStack, Entity aEntity); + + public Class getStoredEntityClass(ItemStack aStack); + + public boolean spawnStoredEntity(World aWorld, ItemStack aStack, BlockPos aPos); + +} diff --git a/src/main/java/gtPlusPlus/api/interfaces/IGeneratorWorld.java b/src/main/java/gtPlusPlus/api/interfaces/IGeneratorWorld.java new file mode 100644 index 0000000000..63f2adbba7 --- /dev/null +++ b/src/main/java/gtPlusPlus/api/interfaces/IGeneratorWorld.java @@ -0,0 +1,17 @@ +package gtPlusPlus.api.interfaces; + +import java.util.Random; +import net.minecraft.world.World; + +public abstract interface IGeneratorWorld +{ + public abstract boolean generate(World paramWorld, Random paramRandom, int paramInt1, int paramInt2); + + public abstract void initiate(); + + public abstract int getExtentX(); + + public abstract int getExtentZ(); + + public abstract int getRange(); +} diff --git a/src/main/java/gtPlusPlus/api/interfaces/IGregtechPacketEntity.java b/src/main/java/gtPlusPlus/api/interfaces/IGregtechPacketEntity.java new file mode 100644 index 0000000000..fa59c58d9f --- /dev/null +++ b/src/main/java/gtPlusPlus/api/interfaces/IGregtechPacketEntity.java @@ -0,0 +1,13 @@ +package gtPlusPlus.api.interfaces; + +import java.io.DataInputStream; +import java.io.DataOutputStream; +import java.io.IOException; + +public interface IGregtechPacketEntity { + + public void writePacketData(DataOutputStream data) throws IOException; + + public void readPacketData(DataInputStream data) throws IOException; + +} diff --git a/src/main/java/gtPlusPlus/api/interfaces/IGregtechPower.java b/src/main/java/gtPlusPlus/api/interfaces/IGregtechPower.java new file mode 100644 index 0000000000..4bb29b3354 --- /dev/null +++ b/src/main/java/gtPlusPlus/api/interfaces/IGregtechPower.java @@ -0,0 +1,145 @@ +package gtPlusPlus.api.interfaces; + +import net.minecraft.block.Block; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; + +import gregtech.api.interfaces.IDescribable; +import gregtech.api.interfaces.tileentity.*; + +public abstract interface IGregtechPower extends IGearEnergyTileEntity, ITurnable, IGregTechDeviceInformation, IDescribable, IBasicEnergyContainer { + + @Override + public String[] getDescription(); + + @Override + default boolean isUniversalEnergyStored(long p0) { + return false; + } + + @Override + public long getOutputAmperage(); + + @Override + public long getOutputVoltage(); + + @Override + public long getInputAmperage(); + + @Override + public long getInputVoltage(); + + @Override + public boolean decreaseStoredEnergyUnits(long p0, boolean p1); + + @Override + public boolean increaseStoredEnergyUnits(long p0, boolean p1); + + @Override + public boolean drainEnergyUnits(byte p0, long p1, long p2); + + @Override + public long getAverageElectricInput(); + + @Override + public long getAverageElectricOutput(); + + @Override + public long getStoredEU(); + + @Override + public long getEUCapacity(); + + @Override + public long getStoredSteam(); + + @Override + public long getSteamCapacity(); + + @Override + public boolean increaseStoredSteam(long p0, boolean p1); + + @Override + public Block getBlockAtSide(byte p0); + + @Override + public Block getBlockAtSideAndDistance(byte p0, int p1); + + @Override + public Block getBlockOffset(int p0, int p1, int p2); + + + @Override + public TileEntity getTileEntity(int p0, int p1, int p2); + + @Override + public TileEntity getTileEntityAtSide(byte p0); + + @Override + public TileEntity getTileEntityAtSideAndDistance(byte p0, int p1); + + @Override + public TileEntity getTileEntityOffset(int p0, int p1, int p2); + + @Override + public World getWorld(); + + @Override + public int getXCoord(); + + @Override + public short getYCoord(); + + @Override + public int getZCoord(); + + @Override + public boolean isClientSide(); + + @Override + public boolean isDead(); + + @Override + public boolean isInvalidTileEntity(); + + @Override + public boolean isServerSide(); + + @Override + public void readFromNBT(NBTTagCompound p0); + + @Override + public void writeToNBT(NBTTagCompound p0); + + @Override + public boolean acceptsRotationalEnergy(byte p0); + + @Override + public boolean injectRotationalEnergy(byte p0, long p1, long p2); + + @Override + public long injectEnergyUnits(byte p0, long p1, long p2); + + @Override + public boolean inputEnergyFrom(byte p0); + + @Override + public boolean outputsEnergyTo(byte p0); + + @Override + public String[] getInfoData(); + + @Override + default public boolean isGivingInformation() { + return true; + } + +/* boolean onPreTick(TilePoweredGT tilePoweredGT, long mTickTimer2); + + boolean onTick(TilePoweredGT iGregTechTileEntity, long mTickTimer2); + + boolean onPostTick(TilePoweredGT iGregTechTileEntity, long mTickTimer2);*/ + + +} diff --git a/src/main/java/gtPlusPlus/api/interfaces/ILazyCoverable.java b/src/main/java/gtPlusPlus/api/interfaces/ILazyCoverable.java new file mode 100644 index 0000000000..9e1a7431db --- /dev/null +++ b/src/main/java/gtPlusPlus/api/interfaces/ILazyCoverable.java @@ -0,0 +1,144 @@ +package gtPlusPlus.api.interfaces; + +import gregtech.api.interfaces.tileentity.ICoverable; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; + +public interface ILazyCoverable extends ICoverable { + + @Override + default byte getColorization() { + return 0; + } + + @Override + default byte setColorization(byte arg0) { + return 0; + } + + @Override + default byte getInputRedstoneSignal(byte arg0) { + return 0; + } + + @Override + default byte getStrongestRedstone() { + return 0; + } + + @Override + default boolean getRedstone() { + // TODO Auto-generated method stub + return false; + } + + @Override + default boolean getRedstone(byte arg0) { + return false; + } + + @Override + default boolean isUniversalEnergyStored(long arg0) { + return false; + } + + @Override + default long getUniversalEnergyStored() { + return 0; + } + + @Override + default long getUniversalEnergyCapacity() { + return 0; + } + + @Override + default long getStoredSteam() { + return 0; + } + + @Override + default long getSteamCapacity() { + return 0; + } + + @Override + default boolean increaseStoredSteam(long arg0, boolean arg2) { + return false; + } + + @Override + default byte getOutputRedstoneSignal(byte arg0) { + return 0; + } + + @Override + default void setOutputRedstoneSignal(byte arg0, byte arg1) { + + } + + @Override + default byte getStrongOutputRedstoneSignal(byte arg0) { + return 0; + } + + @Override + default void setStrongOutputRedstoneSignal(byte arg0, byte arg1) { + + } + + @Override + default byte getComparatorValue(byte arg0) { + return 0; + } + + @Override + default IGregTechTileEntity getIGregTechTileEntity(int arg0, int arg1, int arg2) { + return null; + } + + @Override + default IGregTechTileEntity getIGregTechTileEntityOffset(int arg0, int arg1, int arg2) { + return null; + } + + @Override + default IGregTechTileEntity getIGregTechTileEntityAtSide(byte arg0) { + return null; + } + + @Override + default IGregTechTileEntity getIGregTechTileEntityAtSideAndDistance(byte arg0, int arg1) { + return null; + } + + @Override + default byte getMetaID(int arg0, int arg1, int arg2) { + return 0; + } + + @Override + default byte getMetaIDOffset(int arg0, int arg1, int arg2) { + return 0; + } + + @Override + default byte getMetaIDAtSide(byte arg0) { + return 0; + } + + @Override + default byte getMetaIDAtSideAndDistance(byte arg0, int arg1) { + return 0; + } + + @Override + default boolean isDead() { + return false; + } + + @Override + default void setLightValue(byte arg0) { + + } + +} diff --git a/src/main/java/gtPlusPlus/api/interfaces/IPlugin.java b/src/main/java/gtPlusPlus/api/interfaces/IPlugin.java new file mode 100644 index 0000000000..67be182402 --- /dev/null +++ b/src/main/java/gtPlusPlus/api/interfaces/IPlugin.java @@ -0,0 +1,40 @@ +package gtPlusPlus.api.interfaces; + +import gtPlusPlus.api.objects.Logger; + +public interface IPlugin { + + /** + * @return A {@link String} object which returns the {@link IPlugin}'s name. + */ + public String getPluginName(); + + /** + * @return + * A {@link String} object which returns the {@link IPlugin}'s short name. + * This String should only contain 4 Characters. + */ + public String getPluginAbbreviation(); + + /** + * @param message - A {@link String} object which holds a message to be logged to console. + */ + default void log(String message) { + Logger.INFO("["+getPluginAbbreviation()+"] "+message); + } + + /** + * @param message - A {@link String} object which holds a warning/error message to be logged to console. + */ + default void logDebug(String message) { + Logger.WARNING("["+getPluginAbbreviation()+"] "+message); + } + + public boolean preInit(); + public boolean init(); + public boolean postInit(); + + public boolean serverStart(); + public boolean serverStop(); + +} diff --git a/src/main/java/gtPlusPlus/api/interfaces/IRandomGenerator.java b/src/main/java/gtPlusPlus/api/interfaces/IRandomGenerator.java new file mode 100644 index 0000000000..233fb93d4d --- /dev/null +++ b/src/main/java/gtPlusPlus/api/interfaces/IRandomGenerator.java @@ -0,0 +1,55 @@ +/* + * Copyright 2005, Nick Galbreath -- nickg [at] modp [dot] com + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * Neither the name of the modp.com nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * This is the standard "new" BSD license: + * http://www.opensource.org/licenses/bsd-license.php + */ + +package gtPlusPlus.api.interfaces; + +/** + * Simplified interface for random number generation + * + * @author Nick Galbreath -- nickg [at] modp [dot] com + * @version 1 -- 06-Jul-2005 + */ +public interface IRandomGenerator { + + /** + * Returns N random bits + * + * See also java.util.Random#next + * @param numBits + * @return and int with the LSB being random + */ + public int next(int numBits); + +} diff --git a/src/main/java/gtPlusPlus/api/interfaces/ITexturedBlock.java b/src/main/java/gtPlusPlus/api/interfaces/ITexturedBlock.java new file mode 100644 index 0000000000..47e692bffb --- /dev/null +++ b/src/main/java/gtPlusPlus/api/interfaces/ITexturedBlock.java @@ -0,0 +1,14 @@ +package gtPlusPlus.api.interfaces; + +import net.minecraft.block.Block; + +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.tileentity.ITexturedTileEntity; + +public interface ITexturedBlock extends ITexturedTileEntity{ + + ITexture[] getTexture(byte side); + + ITexture[] getTexture(Block block, byte side); + +} diff --git a/src/main/java/gtPlusPlus/api/interfaces/ITileTooltip.java b/src/main/java/gtPlusPlus/api/interfaces/ITileTooltip.java new file mode 100644 index 0000000000..08866c2712 --- /dev/null +++ b/src/main/java/gtPlusPlus/api/interfaces/ITileTooltip.java @@ -0,0 +1,7 @@ +package gtPlusPlus.api.interfaces; + +public interface ITileTooltip { + + public abstract int getTooltipID(); + +} diff --git a/src/main/java/gtPlusPlus/api/interfaces/IToolable.java b/src/main/java/gtPlusPlus/api/interfaces/IToolable.java new file mode 100644 index 0000000000..24797825a9 --- /dev/null +++ b/src/main/java/gtPlusPlus/api/interfaces/IToolable.java @@ -0,0 +1,17 @@ +package gtPlusPlus.api.interfaces; + +public interface IToolable { + + public boolean isScrewdriverable(); + public boolean onScrewdriverLMB(); + public boolean onScrewdriverRMB(); + + public boolean isWrenchable(); + public boolean onWrenchLMB(); + public boolean onWrenchRMB(); + + public boolean isMalletable(); + public boolean onMalletLMB(); + public boolean onMalletRMB(); + +} diff --git a/src/main/java/gtPlusPlus/api/interfaces/RunnableWithInfo.java b/src/main/java/gtPlusPlus/api/interfaces/RunnableWithInfo.java new file mode 100644 index 0000000000..4f4b9d7acd --- /dev/null +++ b/src/main/java/gtPlusPlus/api/interfaces/RunnableWithInfo.java @@ -0,0 +1,12 @@ +package gtPlusPlus.api.interfaces; + +public interface RunnableWithInfo extends Runnable { + + public V getInfoData(); + + default public Class getInfoDataType() { + return getInfoData().getClass(); + } + + +} diff --git a/src/main/java/gtPlusPlus/api/objects/GregtechException.java b/src/main/java/gtPlusPlus/api/objects/GregtechException.java new file mode 100644 index 0000000000..916dbc4aaf --- /dev/null +++ b/src/main/java/gtPlusPlus/api/objects/GregtechException.java @@ -0,0 +1,28 @@ +package gtPlusPlus.api.objects; + +public class GregtechException extends Throwable { + + private static final long serialVersionUID = 3601884582161841486L; + + public GregtechException(String aError) { + this(aError, true); + } + + public GregtechException(String aError, boolean aIsVerbose) { + Logger.ERROR("Throwing GT++ Exception!"); + Logger.ERROR("[EXCEPTION] "+aError); + if (aIsVerbose) { + Logger.INFO("Throwing GT++ Exception!"); + Logger.INFO("[EXCEPTION] "+aError); + printStackTrace(); + } + } + + @Override + public void printStackTrace() { + super.printStackTrace(); + } + + + +} diff --git a/src/main/java/gtPlusPlus/api/objects/Logger.java b/src/main/java/gtPlusPlus/api/objects/Logger.java new file mode 100644 index 0000000000..1a1da6868b --- /dev/null +++ b/src/main/java/gtPlusPlus/api/objects/Logger.java @@ -0,0 +1,179 @@ +package gtPlusPlus.api.objects; + +import cpw.mods.fml.common.FMLLog; +import cpw.mods.fml.relauncher.FMLRelaunchLog; +import gtPlusPlus.core.lib.CORE; +import gtPlusPlus.preloader.CORE_Preloader; +import gtPlusPlus.preloader.asm.AsmConfig; +import org.apache.logging.log4j.LogManager; + +public class Logger { + + public Logger(String string) { + + } + + // Logging Functions + public static final org.apache.logging.log4j.Logger modLogger = Logger.makeLogger(); + + // Generate GT++ Logger + public static org.apache.logging.log4j.Logger makeLogger() { + final org.apache.logging.log4j.Logger gtPlusPlusLogger = LogManager.getLogger("GT++"); + return gtPlusPlusLogger; + } + + private static final boolean enabled = !AsmConfig.disableAllLogging; + + public static final org.apache.logging.log4j.Logger getLogger() { + return modLogger; + } + + // Non-Dev Comments + public static void INFO(final String s) { + if (enabled) { + modLogger.info(s); + } + } + + // Non-Dev Comments + public static void MACHINE_INFO(String s, Object... args) { + if (enabled) { + boolean localPlayer = CORE_Preloader.DEV_ENVIRONMENT; + if (CORE.ConfigSwitches.MACHINE_INFO || localPlayer) { + final String name1 = gtPlusPlus.core.util.reflect.ReflectionUtils.getMethodName(2); + modLogger.info("Machine Info: " + s + " | " + name1, args); + } + } + } + + // Developer Comments + public static void WARNING(final String s) { + if (enabled) { + if (CORE_Preloader.DEBUG_MODE) { + modLogger.warn(s); + } + } + } + + // Errors + public static void ERROR(final String s) { + if (enabled) { + if (CORE_Preloader.DEBUG_MODE) { + modLogger.fatal(s); + } + } + } + + // Developer Logger + public static void SPECIFIC_WARNING(final String whatToLog, final String msg, final int line) { + if (enabled) { + // if (!CORE_Preloader.DEBUG_MODE){ + FMLLog.warning("GT++ |" + line + "| " + whatToLog + " | " + msg); + // } + } + } + + // ASM Comments + public static void LOG_ASM(final String s) { + if (enabled) { + FMLRelaunchLog.info("[Special ASM Logging] ", s); + } + } + + + + + + + + + + + /** + * Special Loggers + */ + + /** + * Special Logger for Bee related content + */ + public static void BEES(final String s) { + if (enabled) { + if (CORE_Preloader.DEV_ENVIRONMENT || CORE_Preloader.DEBUG_MODE) { + modLogger.info("[Bees] "+s); + } + } + } + /** + * Special Logger for Debugging Bee related content + */ + public static void DEBUG_BEES(final String s) { + if (enabled) { + if (CORE_Preloader.DEV_ENVIRONMENT || CORE_Preloader.DEBUG_MODE) { + modLogger.info("[Debug][Bees] "+s); + } + } + } + + + + /** + * Special Logger for Materials related content + */ + public static void MATERIALS(final String s) { + if (enabled) { + if (CORE_Preloader.DEV_ENVIRONMENT || CORE_Preloader.DEBUG_MODE) { + modLogger.info("[Materials] "+s); + } + } + } + /** + * Special Logger for Debugging Materials related content + */ + public static void DEBUG_MATERIALS(final String s) { + if (enabled) { + if (CORE_Preloader.DEV_ENVIRONMENT || CORE_Preloader.DEBUG_MODE) { + modLogger.info("[Debug][Materials] "+s); + } + } + } + + /** + * Special Logger for Reflection related content + */ + public static void REFLECTION(final String s) { + if (enabled) { + if (CORE_Preloader.DEV_ENVIRONMENT || CORE_Preloader.DEBUG_MODE) { + modLogger.info("[Reflection] "+s); + } + } + } + + + /** + * Special Logger for Darkworld related content + */ + public static void WORLD(final String s) { + if (enabled) { + if (CORE_Preloader.DEV_ENVIRONMENT || CORE_Preloader.DEBUG_MODE) { + modLogger.info("[WorldGen] "+s); + } + } + } + + public static void RECIPE(String string) { + if (enabled) { + if (/*CORE_Preloader.DEV_ENVIRONMENT || */CORE_Preloader.DEBUG_MODE) { + modLogger.info("[Recipe] "+string); + } + } + } + + public static void SPACE(final String s) { + if (enabled) { + modLogger.info("[Space] "+s); + } + } + + + +} diff --git a/src/main/java/gtPlusPlus/api/objects/data/AutoMap.java b/src/main/java/gtPlusPlus/api/objects/data/AutoMap.java new file mode 100644 index 0000000000..e04f1af03a --- /dev/null +++ b/src/main/java/gtPlusPlus/api/objects/data/AutoMap.java @@ -0,0 +1,345 @@ +package gtPlusPlus.api.objects.data; + +import java.io.Serializable; +import java.util.*; + +public class AutoMap implements Iterable, Cloneable, Serializable, Collection, Queue, List { + + /** + * The Internal Map + */ + protected final Map mInternalMap; + protected final Map mInternalNameMap; + + /** + * The Internal ID + */ + private int mInternalID = 0; + private static final long serialVersionUID = 3771412318075131790L; + + + public AutoMap() { + this(new LinkedHashMap()); + } + + public Map getMap(){ + return mInternalMap; + } + + public AutoMap(Map defaultMapType) { + mInternalMap = defaultMapType; + mInternalNameMap = new LinkedHashMap(); + } + + /** + * Generates an AutoMap from the List. + * @param aList - Data to be inserted into the AutoMap. + */ + public AutoMap(List aList) { + mInternalMap = new LinkedHashMap(); + mInternalNameMap = new LinkedHashMap(); + if (aList != null && aList.size() > 0) { + for (V obj : aList) { + add(obj); + } + } + } + /** + * Generates an AutoMap from a Set. + * @param aList - Data to be inserted into the AutoMap. + */ + public AutoMap(Set aList) { + mInternalMap = new LinkedHashMap(); + mInternalNameMap = new LinkedHashMap(); + if (aList != null && aList.size() > 0) { + for (V obj : aList) { + add(obj); + } + } + } + /** + * Generates an AutoMap from a Collection. + * @param aList - Data to be inserted into the AutoMap. + */ + public AutoMap(Collection aList) { + mInternalMap = new LinkedHashMap(); + mInternalNameMap = new LinkedHashMap(); + if (aList != null && aList.size() > 0) { + for (V obj : aList) { + add(obj); + } + } + } + + /** + * Generates an AutoMap from a Array. + * @param aArray - Data to be inserted into the AutoMap. + */ + public AutoMap(V[] aArray) { + mInternalMap = new LinkedHashMap(); + mInternalNameMap = new LinkedHashMap(); + if (aArray != null && aArray.length > 0) { + for (V obj : aArray) { + add(obj); + } + } + } + + @Override + public Iterator iterator() { + return values().iterator(); + } + + public synchronized boolean setValue(V object){ + int mOriginalID = this.mInternalID; + put(object); + if (this.mInternalMap.get(mOriginalID).equals(object) || mOriginalID > this.mInternalID){ + return true; + } + else { + return false; + } + } + + public synchronized V put(V object){ + return set(object); + } + + public synchronized boolean add(V object){ + return set(object) != null; + } + + public synchronized V set(V object){ + if (object == null) { + return null; + } + mInternalNameMap.put(""+object.hashCode(), (mInternalID+1)); + return mInternalMap.put(mInternalID++, object); + } + + public synchronized V get(int id){ + return mInternalMap.get(id); + } + + public synchronized Collection values(){ + return mInternalMap.values(); + } + + public synchronized int size(){ + return mInternalMap.size(); + } + + public synchronized int hashCode(){ + return mInternalMap.hashCode(); + } + + public synchronized boolean containsKey(int key){ + return mInternalMap.containsKey(key); + } + + public synchronized boolean containsValue(V value){ + return mInternalMap.containsValue(value); + } + + public synchronized boolean isEmpty(){ + return mInternalMap.isEmpty(); + } + + public synchronized void clear(){ + this.mInternalID = 0; + this.mInternalMap.clear(); + this.mInternalNameMap.clear(); + return; + } + + @SuppressWarnings("unchecked") + public V[] toArray() { + V[] toR = (V[]) java.lang.reflect.Array.newInstance(mInternalMap.get(0).getClass(), mInternalMap.size()); + for (int i = 0; i < mInternalMap.size(); i++) { + toR[i] = mInternalMap.get(i); + } + return toR; + } + + public synchronized final int getInternalID() { + return mInternalID; + } + + public synchronized final boolean remove(Object value) { + value.getClass(); + if (this.mInternalMap.containsValue(value)) { + return this.mInternalMap.remove(mInternalNameMap.get(""+value.hashCode()), value); + } + return false; + } + + @Override + public boolean contains(Object o) { + for (V g : this.mInternalMap.values()) { + if (g.equals(o)) { + return true; + } + } + return false; + } + + @SuppressWarnings("unchecked") + @Override + public V[] toArray(V[] a) { + return (V[]) toArray(); + } + + @Override + public boolean containsAll(Collection c) { + boolean aTrue = true; + for (Object g : c) { + if (!this.contains(g)) { + aTrue = false; + } + } + return aTrue; + } + + @Override + public boolean addAll(Collection c) { + boolean aTrue = true; + for (V g : c) { + if (!this.add(g)) { + aTrue = false; + } + } + return aTrue; + } + + @Override + public boolean removeAll(Collection c) { + boolean aTrue = true; + for (Object g : c) { + if (!this.remove(g)) { + aTrue = false; + } + } + return aTrue; + } + + @Override + public boolean retainAll(Collection c) { + AutoMap aTempAllocation = new AutoMap(); + boolean aTrue = false; + aTempAllocation = this; + aTempAllocation.removeAll(c); + aTempAllocation.clear(); + aTrue = aTempAllocation.isEmpty(); + aTempAllocation.clear(); + return aTrue; + } + + @Override + public boolean offer(V e) { + return add(e); + } + + @Override + public V remove() { + V y = this.get(0); + if (remove(y)) + return y; + else + return null; + } + + @Override + public V poll() { + if (this.mInternalMap.isEmpty()) { + return null; + } + return remove(); + } + + @Override + public V element() { + if (this.mInternalMap.isEmpty()) { + return null; + } + return this.get(0); + } + + @Override + public V peek() { + return element(); + } + + @Override + public boolean addAll(int index, Collection c) { + for (V y : c) { + add(y); + } + return true; + } + + @Override + public V set(int index, V element) { + return mInternalMap.put(index, element); + } + + @Override + public void add(int index, V element) { + add(element); + } + + @Override + public V remove(int index) { + V h = mInternalMap.get(index); + set(index, null); + return h; + } + + @Override + public int indexOf(Object o) { + int aCount = 0; + for (V of : mInternalMap.values()) { + if (of != o) { + aCount++; + continue; + } + else { + return aCount; + } + } + return -1; + } + + @Override + public int lastIndexOf(Object o) { + //TODO + return indexOf(o); + } + + @Override + public ListIterator listIterator() { + // TODO Auto-generated method stub + return null; + } + + @Override + public ListIterator listIterator(int index) { + // TODO Auto-generated method stub + return null; + } + + @Override + public List subList(int fromIndex, int toIndex) { + AutoMap aNewSubList = new AutoMap(); + for (int slot=fromIndex; slot<=toIndex; slot++) { + V obj = mInternalMap.get(slot); + if (obj == null) { + continue; + } + else { + aNewSubList.put(obj); + } + } + return aNewSubList; + } + +} diff --git a/src/main/java/gtPlusPlus/api/objects/data/ConcurrentHashSet.java b/src/main/java/gtPlusPlus/api/objects/data/ConcurrentHashSet.java new file mode 100644 index 0000000000..991908e402 --- /dev/null +++ b/src/main/java/gtPlusPlus/api/objects/data/ConcurrentHashSet.java @@ -0,0 +1,18 @@ +package gtPlusPlus.api.objects.data; + +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.ConcurrentMap; + +public class ConcurrentHashSet extends ConcurrentSet { + + private static final long serialVersionUID = -1293478938482781728L; + + public ConcurrentHashSet() { + this(new ConcurrentHashMap()); + } + + public ConcurrentHashSet(ConcurrentMap defaultMapType) { + super(defaultMapType); + } + +} diff --git a/src/main/java/gtPlusPlus/api/objects/data/ConcurrentSet.java b/src/main/java/gtPlusPlus/api/objects/data/ConcurrentSet.java new file mode 100644 index 0000000000..1d3ffc1c01 --- /dev/null +++ b/src/main/java/gtPlusPlus/api/objects/data/ConcurrentSet.java @@ -0,0 +1,53 @@ +package gtPlusPlus.api.objects.data; + +import java.io.Serializable; +import java.util.AbstractSet; +import java.util.Iterator; +import java.util.concurrent.ConcurrentMap; + +public abstract class ConcurrentSet extends AbstractSet implements Serializable { + + private static final long serialVersionUID = -6761513279741915432L; + + private final ConcurrentMap mInternalMap; + + private int mInternalID = 0; + + /** + * Creates a new instance which wraps the specified {@code map}. + */ + public ConcurrentSet(ConcurrentMap aMap) { + mInternalMap = aMap; + } + + @Override + public int size() { + return mInternalMap.size(); + } + + @Override + public boolean contains(Object o) { + return mInternalMap.containsKey(o); + } + + @Override + public boolean add(E o) { + return mInternalMap.putIfAbsent(mInternalID++, o) == null; + } + + @Override + public boolean remove(Object o) { + return mInternalMap.remove(o) != null; + } + + @Override + public void clear() { + this.mInternalID = 0; + mInternalMap.clear(); + } + + @Override + public Iterator iterator() { + return mInternalMap.values().iterator(); + } +} diff --git a/src/main/java/gtPlusPlus/api/objects/data/FlexiblePair.java b/src/main/java/gtPlusPlus/api/objects/data/FlexiblePair.java new file mode 100644 index 0000000000..64f57b4e5a --- /dev/null +++ b/src/main/java/gtPlusPlus/api/objects/data/FlexiblePair.java @@ -0,0 +1,39 @@ +package gtPlusPlus.api.objects.data; + +import java.io.Serializable; + +import com.google.common.base.Objects; + +public class FlexiblePair implements Serializable { + + /** + * SVUID + */ + private static final long serialVersionUID = 1250550491092812443L; + private final K key; + private V value; + + public FlexiblePair(final K key, final V value){ + this.key = key; + this.value = value; + } + + final public K getKey(){ + return this.key; + } + + final public V getValue(){ + return this.value; + } + + final public void setValue(V aObj) { + value = aObj; + } + + @Override + public int hashCode() { + Integer aCode = Objects.hashCode(getKey(), getValue()); + return aCode != null ? aCode : super.hashCode(); + } + +} \ No newline at end of file diff --git a/src/main/java/gtPlusPlus/api/objects/data/ObjMap.java b/src/main/java/gtPlusPlus/api/objects/data/ObjMap.java new file mode 100644 index 0000000000..49dd70d2b8 --- /dev/null +++ b/src/main/java/gtPlusPlus/api/objects/data/ObjMap.java @@ -0,0 +1,285 @@ +package gtPlusPlus.api.objects.data; + +import java.util.Arrays; + +/** + * Object-2-object map based on IntIntMap4a + */ +public class ObjMap +{ + private static final Object FREE_KEY = new Object(); + private static final Object REMOVED_KEY = new Object(); + + /** Keys and values */ + private Object[] m_data; + + /** Value for the null key (if inserted into a map) */ + private Object m_nullValue; + private boolean m_hasNull; + + /** Fill factor, must be between (0 and 1) */ + private final float m_fillFactor; + /** We will resize a map once it reaches this size */ + private int m_threshold; + /** Current map size */ + private int m_size; + /** Mask to calculate the original position */ + private int m_mask; + /** Mask to wrap the actual array pointer */ + private int m_mask2; + + public ObjMap( final int size, final float fillFactor ) + { + if ( fillFactor <= 0 || fillFactor >= 1 ) + throw new IllegalArgumentException( "FillFactor must be in (0, 1)" ); + if ( size <= 0 ) + throw new IllegalArgumentException( "Size must be positive!" ); + final int capacity = arraySize(size, fillFactor); + m_mask = capacity - 1; + m_mask2 = capacity * 2 - 1; + m_fillFactor = fillFactor; + + m_data = new Object[capacity * 2]; + Arrays.fill( m_data, FREE_KEY ); + + m_threshold = (int) (capacity * fillFactor); + } + + @SuppressWarnings("unchecked") + public V get( final K key ) + { + if ( key == null ) + return (V) m_nullValue; //we null it on remove, so safe not to check a flag here + + int ptr = (key.hashCode() & m_mask) << 1; + Object k = m_data[ ptr ]; + + if ( k == FREE_KEY ) + return null; //end of chain already + if ( k.equals( key ) ) //we check FREE and REMOVED prior to this call + return (V) m_data[ ptr + 1 ]; + while ( true ) + { + ptr = (ptr + 2) & m_mask2; //that's next index + k = m_data[ ptr ]; + if ( k == FREE_KEY ) + return null; + if ( k.equals( key ) ) + return (V) m_data[ ptr + 1 ]; + } + } + + @SuppressWarnings("unchecked") + public V put( final K key, final V value ) + { + if ( key == null ) + return insertNullKey(value); + + int ptr = getStartIndex(key) << 1; + Object k = m_data[ptr]; + + if ( k == FREE_KEY ) //end of chain already + { + m_data[ ptr ] = key; + m_data[ ptr + 1 ] = value; + if ( m_size >= m_threshold ) + rehash( m_data.length * 2 ); //size is set inside + else + ++m_size; + return null; + } + else if ( k.equals( key ) ) //we check FREE and REMOVED prior to this call + { + final Object ret = m_data[ ptr + 1 ]; + m_data[ ptr + 1 ] = value; + return (V) ret; + } + + int firstRemoved = -1; + if ( k == REMOVED_KEY ) + firstRemoved = ptr; //we may find a key later + + while ( true ) + { + ptr = ( ptr + 2 ) & m_mask2; //that's next index calculation + k = m_data[ ptr ]; + if ( k == FREE_KEY ) + { + if ( firstRemoved != -1 ) + ptr = firstRemoved; + m_data[ ptr ] = key; + m_data[ ptr + 1 ] = value; + if ( m_size >= m_threshold ) + rehash( m_data.length * 2 ); //size is set inside + else + ++m_size; + return null; + } + else if ( k.equals( key ) ) + { + final Object ret = m_data[ ptr + 1 ]; + m_data[ ptr + 1 ] = value; + return (V) ret; + } + else if ( k == REMOVED_KEY ) + { + if ( firstRemoved == -1 ) + firstRemoved = ptr; + } + } + } + + @SuppressWarnings("unchecked") + public V remove( final K key ) + { + if ( key == null ) + return removeNullKey(); + + int ptr = getStartIndex(key) << 1; + Object k = m_data[ ptr ]; + if ( k == FREE_KEY ) + return null; //end of chain already + else if ( k.equals( key ) ) //we check FREE and REMOVED prior to this call + { + --m_size; + if ( m_data[ ( ptr + 2 ) & m_mask2 ] == FREE_KEY ) + m_data[ ptr ] = FREE_KEY; + else + m_data[ ptr ] = REMOVED_KEY; + final V ret = (V) m_data[ ptr + 1 ]; + m_data[ ptr + 1 ] = null; + return ret; + } + while ( true ) + { + ptr = ( ptr + 2 ) & m_mask2; //that's next index calculation + k = m_data[ ptr ]; + if ( k == FREE_KEY ) + return null; + else if ( k.equals( key ) ) + { + --m_size; + if ( m_data[ ( ptr + 2 ) & m_mask2 ] == FREE_KEY ) + m_data[ ptr ] = FREE_KEY; + else + m_data[ ptr ] = REMOVED_KEY; + final V ret = (V) m_data[ ptr + 1 ]; + m_data[ ptr + 1 ] = null; + return ret; + } + } + } + + @SuppressWarnings("unchecked") + private V insertNullKey(final V value) + { + if ( m_hasNull ) + { + final Object ret = m_nullValue; + m_nullValue = value; + return (V) ret; + } + else + { + m_nullValue = value; + ++m_size; + return null; + } + } + + @SuppressWarnings("unchecked") + private V removeNullKey() + { + if ( m_hasNull ) + { + final Object ret = m_nullValue; + m_nullValue = null; + m_hasNull = false; + --m_size; + return (V) ret; + } + else + { + return null; + } + } + + public int size() + { + return m_size; + } + + @SuppressWarnings("unchecked") + private void rehash( final int newCapacity ) + { + m_threshold = (int) (newCapacity/2 * m_fillFactor); + m_mask = newCapacity/2 - 1; + m_mask2 = newCapacity - 1; + + final int oldCapacity = m_data.length; + final Object[] oldData = m_data; + + m_data = new Object[ newCapacity ]; + Arrays.fill( m_data, FREE_KEY ); + + m_size = m_hasNull ? 1 : 0; + + for ( int i = 0; i < oldCapacity; i += 2 ) { + final Object oldKey = oldData[ i ]; + if( oldKey != FREE_KEY && oldKey != REMOVED_KEY ) + put( (K)oldKey, (V)oldData[ i + 1 ]); + } + } + + public int getStartIndex( final Object key ) + { + //key is not null here + return key.hashCode() & m_mask; + } + + public Object[] values() { + return m_data; + } + + /** Taken from FastUtil implementation */ + + /** Return the least power of two greater than or equal to the specified value. + * + *

Note that this function will return 1 when the argument is 0. + * + * @param x a long integer small