From e630cc3f27fb39110b5b1d91f5a55d92266382ca Mon Sep 17 00:00:00 2001 From: kindlich Date: Sun, 8 Dec 2019 18:28:51 +0100 Subject: [PATCH] Added forgotten 1.11 folder --- .gitignore | 12 + MineTweaker3-MC1112-Main/build.gradle | 90 +++ .../java/com/blamejared/ctgui/MTRecipe.java | 37 ++ .../com/blamejared/ctgui/api/CheckButton.java | 95 ++++ .../ctgui/api/CheckButtonRecipe.java | 102 ++++ .../blamejared/ctgui/api/ContainerBase.java | 98 ++++ .../com/blamejared/ctgui/api/GuiBase.java | 313 +++++++++++ .../com/blamejared/ctgui/api/GuiRegistry.java | 30 + .../java/com/blamejared/ctgui/api/Slider.java | 26 + .../com/blamejared/ctgui/api/SlotRecipe.java | 113 ++++ .../ctgui/api/SlotRecipeOutput.java | 13 + .../blamejared/ctgui/client/GuiHandler.java | 33 ++ .../ctgui/client/GuiHandlerVanilla.java | 35 ++ .../ctgui/client/InventoryFake.java | 126 +++++ .../blamejared/ctgui/client/gui/GuiMenu.java | 210 +++++++ .../craftingtable/ContainerCraftingTable.java | 36 ++ .../gui/craftingtable/GuiCraftingTable.java | 93 ++++ .../client/gui/furnace/ContainerFurnace.java | 36 ++ .../ctgui/client/gui/furnace/GuiFurnace.java | 48 ++ .../ctgui/commands/CommandCTGUI.java | 43 ++ .../blamejared/ctgui/proxy/ClientProxy.java | 18 + .../blamejared/ctgui/proxy/CommonProxy.java | 17 + .../blamejared/ctgui/reference/Reference.java | 9 + .../api/minecraft/MineTweakerMC.java | 511 ++++++++++++++++++ .../minetweaker/mc1112/FMLEventHandler.java | 74 +++ .../minetweaker/mc1112/ForgeEventHandler.java | 94 ++++ .../minetweaker/mc1112/GuiCannotRemodify.java | 46 ++ .../mc1112/MCPlatformFunctions.java | 43 ++ .../minetweaker/mc1112/MineTweakerMod.java | 195 +++++++ .../mc1112/MineTweakerRegistry.java | 13 + .../actions/SetBlockHardnessAction.java | 79 +++ .../mc1112/actions/SetStackSizeAction.java | 55 ++ .../actions/SetStackmaxDamageAction.java | 55 ++ .../mc1112/actions/SetTranslationAction.java | 70 +++ .../mc1112/block/MCBlockDefinition.java | 30 + .../minetweaker/mc1112/block/MCItemBlock.java | 63 +++ .../mc1112/block/MCSpecificBlock.java | 67 +++ .../mc1112/block/MCWorldBlock.java | 82 +++ .../mc1112/brackets/EntityBracketHandler.java | 77 +++ .../mc1112/brackets/ItemBracketHandler.java | 138 +++++ .../mc1112/brackets/LiquidBracketHandler.java | 87 +++ .../mc1112/brackets/OreBracketHandler.java | 81 +++ .../mc1112/brewing/MCBrewingManager.java | 73 +++ .../mc1112/chat/MCChatMessage.java | 30 + .../minetweaker/mc1112/client/MCClient.java | 23 + .../minetweaker/mc1112/data/NBTConverter.java | 138 +++++ .../minetweaker/mc1112/data/NBTUpdater.java | 39 ++ .../mc1112/entity/MCEntityDefinition.java | 67 +++ .../formatting/FormattedMarkupString.java | 38 ++ .../mc1112/formatting/FormattedString.java | 35 ++ .../formatting/FormattedStringJoin.java | 62 +++ .../mc1112/formatting/IMCFormattedString.java | 13 + .../mc1112/formatting/MCFormatter.java | 120 ++++ .../mc1112/furnace/FuelTweaker.java | 89 +++ .../mc1112/furnace/MCFurnaceManager.java | 227 ++++++++ .../mc1112/furnace/SetFuelPattern.java | 22 + .../java/minetweaker/mc1112/game/MCGame.java | 212 ++++++++ .../mc1112/item/MCItemDefinition.java | 79 +++ .../minetweaker/mc1112/item/MCItemStack.java | 405 ++++++++++++++ .../mc1112/liquid/MCLiquidDefinition.java | 416 ++++++++++++++ .../mc1112/liquid/MCLiquidStack.java | 188 +++++++ .../minetweaker/mc1112/logger/MCLogger.java | 80 +++ .../minetweaker/mc1112/mods/MCLoadedMods.java | 43 ++ .../java/minetweaker/mc1112/mods/MCMod.java | 36 ++ .../MineTweakerCopyClipboardHandler.java | 27 + .../MineTweakerCopyClipboardPacket.java | 37 ++ .../MineTweakerLoadScriptsHandler.java | 28 + .../network/MineTweakerLoadScriptsPacket.java | 37 ++ .../MineTweakerOpenBrowserHandler.java | 32 ++ .../network/MineTweakerOpenBrowserPacket.java | 39 ++ .../minetweaker/mc1112/oredict/MCOreDict.java | 31 ++ .../mc1112/oredict/MCOreDictEntry.java | 464 ++++++++++++++++ .../mc1112/player/CommandBlockPlayer.java | 135 +++++ .../minetweaker/mc1112/player/MCPlayer.java | 147 +++++ .../minetweaker/mc1112/player/RconPlayer.java | 135 +++++ .../mc1112/recipes/MCCraftingInventory.java | 179 ++++++ .../mc1112/recipes/MCRecipeManager.java | 439 +++++++++++++++ .../mc1112/recipes/RecipeConverter.java | 169 ++++++ .../mc1112/recipes/ShapedRecipeAdvanced.java | 54 ++ .../mc1112/recipes/ShapedRecipeBasic.java | 44 ++ .../mc1112/recipes/ShapedRecipeOre.java | 43 ++ .../recipes/ShapelessRecipeAdvanced.java | 52 ++ .../mc1112/recipes/ShapelessRecipeBasic.java | 43 ++ .../mc1112/recipes/ShapelessRecipeOre.java | 38 ++ .../minetweaker/mc1112/server/MCServer.java | 186 +++++++ .../mc1112/server/ServerPlayer.java | 132 +++++ .../mc1112/util/MineTweakerHacks.java | 238 ++++++++ .../mc1112/util/MineTweakerObfuscation.java | 19 + .../mc1112/util/MineTweakerPlatformUtils.java | 40 ++ .../mc1112/vanilla/MCLootRegistry.java | 193 +++++++ .../mc1112/vanilla/MCSeedRegistry.java | 134 +++++ .../minetweaker/mc1112/vanilla/MCVanilla.java | 22 + .../minetweaker/mc1112/world/MCBiome.java | 21 + .../minetweaker/mc1112/world/MCDimension.java | 39 ++ .../resources/assets/minetweaker/logo.png | Bin 0 -> 21583 bytes .../src/main/resources/mcmod.info | 18 + MineTweaker3-MC1112-Mod-JEI/build.gradle | 45 ++ .../libs/jei_1.11.2-4.5.0-CrT-debug.jar | Bin 0 -> 538952 bytes .../main/java/minetweaker/mods/jei/JEI.java | 106 ++++ .../minetweaker/mods/jei/JEIAddonPlugin.java | 56 ++ .../java/minetweaker/mods/jei/JEIMod.java | 19 + .../mods/jei/JEIRecipeRegistry.java | 130 +++++ .../mods/jei/network/MessageJEIHide.java | 51 ++ .../mods/jei/network/PacketHandler.java | 15 + 104 files changed, 9565 insertions(+) create mode 100644 MineTweaker3-MC1112-Main/build.gradle create mode 100644 MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/MTRecipe.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/api/CheckButton.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/api/CheckButtonRecipe.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/api/ContainerBase.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/api/GuiBase.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/api/GuiRegistry.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/api/Slider.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/api/SlotRecipe.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/api/SlotRecipeOutput.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/client/GuiHandler.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/client/GuiHandlerVanilla.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/client/InventoryFake.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/client/gui/GuiMenu.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/client/gui/craftingtable/ContainerCraftingTable.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/client/gui/craftingtable/GuiCraftingTable.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/client/gui/furnace/ContainerFurnace.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/client/gui/furnace/GuiFurnace.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/commands/CommandCTGUI.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/proxy/ClientProxy.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/proxy/CommonProxy.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/reference/Reference.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/minetweaker/api/minecraft/MineTweakerMC.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/FMLEventHandler.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/ForgeEventHandler.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/GuiCannotRemodify.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/MCPlatformFunctions.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/MineTweakerMod.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/MineTweakerRegistry.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/actions/SetBlockHardnessAction.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/actions/SetStackSizeAction.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/actions/SetStackmaxDamageAction.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/actions/SetTranslationAction.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/block/MCBlockDefinition.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/block/MCItemBlock.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/block/MCSpecificBlock.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/block/MCWorldBlock.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/brackets/EntityBracketHandler.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/brackets/ItemBracketHandler.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/brackets/LiquidBracketHandler.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/brackets/OreBracketHandler.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/brewing/MCBrewingManager.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/chat/MCChatMessage.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/client/MCClient.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/data/NBTConverter.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/data/NBTUpdater.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/entity/MCEntityDefinition.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/formatting/FormattedMarkupString.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/formatting/FormattedString.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/formatting/FormattedStringJoin.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/formatting/IMCFormattedString.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/formatting/MCFormatter.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/furnace/FuelTweaker.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/furnace/MCFurnaceManager.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/furnace/SetFuelPattern.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/game/MCGame.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/item/MCItemDefinition.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/item/MCItemStack.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/liquid/MCLiquidDefinition.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/liquid/MCLiquidStack.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/logger/MCLogger.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/mods/MCLoadedMods.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/mods/MCMod.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/network/MineTweakerCopyClipboardHandler.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/network/MineTweakerCopyClipboardPacket.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/network/MineTweakerLoadScriptsHandler.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/network/MineTweakerLoadScriptsPacket.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/network/MineTweakerOpenBrowserHandler.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/network/MineTweakerOpenBrowserPacket.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/oredict/MCOreDict.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/oredict/MCOreDictEntry.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/player/CommandBlockPlayer.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/player/MCPlayer.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/player/RconPlayer.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/recipes/MCCraftingInventory.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/recipes/MCRecipeManager.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/recipes/RecipeConverter.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/recipes/ShapedRecipeAdvanced.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/recipes/ShapedRecipeBasic.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/recipes/ShapedRecipeOre.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/recipes/ShapelessRecipeAdvanced.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/recipes/ShapelessRecipeBasic.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/recipes/ShapelessRecipeOre.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/server/MCServer.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/server/ServerPlayer.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/util/MineTweakerHacks.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/util/MineTweakerObfuscation.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/util/MineTweakerPlatformUtils.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/vanilla/MCLootRegistry.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/vanilla/MCSeedRegistry.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/vanilla/MCVanilla.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/world/MCBiome.java create mode 100644 MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/world/MCDimension.java create mode 100644 MineTweaker3-MC1112-Main/src/main/resources/assets/minetweaker/logo.png create mode 100644 MineTweaker3-MC1112-Main/src/main/resources/mcmod.info create mode 100644 MineTweaker3-MC1112-Mod-JEI/build.gradle create mode 100644 MineTweaker3-MC1112-Mod-JEI/libs/jei_1.11.2-4.5.0-CrT-debug.jar create mode 100644 MineTweaker3-MC1112-Mod-JEI/src/main/java/minetweaker/mods/jei/JEI.java create mode 100644 MineTweaker3-MC1112-Mod-JEI/src/main/java/minetweaker/mods/jei/JEIAddonPlugin.java create mode 100644 MineTweaker3-MC1112-Mod-JEI/src/main/java/minetweaker/mods/jei/JEIMod.java create mode 100644 MineTweaker3-MC1112-Mod-JEI/src/main/java/minetweaker/mods/jei/JEIRecipeRegistry.java create mode 100644 MineTweaker3-MC1112-Mod-JEI/src/main/java/minetweaker/mods/jei/network/MessageJEIHide.java create mode 100644 MineTweaker3-MC1112-Mod-JEI/src/main/java/minetweaker/mods/jei/network/PacketHandler.java diff --git a/.gitignore b/.gitignore index cbec0aa..a907b14 100644 --- a/.gitignore +++ b/.gitignore @@ -12,6 +12,18 @@ /MineTweaker3-API/* !/MineTweaker3-API/src +!/MineTweaker3-MC1112-Main +/MineTweaker3-MC1112-Main/* +!/MineTweaker3-MC1112-Main/src +!/MineTweaker3-MC1112-Main/build.gradle +/MineTweaker3-MC1112-Main/bin + +!/MineTweaker3-MC1112-Mod-JEI +/MineTweaker3-MC1112-Mod-JEI/* +!/MineTweaker3-MC1112-Mod-JEI/src +!/MineTweaker3-MC1112-Mod-JEI/libs +!/MineTweaker3-MC1112-Mod-JEI/build.gradle + !/MineTweaker3-MC1102-Main /MineTweaker3-MC1102-Main/* !/MineTweaker3-MC1102-Main/src diff --git a/MineTweaker3-MC1112-Main/build.gradle b/MineTweaker3-MC1112-Main/build.gradle new file mode 100644 index 0000000..cb486b1 --- /dev/null +++ b/MineTweaker3-MC1112-Main/build.gradle @@ -0,0 +1,90 @@ +import minetweaker.tasks.RegisterZenClassesTask; + +buildscript { + repositories { + jcenter() + maven { url = "http://files.minecraftforge.net/maven" } + } + dependencies { + classpath 'net.minecraftforge.gradle:ForgeGradle:2.2-SNAPSHOT' + } +} +apply plugin: 'net.minecraftforge.gradle.forge' +apply plugin: 'maven' + +sourceCompatibility = JavaVersion.VERSION_1_8 +targetCompatibility = JavaVersion.VERSION_1_8 + +version = "1.11.2-" + ext.mineTweakerVersion +archivesBaseName = project.projectDir.name + +minecraft { + version = forgeVersion1112 + runDir = "eclipse" + mappings = "snapshot_20161220" +} + +dependencies { + compile project(':ZenScript') + compile project(':MineTweaker3-API') +} + +task makeRegistry(type: RegisterZenClassesTask) { + inputDir = file('build/classes/main') + outputDir = file('build/classes/main') + className = 'minetweaker.mc1112.MineTweakerRegistry' +} + +tasks.jar.dependsOn(makeRegistry) + +processResources + { + + inputs.property "version", project.version + inputs.property "mcversion", project.minecraft.version + + from(sourceSets.main.resources.srcDirs) { + include 'mcmod.info' + + expand 'version': project.version, 'mcversion': project.minecraft.version + } + + from(sourceSets.main.resources.srcDirs) { + exclude 'mcmod.info' + } + } + +uploadArchives { + repositories { + mavenDeployer { + repository(url: "file://" + System.getenv("local_maven")) + pom { + groupId = project.group + version + artifactId = project.archivesBaseName + project { + name project.archivesBaseName + packaging 'jar' + description 'CraftTweaker' + url 'https://github.com/jaredlll08/CraftTweaker' + scm { + url 'https://github.com/jaredlll08/CraftTweaker.git' + connection 'scm:git:git@github.com:jaredlll08/CraftTweaker.git' + developerConnection 'scm:git:git@github.com:jaredlll08/CraftTweaker.git' + } + issueManagement { + system 'github' + url 'https://github.com/jaredlll08/CraftTweaker/issues' + } + developers { + developer { + id 'Jared' + name 'Jared' + roles { role 'developer' } + } + } + } + } + } + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/MTRecipe.java b/MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/MTRecipe.java new file mode 100644 index 0000000..d2b5cdc --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/MTRecipe.java @@ -0,0 +1,37 @@ +package com.blamejared.ctgui; + +import com.blamejared.ctgui.api.GuiRegistry; +import com.blamejared.ctgui.client.GuiHandlerVanilla; +import com.blamejared.ctgui.commands.CommandCTGUI; +import com.blamejared.ctgui.proxy.CommonProxy; +import net.minecraftforge.fml.common.*; +import net.minecraftforge.fml.common.event.*; + +import java.util.*; + +import static com.blamejared.ctgui.reference.Reference.*; + +@Mod(modid = MOD_ID, name = MOD_NAME, version = VERSION, clientSideOnly = true, dependencies = "required-after:crafttweaker;") +public class MTRecipe { + + @Mod.Instance(MOD_ID) + public static MTRecipe INSTANCE; + + @SidedProxy(clientSide = "com.blamejared.ctgui.proxy.ClientProxy", serverSide = "com.blamejared.ctgui.proxy.CommonProxy") + public static CommonProxy PROXY; + + @Mod.EventHandler + public void preInit(FMLPreInitializationEvent event) { + List idrange = new ArrayList<>(); + idrange.add(1); + idrange.add(2); + GuiRegistry.registerGui(idrange, new GuiHandlerVanilla()); + PROXY.registerGuis(); + } + + @Mod.EventHandler + public void serverStarting(FMLServerStartingEvent e) { + e.registerServerCommand(new CommandCTGUI()); + } + +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/api/CheckButton.java b/MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/api/CheckButton.java new file mode 100644 index 0000000..466e492 --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/api/CheckButton.java @@ -0,0 +1,95 @@ +package com.blamejared.ctgui.api; + +import net.minecraft.client.Minecraft; +import net.minecraft.client.gui.GuiButton; +import net.minecraft.client.renderer.GlStateManager; +import net.minecraftforge.fml.client.config.*; +import org.lwjgl.opengl.GL11; + +import java.awt.*; +import java.util.List; + +public class CheckButton extends GuiCheckBox { + + protected GuiBase parent; + protected List incompatible; + + protected int backgroundSize = 100; + + public CheckButton(GuiBase parent, int id, int xPos, int yPos, String displayString, boolean isChecked) { + super(id, xPos, yPos, displayString, isChecked); + this.parent = parent; + } + + + public int getBackgroundSize() { + return backgroundSize; + } + + public void setBackgroundSize(int backgroundSize) { + this.backgroundSize = backgroundSize; + } + + public List getIncompatible() { + return incompatible; + } + + public void setIncompatible(List incompatible) { + this.incompatible = incompatible; + } + + /** + * Draws this button to the screen. + */ + public void drawButton(Minecraft mc, int mouseX, int mouseY) { + if(this.visible) { + this.hovered = mouseX >= this.xPosition && mouseY >= this.yPosition && mouseX < this.xPosition + getButtonWidth() && mouseY < this.yPosition + this.height; + GlStateManager.enableAlpha(); + GL11.glColor4d(1, 1, 1, 0); + GuiUtils.drawGradientRect(30, this.xPosition - 2, this.yPosition - 2, this.xPosition + getBackgroundSize(), this.yPosition + height + 2, 0x9F100010, 0x9F100010); + GlStateManager.disableAlpha(); + GuiUtils.drawContinuousTexturedBox(BUTTON_TEXTURES, this.xPosition, this.yPosition, 0, 46, 11, this.height, 200, 20, 2, 3, 2, 2, this.zLevel); + this.mouseDragged(mc, mouseX, mouseY); + int color = 14737632; + + if(packedFGColour != 0) { + color = packedFGColour; + } else if(!this.enabled) { + color = 10526880; + } + + if(this.isChecked()) { + this.drawGradientRect(this.xPosition + 2, this.yPosition + 2, this.xPosition + 11 - 2, this.yPosition + height - 2, Color.cyan.darker().getRGB(), Color.cyan.darker().getRGB()); + } + + this.drawString(mc.fontRendererObj, displayString, xPosition + 11 + 2, yPosition + 2, color); + } + } + + @Override + public boolean mousePressed(Minecraft mc, int mouseX, int mouseY) { + if(this.enabled && this.visible && mouseX >= this.xPosition && mouseY >= this.yPosition && mouseX < this.xPosition + this.width && mouseY < this.yPosition + this.height) { + setIsChecked(!isChecked()); + return true; + } + return false; + } + + + public void setIsChecked(boolean isChecked) { + super.setIsChecked(isChecked); + if(isChecked()) { + for(GuiButton but : incompatible) { + but.enabled = false; + if(but instanceof CheckButton) { + ((CheckButton) but).setIsChecked(false); + } + } + } else { + for(GuiButton but : incompatible) { + but.enabled = true; + } + } + } + +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/api/CheckButtonRecipe.java b/MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/api/CheckButtonRecipe.java new file mode 100644 index 0000000..ff5a652 --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/api/CheckButtonRecipe.java @@ -0,0 +1,102 @@ +package com.blamejared.ctgui.api; + +import net.minecraft.block.Block; +import net.minecraft.client.Minecraft; +import net.minecraft.client.gui.GuiButton; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.item.ItemStack; +import net.minecraft.util.NonNullList; + +public class CheckButtonRecipe extends CheckButton { + + private String propertyKey; + + public CheckButtonRecipe(GuiBase parent, int id, int xPos, int yPos, String displayString, boolean isChecked, String propertyKey) { + super(parent, id, xPos, yPos, displayString, isChecked); + this.propertyKey = propertyKey; + } + + + @Override + public boolean mousePressed(Minecraft mc, int mouseX, int mouseY) { + if(this.enabled && this.visible && mouseX >= this.xPosition && mouseY >= this.yPosition && mouseX < this.xPosition + this.width && mouseY < this.yPosition + this.height) { + setIsChecked(!isChecked()); + parent.selectedSlot.getPropertyMap().put(getPropertyKey(), isChecked()); + if(isChecked()) { + for(Slider slider : parent.getMenu().getSliders(this)) { + if(GuiBase.isBlock(parent.selectedSlot.getStack())) { + Block b = Block.getBlockFromItem(parent.selectedSlot.getStack().getItem()); + NonNullList list = NonNullList.create(); + b.getSubBlocks(parent.selectedSlot.getStack().getItem(), CreativeTabs.SEARCH, list); + slider.setValue(parent.selectedSlot.getProperty(slider.getPropertyKey())); + slider.maxValue = list.size() - 1; + slider.updateSlider(); + } else { + if(parent.selectedSlot.getStack().getItem().getHasSubtypes()) { + NonNullList list = NonNullList.create(); + parent.selectedSlot.getStack().getItem().getSubItems(parent.selectedSlot.getStack().getItem(), CreativeTabs.SEARCH, list); + slider.setValue(parent.selectedSlot.getProperty(slider.getPropertyKey())); + slider.maxValue = list.size() - 1; + slider.updateSlider(); + } else { + slider.setValue(parent.selectedSlot.getProperty(slider.getPropertyKey())); + slider.maxValue = parent.selectedSlot.getStack().getMaxDamage(); + slider.updateSlider(); + } + } + parent.getButtonList().add(slider); + } + } else { + for(Slider slider : parent.getMenu().getSliders(this)) { + parent.getButtonList().remove(slider); + } + } + return true; + } + return false; + } + + + public void setIsChecked(boolean isChecked) { + super.setIsChecked(isChecked); + if(isChecked()) { + for(Slider slider : parent.getMenu().getSliders(this)) { + if(GuiBase.isBlock(parent.selectedSlot.getStack())) { + Block b = Block.getBlockFromItem(parent.selectedSlot.getStack().getItem()); + NonNullList list = NonNullList.create(); + b.getSubBlocks(parent.selectedSlot.getStack().getItem(), CreativeTabs.SEARCH, list); + slider.setValue(parent.selectedSlot.getProperty(slider.getPropertyKey())); + slider.maxValue = list.size() - 1; + slider.updateSlider(); + } else { + if(parent.selectedSlot.getStack().getItem().getHasSubtypes()) { + NonNullList list = NonNullList.create(); + parent.selectedSlot.getStack().getItem().getSubItems(parent.selectedSlot.getStack().getItem(), CreativeTabs.SEARCH, list); + slider.setValue(parent.selectedSlot.getProperty(slider.getPropertyKey())); + slider.maxValue = list.size() - 1; + slider.updateSlider(); + } else { + slider.setValue(parent.selectedSlot.getProperty(slider.getPropertyKey())); + slider.maxValue = parent.selectedSlot.getStack().getMaxDamage(); + slider.updateSlider(); + } + } + parent.getButtonList().add(slider); + } + for(GuiButton but : incompatible) { + but.enabled = false; + } + } else { + for(Slider slider : parent.getMenu().getSliders(this)) { + parent.getButtonList().remove(slider); + } + for(GuiButton but : incompatible) { + but.enabled = true; + } + } + } + + public String getPropertyKey() { + return propertyKey; + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/api/ContainerBase.java b/MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/api/ContainerBase.java new file mode 100644 index 0000000..80df800 --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/api/ContainerBase.java @@ -0,0 +1,98 @@ +package com.blamejared.ctgui.api; + +import net.minecraft.entity.player.*; +import net.minecraft.inventory.*; +import net.minecraft.item.ItemStack; + +import javax.annotation.Nullable; +import java.util.*; + +public class ContainerBase extends Container { + + protected List recipeSlots = new LinkedList<>(); + + @Override + public boolean canInteractWith(EntityPlayer player) { + return true; + } + + + @Nullable + @Override + public ItemStack slotClick(int i, int mousebtn, ClickType clickTypeIn, EntityPlayer player) { + ItemStack stack = ItemStack.EMPTY; + + if(i >= 0 && getSlot(i) != null && getSlot(i) instanceof SlotRecipe) // Fake slots + { + if(mousebtn == 2) { + getSlot(i).putStack(ItemStack.EMPTY); + } else if(mousebtn == 0) { + InventoryPlayer playerInv = player.inventory; + getSlot(i).onSlotChanged(); + ItemStack stackSlot = getSlot(i).getStack(); + ItemStack stackHeld = playerInv.getItemStack(); + + if(!stackSlot.isEmpty()) + stack = stackSlot.copy(); + + if(!stackHeld.isEmpty()) { + ItemStack newStack = stackHeld.copy(); + if(!(getSlot(i) instanceof SlotRecipeOutput)) + newStack.setCount(1); + ; + getSlot(i).putStack(newStack); + } else + getSlot(i).putStack(ItemStack.EMPTY); + } else if(mousebtn == 1) { + InventoryPlayer playerInv = player.inventory; + getSlot(i).onSlotChanged(); + ItemStack stackSlot = getSlot(i).getStack(); + ItemStack stackHeld = playerInv.getItemStack(); + + if(!stackSlot.isEmpty()) + stack = stackSlot.copy(); + + if(!stackHeld.isEmpty()) { + stackHeld = stackHeld.copy(); + if(!stackSlot.isEmpty() && stackHeld.isItemEqual(stackSlot) && i == 0) { + int max = stackSlot.getMaxStackSize(); + stackSlot.setCount(stackSlot.getCount() + 1); + if(stackSlot.getCount() > max) + stackSlot.setCount(max); + getSlot(i).putStack(stackSlot); + } else { + stackHeld.setCount(1); + getSlot(i).putStack(stackHeld); + } + } else { + if(!stackSlot.isEmpty()) { + stackSlot.setCount(stackSlot.getCount() - 1); + if(stackSlot.getCount() == 0) + getSlot(i).putStack(ItemStack.EMPTY); + } + } + } + } else { + stack = super.slotClick(i, mousebtn, clickTypeIn, player); + } + return stack; + } + + @Nullable + @Override + public ItemStack transferStackInSlot(EntityPlayer playerIn, int index) { + return ItemStack.EMPTY; + } + + public List getRecipeSlots() { + return recipeSlots; + } + + @Override + protected Slot addSlotToContainer(Slot slotIn) { + if(slotIn instanceof SlotRecipe) { + getRecipeSlots().add((SlotRecipe) slotIn); + } + return super.addSlotToContainer(slotIn); + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/api/GuiBase.java b/MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/api/GuiBase.java new file mode 100644 index 0000000..9549d0f --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/api/GuiBase.java @@ -0,0 +1,313 @@ +package com.blamejared.ctgui.api; + +import com.blamejared.ctgui.client.gui.GuiMenu; +import net.minecraft.block.Block; +import net.minecraft.client.Minecraft; +import net.minecraft.client.gui.*; +import net.minecraft.client.gui.inventory.GuiContainer; +import net.minecraft.client.renderer.GlStateManager; +import net.minecraft.item.ItemStack; +import net.minecraft.util.ResourceLocation; +import org.apache.commons.lang3.tuple.Pair; +import org.lwjgl.opengl.GL11; + +import java.awt.*; +import java.io.*; +import java.util.*; +import java.util.List; + +public abstract class GuiBase extends GuiContainer { + + public SlotRecipe selectedSlot; + public GuiTextField editingField; + public GuiButton add; + public GuiButton remove; + protected ContainerBase container; + protected GuiMenu menu = new GuiMenu(); + private boolean shouldOpenMenu; + + public GuiBase(ContainerBase container, int xSize, int ySize, boolean shouldOpenMenu) { + super(container); + this.container = container; + this.xSize = xSize; + this.ySize = ySize; + this.shouldOpenMenu = shouldOpenMenu; + } + + public static boolean isBlock(ItemStack stack) { + ResourceLocation name = Block.REGISTRY.getNameForObject(Block.getBlockFromItem(stack.getItem())); + return !(name != null && name.toString().equals("minecraft:air")) && Block.REGISTRY.containsKey(name); + } + + @Override + public void initGui() { + super.initGui(); + buttonList.clear(); + if(shouldOpenMenu) + menu.open(this, guiLeft - 102, guiTop + 2); + editingField = new GuiTextField(2906, fontRendererObj, guiLeft - 104, guiTop - 26, xSize + 102, 20); + editingField.setMaxStringLength(Integer.MAX_VALUE); + editingField.setEnabled(true); + add = new GuiButton(2906, getGuiLeft() + 86, getGuiTop() + 8, fontRendererObj.getStringWidth("Add") + 4, 20, "Add"); + getButtonList().add(add); + remove = new GuiButton(2907, getGuiLeft() + 86 + 2 + fontRendererObj.getStringWidth("Add") + 4, getGuiTop() + 8, fontRendererObj.getStringWidth("Remove") + 4, 20, "Remove"); + getButtonList().add(remove); + + } + + @Override + public void drawScreen(int mouseX, int mouseY, float partialTicks) { + super.drawScreen(mouseX, mouseY, partialTicks); + editingField.drawTextBox(); + } + + @Override + public void updateScreen() { + super.updateScreen(); + if(selectedSlot != null) { + if(!selectedSlot.getHasStack()) { + selectedSlot = null; + editingField.setText(""); + if(shouldOpenMenu) { + menu.setState(false); + menu.toggle(false); + for(Pair but : menu.getButtons()) { + for(Slider slider : but.getValue()) { + slider.setValue(0); + slider.maxValue = 0; + slider.updateSlider(); + buttonList.remove(slider); + } + } + } + } else { + editingField.setText(selectedSlot.getItemString()); + } + } else { + editingField.setText(""); + if(shouldOpenMenu) { + menu.setState(false); + menu.toggle(false); + for(Pair but : menu.getButtons()) { + for(Slider slider : but.getValue()) { + slider.setValue(0); + slider.maxValue = 0; + slider.updateSlider(); + buttonList.remove(slider); + } + } + } + + } + editingField.updateCursorCounter(); + final boolean[] canCreate = {true}; + container.getRecipeSlots().stream().filter(slot -> slot instanceof SlotRecipeOutput).filter(slot -> !slot.getHasStack()).forEach(slot -> canCreate[0] = false); + if(!canCreate[0]) { + add.enabled = false; + remove.enabled = false; + } else { + add.enabled = true; + remove.enabled = true; + } + if(shouldOpenMenu) { + if(selectedSlot != null) { + if(selectedSlot.getHasStack() && !selectedSlot.getStack().hasTagCompound()) { + menu.nbt.getLeft().enabled = false; + } + } + } + } + + @Override + protected void mouseClicked(int mouseX, int mouseY, int mouseButton) throws IOException { + final boolean[] clickedSlot = new boolean[]{false}; + for(SlotRecipe slot : container.getRecipeSlots()) { + Rectangle rectangle = new Rectangle(guiLeft + slot.xPos, guiTop + slot.yPos, 18, 18); + if(rectangle.contains(mouseX, mouseY)) { + switch(mouseButton) { + case 0: + break; + case 1: + if(slot.getHasStack()) { + clickedSlot[0] = true; + selectedSlot = slot; + editingField.setText(slot.getItemString()); + if(shouldOpenMenu) { + menu.toggle(true); + for(Pair but : menu.getButtons()) { + for(Slider slider : but.getValue()) { + buttonList.remove(slider); + } + } + menu.getFromMap(slot.getPropertyMap(), slot.getProperties()); + } + } + break; + case 2: + clickedSlot[0] = true; + selectedSlot = null; + if(shouldOpenMenu) { + menu.toggle(false); + for(Pair but : menu.getButtons()) { + for(Slider slider : but.getValue()) { + slider.updateSlider(); + buttonList.remove(slider); + } + } + } + if(editingField != null) + editingField.setText(""); + break; + } + } + + } + if(!clickedSlot[0]) { + super.mouseClicked(mouseX, mouseY, mouseButton); + } + } + + public abstract String getOutputAdd(); + + public abstract String getOutputRemove(); + + protected void actionPerformed(GuiButton btn) { + if(btn.equals(add)) { + File scriptFile = new File(new File("scripts"), "/recipes.zs"); + if(!scriptFile.exists()) { + generateFile(scriptFile); + } + try { + List lines = new LinkedList<>(); + BufferedReader reader = new BufferedReader(new FileReader(scriptFile)); + String line; + while((line = reader.readLine()) != null) { + lines.add(line); + } + if(lines.isEmpty()) { + generateFile(scriptFile); + while((line = reader.readLine()) != null) { + lines.add(line); + } + } + reader.close(); + PrintWriter writer = new PrintWriter(new FileWriter(scriptFile)); + for(int i = 0; i < lines.size(); i++) { + String beforeLine = ""; + if(i > 0) + beforeLine = lines.get(i - 1); + + String lined = lines.get(i); + if(beforeLine.trim().equals("//#Add")) { + writer.println(getOutputAdd()); + } + if(!lined.isEmpty()) { + writer.println(lined); + } + + } + writer.close(); + } catch(IOException e) { + e.printStackTrace(); + } + } + if(btn.equals(remove)) { + File scriptFile = new File(new File("scripts"), "/recipes.zs"); + if(!scriptFile.exists()) { + generateFile(scriptFile); + } + + try { + List lines = new LinkedList<>(); + BufferedReader reader = new BufferedReader(new FileReader(scriptFile)); + String line; + while((line = reader.readLine()) != null) { + lines.add(line); + } + if(lines.isEmpty()) { + generateFile(scriptFile); + while((line = reader.readLine()) != null) { + lines.add(line); + } + } + reader.close(); + PrintWriter writer = new PrintWriter(new FileWriter(scriptFile)); + for(int i = 0; i < lines.size(); i++) { + String beforeLine = ""; + if(i > 0) + beforeLine = lines.get(i - 1); + + String lined = lines.get(i); + if(beforeLine.trim().equals("//#Remove")) { + writer.println(getOutputRemove()); + } + if(!lined.isEmpty()) { + writer.println(lined); + } + } + writer.close(); + } catch(IOException e) { + e.printStackTrace(); + } + } + } + + public abstract ResourceLocation getTexture(); + + protected void drawGuiContainerBackgroundLayer(float partialTicks, int mouseX, int mouseY) { + GlStateManager.pushAttrib(); + GL11.glColor4f(1.0f, 1.0f, 1.0f, 1.0f); + Minecraft.getMinecraft().renderEngine.bindTexture(getTexture()); + drawTexturedModalRect(guiLeft, guiTop, 0, 0, xSize, ySize); + GlStateManager.popAttrib(); + if(selectedSlot != null) { + GlStateManager.colorMask(true, true, true, false); + this.drawGradientRect(guiLeft + selectedSlot.xPos, guiTop + selectedSlot.yPos, guiLeft + selectedSlot.xPos + 16, guiTop + selectedSlot.yPos + 16, Color.cyan.darker().getRGB(), Color.cyan.darker().getRGB()); + GlStateManager.colorMask(true, true, true, true); + } + } + + public List getButtonList() { + return this.buttonList; + } + + public int getGuiLeft() { + return guiLeft; + } + + public int getGuiTop() { + return guiTop; + } + + public int getXSize() { + return xSize; + } + + public int getYSize() { + return ySize; + } + + public GuiMenu getMenu() { + return menu; + } + + + public void generateFile(File f) { + try { + f.createNewFile(); + PrintWriter writer = new PrintWriter(new FileWriter(f)); + writer.println("//This file was created via CT-GUI! Editing it is not advised!"); + writer.println("//Don't touch me!"); + writer.println("//#Remove"); + writer.println(); + writer.println("//Don't touch me!"); + writer.println("//#Add"); + writer.println(); + writer.println("//File End"); + writer.close(); + } catch(IOException e) { + e.printStackTrace(); + } + } + +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/api/GuiRegistry.java b/MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/api/GuiRegistry.java new file mode 100644 index 0000000..bf360d3 --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/api/GuiRegistry.java @@ -0,0 +1,30 @@ +package com.blamejared.ctgui.api; + +import net.minecraftforge.fml.common.network.IGuiHandler; + +import java.util.*; + +/** + * Created by Jared. + */ +public class GuiRegistry { + + public static Map, IGuiHandler> guiMap = new HashMap<>(); + + public static void registerGui(List idRange, IGuiHandler handler) { + getGuiMap().put(idRange, handler); + } + + public static IGuiHandler getHandlerForID(int id) { + for(Map.Entry, IGuiHandler> entry : getGuiMap().entrySet()) { + if(entry.getKey().contains(id)) { + return entry.getValue(); + } + } + return null; + } + + public static Map, IGuiHandler> getGuiMap() { + return guiMap; + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/api/Slider.java b/MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/api/Slider.java new file mode 100644 index 0000000..05e98b9 --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/api/Slider.java @@ -0,0 +1,26 @@ +package com.blamejared.ctgui.api; + +import net.minecraftforge.fml.client.config.GuiSlider; + +/** + * Created by Jared. + */ +public class Slider extends GuiSlider { + + private String propertyKey; + + public Slider(String propertyKey, int id, int xPos, int yPos, int width, int height, String prefix, String suf, double minVal, double maxVal, double currentVal, boolean showDec, boolean drawStr) { + super(id, xPos, yPos, width, height, prefix, suf, minVal, maxVal, currentVal, showDec, drawStr); + this.propertyKey = propertyKey; + } + + public Slider(String propertyKey, int id, int xPos, int yPos, int width, int height, String prefix, String suf, double minVal, double maxVal, double currentVal, boolean showDec, boolean drawStr, ISlider par) { + super(id, xPos, yPos, width, height, prefix, suf, minVal, maxVal, currentVal, showDec, drawStr, par); + this.propertyKey = propertyKey; + } + + + public String getPropertyKey() { + return propertyKey; + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/api/SlotRecipe.java b/MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/api/SlotRecipe.java new file mode 100644 index 0000000..f578ae5 --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/api/SlotRecipe.java @@ -0,0 +1,113 @@ +package com.blamejared.ctgui.api; + +import minetweaker.mc1112.data.NBTConverter; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.inventory.*; +import net.minecraft.item.*; +import net.minecraftforge.oredict.OreDictionary; + +import javax.annotation.Nullable; +import java.util.*; + +/** + * Created by Jared. + */ +public class SlotRecipe extends Slot { + + //key is the operation, value is the values, for more than 1 value, seperate using ยง + private Map propertyMap = new HashMap<>(); + private Map properties = new HashMap<>(); + + + public SlotRecipe(IInventory inventoryIn, int index, int xPosition, int yPosition) { + super(inventoryIn, index, xPosition, yPosition); + } + + @Override + public ItemStack onTake(EntityPlayer playerIn, ItemStack stack) { + this.propertyMap.clear(); + this.properties.clear(); + return super.onTake(playerIn, stack); + } + + + @Override + public int getSlotStackLimit() { + return 1; + } + + @Override + public boolean isItemValid(@Nullable ItemStack stack) { + return true; + } + + public String getItemString() { + boolean matchAny = getPropertyFromMap("matchNotEmpty"); + boolean metaWildcard = getPropertyFromMap("anyMetadata"); + boolean oreDict = getPropertyFromMap("oreDictionary"); + if(getStack().isEmpty()) + return "null"; + String stackName = Item.REGISTRY.getNameForObject(getStack().getItem()).toString(); + StringBuilder builder = new StringBuilder("<"); + if(oreDict) { + int[] ids = OreDictionary.getOreIDs(getStack()); + if(ids.length != 0) { + stackName = "ore:" + OreDictionary.getOreName(ids[0]); + } else + oreDict = false; + } + if(matchAny) { + stackName = "*"; + } + builder.append(stackName); + if(!oreDict && !matchAny && (metaWildcard || getStack().getItemDamage() != 0)) + builder.append(':').append(metaWildcard || getStack().getItemDamage() == OreDictionary.WILDCARD_VALUE ? "*" : getStack().getItemDamage()); + builder.append('>'); + if(getStack().getCount() > 1) + builder.append(" * ").append(getStack().getCount()); + if(getPropertyFromMap("anyDamage")) + builder.append(".anyDamage()"); + if(getPropertyFromMap("onlyDamage")) + builder.append(".onlyDamaged()"); + if(getPropertyFromMap("gted")) + builder.append(".onlyDamageAtLeast(").append("").append(getProperty("gted")).append(')'); + if(getPropertyFromMap("ltd")) + builder.append(".onlyDamageAtMost(").append("").append(getProperty("ltd")).append(')'); + if(getPropertyFromMap("betweenDamage")) { + builder.append(".onlyDamageBetween(").append("").append(getProperty("betweenDamageX")).append(", ").append("").append(getProperty("betweenDamageY")).append(')'); + } + if(getPropertyFromMap("reuse")) + builder.append(".reuse()"); + if(getPropertyFromMap("noreturn")) + builder.append(".noReturn()"); + if(getPropertyFromMap("nbt")) { + if(this instanceof SlotRecipeOutput) + builder.append(String.format(".withTag(%s)", NBTConverter.from(getStack().getTagCompound(), false).toString())); + else + builder.append(String.format(".onlyWithTag(%s)", NBTConverter.from(getStack().getTagCompound(), false).toString())); + } + return builder.toString(); + } + + boolean getPropertyFromMap(String key) { + if(propertyMap.containsKey(key)) { + return propertyMap.get(key); + } + return false; + } + + int getProperty(String key) { + if(properties.containsKey(key)) { + return properties.get(key); + } + return 0; + } + + public Map getPropertyMap() { + return propertyMap; + } + + public Map getProperties() { + return properties; + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/api/SlotRecipeOutput.java b/MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/api/SlotRecipeOutput.java new file mode 100644 index 0000000..cd6c58c --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/api/SlotRecipeOutput.java @@ -0,0 +1,13 @@ +package com.blamejared.ctgui.api; + +import net.minecraft.inventory.IInventory; + +/** + * Created by Jared. + */ +public class SlotRecipeOutput extends SlotRecipe { + + public SlotRecipeOutput(IInventory inventoryIn, int index, int xPosition, int yPosition) { + super(inventoryIn, index, xPosition, yPosition); + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/client/GuiHandler.java b/MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/client/GuiHandler.java new file mode 100644 index 0000000..00e8d61 --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/client/GuiHandler.java @@ -0,0 +1,33 @@ +package com.blamejared.ctgui.client; + +import com.blamejared.ctgui.MTRecipe; +import com.blamejared.ctgui.api.GuiRegistry; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.world.World; +import net.minecraftforge.fml.common.network.*; + +/** + * Created by Jared. + */ +public class GuiHandler implements IGuiHandler { + + public GuiHandler() { + NetworkRegistry.INSTANCE.registerGuiHandler(MTRecipe.INSTANCE, this); + } + + @Override + public Object getServerGuiElement(int ID, EntityPlayer player, World world, int x, int y, int z) { + if(GuiRegistry.getHandlerForID(ID) == null) { + return null; + } + return GuiRegistry.getHandlerForID(ID).getServerGuiElement(ID, player, world, x, y, z); + } + + @Override + public Object getClientGuiElement(int ID, EntityPlayer player, World world, int x, int y, int z) { + if(GuiRegistry.getHandlerForID(ID) == null) { + return null; + } + return GuiRegistry.getHandlerForID(ID).getClientGuiElement(ID, player, world, x, y, z); + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/client/GuiHandlerVanilla.java b/MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/client/GuiHandlerVanilla.java new file mode 100644 index 0000000..b131d92 --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/client/GuiHandlerVanilla.java @@ -0,0 +1,35 @@ +package com.blamejared.ctgui.client; + +import com.blamejared.ctgui.client.gui.craftingtable.*; +import com.blamejared.ctgui.client.gui.furnace.*; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.world.World; +import net.minecraftforge.fml.common.network.IGuiHandler; + +/** + * Created by Jared. + */ +public class GuiHandlerVanilla implements IGuiHandler { + + @Override + public Object getServerGuiElement(int ID, EntityPlayer player, World world, int x, int y, int z) { + switch(ID) { + case 1: + return new ContainerCraftingTable(player.inventory); + case 2: + return new ContainerFurnace(player.inventory); + } + return null; + } + + @Override + public Object getClientGuiElement(int ID, EntityPlayer player, World world, int x, int y, int z) { + switch(ID) { + case 1: + return new GuiCraftingTable(new ContainerCraftingTable(player.inventory)); + case 2: + return new GuiFurnace(new ContainerFurnace(player.inventory)); + } + return null; + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/client/InventoryFake.java b/MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/client/InventoryFake.java new file mode 100644 index 0000000..9ed898f --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/client/InventoryFake.java @@ -0,0 +1,126 @@ +package com.blamejared.ctgui.client; + +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.inventory.*; +import net.minecraft.item.ItemStack; +import net.minecraft.util.NonNullList; +import net.minecraft.util.text.ITextComponent; + +import javax.annotation.Nullable; + +/** + * Created by Jared. + */ +public class InventoryFake implements IInventory { + + private final int size; + private NonNullList items; + + public InventoryFake(int size) { + this.size = size; + items = NonNullList.create(); + } + + @Override + public int getSizeInventory() { + return size; + } + + public boolean isEmpty() { + for(ItemStack itemstack : this.items) { + if(!itemstack.isEmpty()) { + return false; + } + } + + return true; + } + + @Nullable + @Override + public ItemStack getStackInSlot(int index) { + return index >= this.getSizeInventory() ? ItemStack.EMPTY : items.get(index); + } + + @Nullable + @Override + public ItemStack decrStackSize(int index, int count) { + return ItemStackHelper.getAndSplit(items, index, count); + } + + @Nullable + @Override + public ItemStack removeStackFromSlot(int index) { + return ItemStackHelper.getAndRemove(items, index); + } + + @Override + public void setInventorySlotContents(int index, @Nullable ItemStack stack) { + this.items.set(index, stack); + } + + @Override + public int getInventoryStackLimit() { + return 64; + } + + @Override + public void markDirty() { + + } + + @Override + public boolean isUsableByPlayer(EntityPlayer player) { + return true; + } + + @Override + public void openInventory(EntityPlayer player) { + + } + + @Override + public void closeInventory(EntityPlayer player) { + + } + + @Override + public boolean isItemValidForSlot(int index, ItemStack stack) { + return true; + } + + @Override + public int getField(int id) { + return 0; + } + + @Override + public void setField(int id, int value) { + + } + + @Override + public int getFieldCount() { + return 0; + } + + @Override + public void clear() { + items.clear(); + } + + @Override + public String getName() { + return "Fake Inventory"; + } + + @Override + public boolean hasCustomName() { + return false; + } + + @Override + public ITextComponent getDisplayName() { + return null; + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/client/gui/GuiMenu.java b/MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/client/gui/GuiMenu.java new file mode 100644 index 0000000..83ead7f --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/client/gui/GuiMenu.java @@ -0,0 +1,210 @@ +package com.blamejared.ctgui.client.gui; + +import com.blamejared.ctgui.api.*; +import net.minecraftforge.fml.relauncher.*; +import org.apache.commons.lang3.tuple.*; + +import java.util.*; + +@SideOnly(Side.CLIENT) +public class GuiMenu { + + // public Pair matchNotEmpty; + public Pair useOreDict; + public Pair matchAnyMetadata; + public Pair anyDamage; + public Pair onlyDamage; + // public Pair damage; + public Pair greaterThanEqualDamage; + public Pair lessThanDamage; + public Pair betweenDamage; + public Pair nbt; + // public Pair transformDamage; + // public Pair transformReplace; + public Pair reuse; + public Pair noReturn; + private GuiBase parent; + private int x; + private int y; + private List> buttons = new ArrayList<>(); + // public Pair giveBack; + + + public GuiMenu() { + } + + public void open(final GuiBase parent, int x, int y) { + this.parent = parent; + this.x = x; + this.y = y; + int buttonCount = 0; + // matchNotEmpty = new MutablePair<>(new CheckButtonRecipe(parent, 0, x, y + (15 * buttonCount++), "Match Not Empty", false, "matchNotEmpty"), new Slider[]{}); + useOreDict = new MutablePair<>(new CheckButtonRecipe(parent, 1, x, y + (15 * buttonCount++), "Ore Dictionary", false, "oreDictionary"), new Slider[]{}); + matchAnyMetadata = new MutablePair<>(new CheckButtonRecipe(parent, 2, x, y + (15 * buttonCount++), "Any Metadata", false, "anyMetadata"), new Slider[]{}); + anyDamage = new MutablePair<>(new CheckButtonRecipe(parent, 3, x, y + (15 * buttonCount++), "Any Damage", false, "anyDamage"), new Slider[]{}); + onlyDamage = new MutablePair<>(new CheckButtonRecipe(parent, 4, x, y + (15 * buttonCount++), "Only Damage", false, "onlyDamage"), new Slider[]{}); + greaterThanEqualDamage = new MutablePair<>(new CheckButtonRecipe(parent, 6, x, y + (15 * buttonCount++), "X>=Damage", false, "gted"), new Slider[]{new Slider("gted", 10, x - 2, parent.getGuiTop() + parent.getYSize() + 20, parent.getXSize() + 102, 20, "X= ", "", 0, 0, 0, false, true, slider -> { + if(parent.selectedSlot != null && parent.selectedSlot.getStack() != null) { + parent.selectedSlot.getProperties().put(((Slider) slider).getPropertyKey(), slider.getValueInt()); + } + })}); + lessThanDamage = new MutablePair<>(new CheckButtonRecipe(parent, 7, x, y + (15 * buttonCount++), "Damage { + if(parent.selectedSlot != null && parent.selectedSlot.getStack() != null) { + parent.selectedSlot.getProperties().put(((Slider) slider).getPropertyKey(), slider.getValueInt()); + } + })}); + betweenDamage = new MutablePair<>(new CheckButtonRecipe(parent, 8, x, y + (15 * buttonCount++), "X { + if(parent.selectedSlot != null && parent.selectedSlot.getStack() != null) { + parent.selectedSlot.getProperties().put(((Slider) slider).getPropertyKey(), slider.getValueInt()); + } + }), new Slider("betweenDamageY", 13, x - 2, parent.getGuiTop() + parent.getYSize() + 44, parent.getXSize() + 102, 20, "Y= ", "", 0, 0, 0, false, true, slider -> { + if(parent.selectedSlot != null && parent.selectedSlot.getStack() != null) { + parent.selectedSlot.getProperties().put(((Slider) slider).getPropertyKey(), slider.getValueInt()); + } + })}); + + nbt = new MutablePair<>(new CheckButtonRecipe(parent, 8, x, y + (15 * buttonCount++), "NBT", false, "nbt"), new Slider[]{}); + + reuse = new MutablePair<>(new CheckButtonRecipe(parent, 0, x, y + (15 * buttonCount++), "Reuse", false, "reuse"), new Slider[]{}); + noReturn = new MutablePair<>(new CheckButtonRecipe(parent, 0, x, y + (15 * buttonCount), "No Return", false, "noreturn"), new Slider[]{}); + + + this.buttons.add(useOreDict); + this.buttons.add(matchAnyMetadata); + this.buttons.add(anyDamage); + this.buttons.add(onlyDamage); + + this.buttons.add(greaterThanEqualDamage); + this.buttons.add(lessThanDamage); + this.buttons.add(betweenDamage); + this.buttons.add(nbt); + + + this.buttons.add(reuse); + this.buttons.add(noReturn); + + for(Pair but : this.buttons) { + parent.getButtonList().add(but.getLeft()); + } + + useOreDict.getLeft().setIncompatible(Arrays.asList(new CheckButtonRecipe[]{matchAnyMetadata.getLeft(), anyDamage.getLeft(), onlyDamage.getLeft(), greaterThanEqualDamage.getLeft(), lessThanDamage.getLeft(), betweenDamage.getLeft(), nbt.getLeft()})); + matchAnyMetadata.getLeft().setIncompatible(Arrays.asList(new CheckButtonRecipe[]{useOreDict.getLeft(), anyDamage.getLeft(), onlyDamage.getLeft(), greaterThanEqualDamage.getLeft(), lessThanDamage.getLeft(), betweenDamage.getLeft()})); + anyDamage.getLeft().setIncompatible(Arrays.asList(new CheckButtonRecipe[]{useOreDict.getLeft(), matchAnyMetadata.getLeft(), onlyDamage.getLeft(), greaterThanEqualDamage.getLeft(), lessThanDamage.getLeft(), betweenDamage.getLeft()})); + onlyDamage.getLeft().setIncompatible(Arrays.asList(new CheckButtonRecipe[]{useOreDict.getLeft(), matchAnyMetadata.getLeft(), anyDamage.getLeft(), greaterThanEqualDamage.getLeft(), lessThanDamage.getLeft(), betweenDamage.getLeft()})); + + greaterThanEqualDamage.getLeft().setIncompatible(Arrays.asList(new CheckButtonRecipe[]{useOreDict.getLeft(), matchAnyMetadata.getLeft(), anyDamage.getLeft(), onlyDamage.getLeft(), lessThanDamage.getLeft(), betweenDamage.getLeft()})); + lessThanDamage.getLeft().setIncompatible(Arrays.asList(new CheckButtonRecipe[]{useOreDict.getLeft(), matchAnyMetadata.getLeft(), anyDamage.getLeft(), onlyDamage.getLeft(), greaterThanEqualDamage.getLeft(), betweenDamage.getLeft()})); + betweenDamage.getLeft().setIncompatible(Arrays.asList(new CheckButtonRecipe[]{useOreDict.getLeft(), matchAnyMetadata.getLeft(), anyDamage.getLeft(), onlyDamage.getLeft(), greaterThanEqualDamage.getLeft(), lessThanDamage.getLeft()})); + + nbt.getLeft().setIncompatible(Arrays.asList(new CheckButtonRecipe[]{useOreDict.getLeft()})); + noReturn.getLeft().setIncompatible(Collections.singletonList(reuse.getLeft())); + reuse.getLeft().setIncompatible(Collections.singletonList(noReturn.getLeft())); + + + } + + public void close(GuiBase parent) { + this.parent = parent; + if(!parent.getButtonList().isEmpty()) { + this.parent.getButtonList().remove(useOreDict.getLeft()); + this.parent.getButtonList().remove(matchAnyMetadata.getLeft()); + this.parent.getButtonList().remove(anyDamage.getLeft()); + this.parent.getButtonList().remove(onlyDamage.getLeft()); + this.parent.getButtonList().remove(greaterThanEqualDamage.getLeft()); + this.parent.getButtonList().remove(lessThanDamage.getLeft()); + this.parent.getButtonList().remove(betweenDamage.getLeft()); + + this.parent.getButtonList().remove(reuse.getLeft()); + this.parent.getButtonList().remove(noReturn.getLeft()); + + } + } + + + public void setState(boolean active) { + useOreDict.getLeft().setIsChecked(active); + matchAnyMetadata.getLeft().setIsChecked(active); + anyDamage.getLeft().setIsChecked(active); + onlyDamage.getLeft().setIsChecked(active); + + greaterThanEqualDamage.getLeft().setIsChecked(active); + lessThanDamage.getLeft().setIsChecked(active); + betweenDamage.getLeft().setIsChecked(active); + reuse.getLeft().setIsChecked(active); + noReturn.getLeft().setIsChecked(active); + nbt.getLeft().setIsChecked(active); + + } + + public void toggle(boolean active) { + useOreDict.getLeft().enabled = active; + matchAnyMetadata.getLeft().enabled = active; + anyDamage.getLeft().enabled = active; + onlyDamage.getLeft().enabled = active; + greaterThanEqualDamage.getLeft().enabled = active; + lessThanDamage.getLeft().enabled = active; + betweenDamage.getLeft().enabled = active; + reuse.getLeft().enabled = active; + noReturn.getLeft().enabled = active; + nbt.getLeft().enabled = active; + + + } + + public void getFromMap(Map propertyMap, Map properties) { + useOreDict.getLeft().setIsChecked(getPropertyFromMap(propertyMap, useOreDict.getLeft().getPropertyKey())); + matchAnyMetadata.getLeft().setIsChecked(getPropertyFromMap(propertyMap, matchAnyMetadata.getLeft().getPropertyKey())); + anyDamage.getLeft().setIsChecked(getPropertyFromMap(propertyMap, anyDamage.getLeft().getPropertyKey())); + onlyDamage.getLeft().setIsChecked(getPropertyFromMap(propertyMap, onlyDamage.getLeft().getPropertyKey())); + greaterThanEqualDamage.getLeft().setIsChecked(getPropertyFromMap(propertyMap, greaterThanEqualDamage.getLeft().getPropertyKey())); + lessThanDamage.getLeft().setIsChecked(getPropertyFromMap(propertyMap, lessThanDamage.getLeft().getPropertyKey())); + betweenDamage.getLeft().setIsChecked(getPropertyFromMap(propertyMap, betweenDamage.getLeft().getPropertyKey())); + reuse.getLeft().setIsChecked(getPropertyFromMap(propertyMap, reuse.getLeft().getPropertyKey())); + noReturn.getLeft().setIsChecked(getPropertyFromMap(propertyMap, noReturn.getLeft().getPropertyKey())); + nbt.getLeft().setIsChecked(getPropertyFromMap(propertyMap, nbt.getLeft().getPropertyKey())); + } + + boolean getPropertyFromMap(Map propertyMap, String key) { + if(propertyMap.containsKey(key)) { + return propertyMap.get(key); + } + return false; + } + + Object getProperty(Map propertyMap, String key) { + if(propertyMap.containsKey(key)) { + return propertyMap.get(key); + } + return false; + } + + public int getX() { + return x; + } + + public int getY() { + return y; + } + + public int getWidth() { + return 11; + } + + public int getHeight() { + return 55; + } + + + public Slider[] getSliders(CheckButtonRecipe check) { + for(Pair pair : this.buttons) { + if(pair.getLeft().getPropertyKey().equals(check.getPropertyKey())) { + return pair.getValue(); + } + } + return new Slider[0]; + } + + public List> getButtons() { + return buttons; + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/client/gui/craftingtable/ContainerCraftingTable.java b/MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/client/gui/craftingtable/ContainerCraftingTable.java new file mode 100644 index 0000000..bbf93e4 --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/client/gui/craftingtable/ContainerCraftingTable.java @@ -0,0 +1,36 @@ +package com.blamejared.ctgui.client.gui.craftingtable; + +import com.blamejared.ctgui.api.*; +import net.minecraft.entity.player.InventoryPlayer; +import net.minecraft.inventory.*; + +/** + * Created by Jared. + */ +public class ContainerCraftingTable extends ContainerBase { + + public InventoryCrafting craftMatrix = new InventoryCrafting(this, 3, 3); + public IInventory craftResult = new InventoryCraftResult(); + + public ContainerCraftingTable(InventoryPlayer invPlayer) { + //output + this.addSlotToContainer(new SlotRecipeOutput(craftResult, 0, 124, 35)); + //Slots + for(int i = 0; i < 3; ++i) { + for(int j = 0; j < 3; ++j) { + this.addSlotToContainer(new SlotRecipe(craftMatrix, j + i * 3, 30 + j * 18, 17 + i * 18)); + } + } + //Player + for(int x = 0; x < 9; x++) { + addSlotToContainer(new Slot(invPlayer, x, 8 + 18 * x, 142)); + } + + for(int y = 0; y < 3; y++) { + for(int x = 0; x < 9; x++) { + addSlotToContainer(new Slot(invPlayer, x + y * 9 + 9, 8 + 18 * x, 84 + y * 18)); + } + } + } + +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/client/gui/craftingtable/GuiCraftingTable.java b/MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/client/gui/craftingtable/GuiCraftingTable.java new file mode 100644 index 0000000..9265561 --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/client/gui/craftingtable/GuiCraftingTable.java @@ -0,0 +1,93 @@ +package com.blamejared.ctgui.client.gui.craftingtable; + +import com.blamejared.ctgui.api.*; +import net.minecraft.util.ResourceLocation; + +import java.util.*; + +/** + * Created by Jared. + */ +public class GuiCraftingTable extends GuiBase { + + private CheckButton shaped; + private CheckButton shapeless; + private CheckButton mirror; + public GuiCraftingTable(ContainerBase container) { + super(container, 176, 166, true); + } + + @Override + public void initGui() { + super.initGui(); + shaped = new CheckButton(this, 2910, getGuiLeft(), getGuiTop() + getYSize() + 4, "Shaped", true); + shapeless = new CheckButton(this, 2911, getGuiLeft() + 54, getGuiTop() + getYSize() + 4, "Shapeless", false); + mirror = new CheckButton(this, 2912, getGuiLeft() + 54 + 74, getGuiTop() + getYSize() + 4, "Mirror", false); + shaped.setBackgroundSize(50); + shapeless.setBackgroundSize(70); + mirror.setBackgroundSize(50); + + getButtonList().add(shapeless); + getButtonList().add(shaped); + getButtonList().add(mirror); + shaped.setIncompatible(Collections.singletonList(shapeless)); + shapeless.setIncompatible(Arrays.asList(shaped, mirror)); + mirror.setIncompatible(Collections.singletonList(remove)); + shaped.setIsChecked(true); + + } + + @Override + public String getOutputAdd() { + String type = "add"; + boolean shapel = false; + if(shapeless.isChecked()) { + type += "Shapeless"; + shapel = true; + } else if(shaped.isChecked()) { + type += "Shaped"; + } + if(mirror.isChecked()) { + type += "Mirrored"; + } + if(shapel) { + return String.format("recipes.%s(%s, [%s%s%s%s%s%s%s%s%s]);", type, container.getRecipeSlots().get(0).getItemString(), getShapelessItem(container.getRecipeSlots().get(1), true), getShapelessItem(container.getRecipeSlots().get(2), false), getShapelessItem(container.getRecipeSlots().get(3), false), getShapelessItem(container.getRecipeSlots().get(4), false), getShapelessItem(container.getRecipeSlots().get(5), false), getShapelessItem(container.getRecipeSlots().get(6), false), getShapelessItem(container.getRecipeSlots().get(7), false), getShapelessItem(container.getRecipeSlots().get(8), false), getShapelessItem(container.getRecipeSlots().get(9), false)); + } + return String.format("recipes.%s(%s, [[%s, %s, %s],[%s, %s, %s], [%s, %s, %s]]);", type, container.getRecipeSlots().get(0).getItemString(), container.getRecipeSlots().get(1).getItemString(), container.getRecipeSlots().get(2).getItemString(), container.getRecipeSlots().get(3).getItemString(), container.getRecipeSlots().get(4).getItemString(), container.getRecipeSlots().get(5).getItemString(), container.getRecipeSlots().get(6).getItemString(), container.getRecipeSlots().get(7).getItemString(), container.getRecipeSlots().get(8).getItemString(), container.getRecipeSlots().get(9).getItemString()); + } + + private String getShapelessItem(SlotRecipe slot, boolean first) { + String ret = ""; + if(slot.getHasStack()) { + if(!first) { + ret += ", "; + } + ret += slot.getItemString(); + } + return ret.isEmpty() ? ret : ret; + } + + @Override + public String getOutputRemove() { + boolean hasrecipe = false; + for(int i = 1; i < container.getRecipeSlots().size(); i++) { + SlotRecipe slot = container.getRecipeSlots().get(i); + if(slot.getHasStack()) { + hasrecipe = true; + } + } + + boolean shapel = shapeless.isChecked(); + if(shapel) { + return String.format("recipes.removeShapeless(%s, [%s%s%s%s%s%s%s%s%s]);", container.getRecipeSlots().get(0).getItemString(), getShapelessItem(container.getRecipeSlots().get(1), true), getShapelessItem(container.getRecipeSlots().get(2), false), getShapelessItem(container.getRecipeSlots().get(3), false), getShapelessItem(container.getRecipeSlots().get(4), false), getShapelessItem(container.getRecipeSlots().get(5), false), getShapelessItem(container.getRecipeSlots().get(6), false), getShapelessItem(container.getRecipeSlots().get(7), false), getShapelessItem(container.getRecipeSlots().get(8), false), getShapelessItem(container.getRecipeSlots().get(9), false)); + } + return hasrecipe ? String.format("recipes.removeShaped(%s, [[%s, %s, %s],[%s, %s, %s], [%s, %s, %s]]);", container.getRecipeSlots().get(0).getItemString(), container.getRecipeSlots().get(1).getItemString(), container.getRecipeSlots().get(2).getItemString(), container.getRecipeSlots().get(3).getItemString(), container.getRecipeSlots().get(4).getItemString(), container.getRecipeSlots().get(5).getItemString(), container.getRecipeSlots().get(6).getItemString(), container.getRecipeSlots().get(7).getItemString(), container.getRecipeSlots().get(8).getItemString(), container.getRecipeSlots().get(9).getItemString()) : String.format("recipes.remove(%s);", container.getRecipeSlots().get(0).getItemString()); + } + + @Override + public ResourceLocation getTexture() { + return new ResourceLocation("textures/gui/container/crafting_table.png"); + } + + +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/client/gui/furnace/ContainerFurnace.java b/MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/client/gui/furnace/ContainerFurnace.java new file mode 100644 index 0000000..42889e1 --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/client/gui/furnace/ContainerFurnace.java @@ -0,0 +1,36 @@ +package com.blamejared.ctgui.client.gui.furnace; + +import com.blamejared.ctgui.api.*; +import com.blamejared.ctgui.client.InventoryFake; +import net.minecraft.entity.player.InventoryPlayer; +import net.minecraft.inventory.*; + +/** + * Created by Jared. + */ +public class ContainerFurnace extends ContainerBase { + + public IInventory inventory = new InventoryFake(1); + public IInventory craftResult = new InventoryCraftResult(); + + public ContainerFurnace(InventoryPlayer invPlayer) { + //output + this.addSlotToContainer(new SlotRecipeOutput(craftResult, 0, 116, 35)); + + //Slots + this.addSlotToContainer(new SlotRecipe(inventory, 0, 56, 17)); + + //Player + for(int x = 0; x < 9; x++) { + addSlotToContainer(new Slot(invPlayer, x, 8 + 18 * x, 142)); + } + + for(int y = 0; y < 3; y++) { + for(int x = 0; x < 9; x++) { + addSlotToContainer(new Slot(invPlayer, x + y * 9 + 9, 8 + 18 * x, 84 + y * 18)); + } + } + } + + +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/client/gui/furnace/GuiFurnace.java b/MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/client/gui/furnace/GuiFurnace.java new file mode 100644 index 0000000..bae9f6d --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/client/gui/furnace/GuiFurnace.java @@ -0,0 +1,48 @@ +package com.blamejared.ctgui.client.gui.furnace; + +import com.blamejared.ctgui.api.*; +import net.minecraft.util.ResourceLocation; + +/** + * Created by Jared. + */ +public class GuiFurnace extends GuiBase { + + private Slider xpSlider; + + public GuiFurnace(ContainerBase container) { + super(container, 176, 166, false); + } + + @Override + public void initGui() { + super.initGui(); + xpSlider = new Slider("slider", 10, getGuiLeft() - 102 - 2, getGuiTop() + getYSize() + 20, getXSize() + 102, 20, "XP= ", "", 0, 50, 0, true, true); + getButtonList().add(xpSlider); + } + + @Override + public void updateScreen() { + super.updateScreen(); + if(!container.getRecipeSlots().get(1).getHasStack()) { + add.enabled = false; + remove.enabled = false; + } + } + + @Override + public String getOutputAdd() { + return String.format("furnace.addRecipe(%s, %s, %s);", container.getRecipeSlots().get(0).getItemString(), container.getRecipeSlots().get(1).getItemString(), xpSlider.getValue() + 0f); + } + + @Override + public String getOutputRemove() { + return String.format("furnace.remove(%s%s);", container.getRecipeSlots().get(0).getItemString(), container.getRecipeSlots().get(1).getHasStack() ? ", " + container.getRecipeSlots().get(1).getItemString() : ""); + } + + @Override + public ResourceLocation getTexture() { + return new ResourceLocation("textures/gui/container/furnace.png"); + } + +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/commands/CommandCTGUI.java b/MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/commands/CommandCTGUI.java new file mode 100644 index 0000000..6d178bf --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/commands/CommandCTGUI.java @@ -0,0 +1,43 @@ +package com.blamejared.ctgui.commands; + +import com.blamejared.ctgui.MTRecipe; +import com.blamejared.ctgui.api.GuiRegistry; +import net.minecraft.command.*; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.server.MinecraftServer; +import net.minecraft.util.text.TextComponentString; + +/** + * Created by Jared. + */ +public class CommandCTGUI extends CommandBase { + + @Override + public String getName() { + return "CTGUI"; + } + + @Override + public String getUsage(ICommandSender sender) { + return "CTGUI "; + } + + @Override + public int getRequiredPermissionLevel() { + return 0; + } + + + @Override + public void execute(MinecraftServer server, ICommandSender sender, String[] args) throws CommandException { + if(args.length == 0 || Integer.parseInt(args[0]) < 1 || GuiRegistry.getHandlerForID(Integer.parseInt(args[0])) == null) { + sender.sendMessage(new TextComponentString("Invalid ID!")); + return; + } + + if(sender instanceof EntityPlayer) { + EntityPlayer player = (EntityPlayer) sender; + player.openGui(MTRecipe.INSTANCE, Integer.parseInt(args[0]), sender.getEntityWorld(), 0, 0, 0); + } + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/proxy/ClientProxy.java b/MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/proxy/ClientProxy.java new file mode 100644 index 0000000..22dd56a --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/proxy/ClientProxy.java @@ -0,0 +1,18 @@ +package com.blamejared.ctgui.proxy; + +import net.minecraft.client.Minecraft; +import net.minecraft.entity.player.EntityPlayer; + +public class ClientProxy extends CommonProxy { + + @Override + public void registerGuis() { + super.registerGuis(); + } + + @Override + public EntityPlayer getPlayer() { + return Minecraft.getMinecraft().player; + } + +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/proxy/CommonProxy.java b/MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/proxy/CommonProxy.java new file mode 100644 index 0000000..11c6762 --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/proxy/CommonProxy.java @@ -0,0 +1,17 @@ +package com.blamejared.ctgui.proxy; + +import com.blamejared.ctgui.client.GuiHandler; +import net.minecraft.entity.player.EntityPlayer; + +public class CommonProxy { + + public void registerGuis() { + new GuiHandler(); + } + + + public EntityPlayer getPlayer() { + return null; + } + +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/reference/Reference.java b/MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/reference/Reference.java new file mode 100644 index 0000000..3bf9fd1 --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/com/blamejared/ctgui/reference/Reference.java @@ -0,0 +1,9 @@ +package com.blamejared.ctgui.reference; + +public class Reference { + + public static final String MOD_ID = "ctgui"; + public static final String MOD_NAME = "CT-GUI"; + public static final String VERSION = "1.0.0"; + +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/minetweaker/api/minecraft/MineTweakerMC.java b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/api/minecraft/MineTweakerMC.java new file mode 100644 index 0000000..0b3039d --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/api/minecraft/MineTweakerMC.java @@ -0,0 +1,511 @@ +package minetweaker.api.minecraft; + +import minetweaker.MineTweakerAPI; +import minetweaker.api.block.*; +import minetweaker.api.data.IData; +import minetweaker.api.item.*; +import minetweaker.api.liquid.ILiquidStack; +import minetweaker.api.oredict.IOreDictEntry; +import minetweaker.api.player.IPlayer; +import minetweaker.api.world.*; +import minetweaker.mc1112.block.*; +import minetweaker.mc1112.data.NBTConverter; +import minetweaker.mc1112.item.MCItemStack; +import minetweaker.mc1112.liquid.MCLiquidStack; +import minetweaker.mc1112.oredict.MCOreDictEntry; +import minetweaker.mc1112.player.MCPlayer; +import minetweaker.mc1112.world.*; +import net.minecraft.block.Block; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.*; +import net.minecraft.nbt.*; +import net.minecraft.world.*; +import net.minecraft.world.biome.Biome; +import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.oredict.OreDictionary; + +import java.util.*; + +/** + * MineTweaker - MineCraft API bridge. + * + * @author Stan Hebben + */ +public class MineTweakerMC { + + public static final IBiome[] biomes; + private static final Map blockDefinitions = new HashMap<>(); + private static final HashMap oreDictArrays = new HashMap(); + static { + biomes = new IBiome[Biome.REGISTRY.getKeys().size()]; + for(int i = 0; i < Biome.REGISTRY.getKeys().size(); i++) { + if(Biome.REGISTRY.getObjectById(i) != null) + biomes[i] = new MCBiome(Biome.REGISTRY.getObjectById(i)); + } + } + + private MineTweakerMC() { + } + + /** + * Returns the Minecraft item for this MineTweaker item. + * + * @param item minetweaker item stack + * + * @return minecraft item stack + */ + public static ItemStack getItemStack(IItemStack item) { + if(item == null) + return ItemStack.EMPTY; + + Object internal = item.getInternal(); + if(internal == null || !(internal instanceof ItemStack)) { + MineTweakerAPI.logError("Not a valid item stack: " + item); + } + return (ItemStack) internal; + } + + /** + * Returns the Minecraft ingredient for this ingredient. This method is only + * useful for ingredients that represent a single item stack. + * + * @param ingredient item ingredient + * + * @return minecraft item stack + */ + public static ItemStack getItemStack(IIngredient ingredient) { + if(ingredient == null) + return ItemStack.EMPTY; + + List items = ingredient.getItems(); + if(items.size() != 1) { + MineTweakerAPI.logError("Not an ingredient with a single item: " + ingredient); + } + return getItemStack(items.get(0)); + } + + /** + * Returns the MineTweaker item stack for this item. + * + * @param item minecraft item stack + * + * @return minetweaker item stack + */ + public static IItemStack getIItemStack(ItemStack item) { + if(item.isEmpty()) + return null; + + return new MCItemStack(item); + } + + /** + * Constructs an item stack with wildcard size. + * + * @param item minecraft item stack + * + * @return minetweaker stack + */ + public static IItemStack getIItemStackWildcardSize(ItemStack item) { + if(item.isEmpty()) + return null; + + return new MCItemStack(item, true); + } + + /** + * Constructs an item stack with wildcard size. + * + * @param item + * @param meta + * + * @return minetweaker stack + */ + public static IItemStack getIItemStackWildcardSize(Item item, int meta) { + if(item == null) + return null; + return new MCItemStack(new ItemStack(item, 1, meta), true); + } + + /** + * Constructs an item stack with wildcard damage. + * + * @param item stack item + * @param amount stack size + * + * @return minetweaker item stack + */ + public static IItemStack getIItemStackWildcard(Item item, int amount) { + if(item == null) + return null; + + return new MCItemStack(new ItemStack(item, 1, OreDictionary.WILDCARD_VALUE)); + } + + public static ItemStack[] getExamples(IIngredient ingredient) { + List examples = ingredient.getItems(); + ItemStack[] result = new ItemStack[examples.size()]; + for(int i = 0; i < examples.size(); i++) { + result[i] = MineTweakerMC.getItemStack(examples.get(i)); + } + return result; + } + + /** + * Constructs an item stack with given item, damage and amount. + * + * @param item stack item + * @param damage stack damage + * @param amount stack amount + * + * @return minetweaker item stack + */ + public static IItemStack getItemStack(Item item, int amount, int damage) { + if(item == null) + return null; + + return new MCItemStack(new ItemStack(item, amount, damage)); + } + + /** + * Converts an array of minetweaker item stacks into an array of minecraft + * item stacks. + * + * @param items minetweker item stacks + * + * @return minecraft item stacks + */ + public static ItemStack[] getItemStacks(IItemStack... items) { + if(items == null) + return null; + + ItemStack[] output = new ItemStack[items.length]; + for(int i = 0; i < items.length; i++) { + Object internal = items[i].getInternal(); + if(internal instanceof ItemStack && !((ItemStack) internal).isEmpty()) { + output[i] = (ItemStack) internal; + } + } + return output; + } + + /** + * Converts a list of minetweaker item stacks into an array of minecraft + * item stacks. + * + * @param items minetweaker items + * + * @return minecraft items + */ + public static ItemStack[] getItemStacks(List items) { + if(items == null) + return null; + + ItemStack[] output = new ItemStack[items.size()]; + for(int i = 0; i < items.size(); i++) { + Object internal = items.get(i).getInternal(); + if(internal instanceof ItemStack && !((ItemStack) internal).isEmpty()) { + output[i] = (ItemStack) internal; + } else { + MineTweakerAPI.logError("Invalid item stack: " + items.get(i)); + } + } + return output; + } + + /** + * Converts an array of minecraft item stacks into an array of minetweaker + * item stacks. + * + * @param items minecraft item stacks + * + * @return minetweaker item stacks + */ + public static IItemStack[] getIItemStacks(ItemStack... items) { + if(items == null) + return null; + + IItemStack[] result = new IItemStack[items.length]; + for(int i = 0; i < items.length; i++) { + if(!items[i].isEmpty()){ + result[i] = new MCItemStack(items[i]); + } + } + return result; + } + + /** + * Converts a list of minecraft item stacks into an array of minetweaker + * item stacks. + * + * @param items minecraft item stacks + * + * @return minetweaker item stacks + */ + public static IItemStack[] getIItemStacks(List items) { + if(items == null) + return null; + + IItemStack[] result = new IItemStack[items.size()]; + for(int i = 0; i < result.length; i++) { + if(!items.get(i).isEmpty()) { + result[i] = new MCItemStack(items.get(i)); + } + } + return result; + } + + /** + * Gets the ore dictionary entry with the given name. If the entry didn't + * exist yet, it will create it and return an empty entry. + * + * @param name ore entry name + * + * @return ore dictionary entry + */ + public static IOreDictEntry getOreDict(String name) { + return new MCOreDictEntry(name); + } + + /** + * Converts a Minecraft player into a MineTweaker player. + * + * @param player minecraft player + * + * @return minetweaker player + */ + public static IPlayer getIPlayer(EntityPlayer player) { + if(player == null) + return null; + + return new MCPlayer(player); + } + + /** + * Converts a MineTweaker player into a Minecraft player. + * + * @param player minetweaker player + * + * @return minecraft player + */ + public static EntityPlayer getPlayer(IPlayer player) { + if(player == null) + return null; + + if(!(player instanceof MCPlayer)) { + MineTweakerAPI.logError("Invalid player: " + player); + } + + return ((MCPlayer) player).getInternal(); + } + + /** + * Converts a Minecraft NBT to an IData instance. The IData instance is + * immutable (not modifyiable). + * + * @param nbt nbt data + * + * @return IData value + */ + public static IData getIData(NBTBase nbt) { + if(nbt == null) + return null; + + return NBTConverter.from(nbt, true); + } + + /** + * Converts a Minecraft NBT to a modifyable IData instance. + * + * @param nbt nbt data + * + * @return mutable IData value + */ + public static IData getIDataModifyable(NBTBase nbt) { + if(nbt == null) + return null; + + return NBTConverter.from(nbt, false); + } + + /** + * Converts an IData instance to an NBT value. + * + * @param data IData value + * + * @return nbt data + */ + public static NBTBase getNBT(IData data) { + if(data == null) + return null; + + return NBTConverter.from(data); + } + + /** + * Converts an IData instance to an NBT Tag compound. + * + * @param data IData value + * + * @return nbt compound data + */ + public static NBTTagCompound getNBTCompound(IData data) { + if(data == null) + return null; + + return (NBTTagCompound) NBTConverter.from(data); + } + + /** + * Retrieves the block at the given position. + * + * @param blocks block access + * @param x block x position + * @param y block y position + * @param z block z position + * + * @return block instance + */ + public static IBlock getBlock(IBlockAccess blocks, int x, int y, int z) { + return new MCWorldBlock(blocks, x, y, z); + } + + /** + * Retrieves the block definition for the given block. + * + * @param block block object + * + * @return block definition + */ + public static IBlockDefinition getBlockDefinition(Block block) { + if(!blockDefinitions.containsKey(block)) { + blockDefinitions.put(block, new MCBlockDefinition(block)); + } + return blockDefinitions.get(block); + } + + /** + * Retrieves the dimension instance for a given world. + * + * @param world world + * + * @return dimension + */ + public static IDimension getDimension(World world) { + if(world == null) + return null; + + return new MCDimension(world); + } + + /** + * Returns an instance of the given block. + * + * @param block MC block definition + * + * @return MT block instance + */ + public static IBlock getBlockAnyMeta(Block block) { + return new MCSpecificBlock(block, OreDictionary.WILDCARD_VALUE); + } + + /** + * Returns an instance of the given block. + * + * @param block MC block definition + * @param meta block meta value + * + * @return MT block instance + */ + public static IBlock getBlock(Block block, int meta) { + return new MCSpecificBlock(block, meta); + } + + /** + * Retrieves the block from an item stack. + * + * @param itemStack + * + * @return + */ + public static Block getBlock(IItemStack itemStack) { + return ((MCBlockDefinition) itemStack.asBlock().getDefinition()).getInternalBlock(); + } + + public static Block getBlock(IBlock block) { + return ((MCBlockDefinition) block.getDefinition()).getInternalBlock(); + } + + /** + * Retrieves the internal fluid stack of the given stack. + * + * @param stack MT liquid stack + * + * @return MCF fluid stack + */ + public static FluidStack getLiquidStack(ILiquidStack stack) { + if(stack == null) + return null; + + return (FluidStack) stack.getInternal(); + } + + /** + * Converts an array of MT liquid stacks into an array of MCF fluid stacks + */ + public static FluidStack[] getLiquidStacks(ILiquidStack[] stacks) { + if(stacks == null) { + return null; + } + + FluidStack[] res = new FluidStack[stacks.length]; + + for(int i = 0; i < stacks.length; i++) { + ILiquidStack liquidStack = stacks[i]; + res[i] = getLiquidStack(liquidStack); + } + return res; + } + + public static IOreDictEntry getOreDictEntryFromArray(List array) { + if(!oreDictArrays.containsKey(array)) { + for(String ore : OreDictionary.getOreNames()) { + if(OreDictionary.getOres(ore) == array) { + oreDictArrays.put(array, MineTweakerAPI.oreDict.get(ore)); + } + } + } + + return oreDictArrays.get(array); + } + + /** + * Converts a Minecraft ingredient to a MineTweaker ingredient. + * + * @param ingredient minecraft ingredient + * + * @return minetweaker ingredient + */ + public static IIngredient getIIngredient(Object ingredient) { + if(ingredient == null) { + return null; + } else if(ingredient instanceof String) { + return MineTweakerAPI.oreDict.get((String) ingredient); + } else if(ingredient instanceof Item) { + return getIItemStack(new ItemStack((Item) ingredient, 1, 0)); + } else if(ingredient instanceof ItemStack) { + return getIItemStack((ItemStack) ingredient); + } else if(ingredient instanceof List) { + IOreDictEntry entry = getOreDictEntryFromArray((List) ingredient); + + if(entry == null) { + return IngredientUnknown.INSTANCE; + } + + return entry; + } else if(ingredient instanceof FluidStack) { + return new MCLiquidStack((FluidStack) ingredient); + } else { + throw new IllegalArgumentException("Not a valid ingredient: " + ingredient); + } + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/FMLEventHandler.java b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/FMLEventHandler.java new file mode 100644 index 0000000..322de49 --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/FMLEventHandler.java @@ -0,0 +1,74 @@ +package minetweaker.mc1112; + +import minetweaker.*; +import minetweaker.api.event.*; +import minetweaker.api.minecraft.MineTweakerMC; +import minetweaker.api.player.IPlayer; +import minetweaker.api.recipes.*; +import minetweaker.mc1112.item.MCItemStack; +import minetweaker.mc1112.network.MineTweakerLoadScriptsPacket; +import minetweaker.mc1112.player.MCPlayer; +import minetweaker.mc1112.recipes.MCCraftingInventory; +import minetweaker.mc1112.world.MCDimension; +import net.minecraft.entity.player.EntityPlayerMP; +import net.minecraft.inventory.InventoryCrafting; +import net.minecraft.item.crafting.CraftingManager; +import net.minecraftforge.fml.common.eventhandler.SubscribeEvent; +import net.minecraftforge.fml.common.gameevent.PlayerEvent; + +/** + * @author Stan + */ +public class FMLEventHandler { + + @SubscribeEvent + public void onPlayerLoggedIn(PlayerEvent.PlayerLoggedInEvent ev) { + if(ev.player instanceof EntityPlayerMP) { + EntityPlayerMP player = (EntityPlayerMP) ev.player; + MineTweakerMod.NETWORK.sendTo(new MineTweakerLoadScriptsPacket(MineTweakerAPI.tweaker.getScriptData()), player); + } + + MineTweakerImplementationAPI.events.publishPlayerLoggedIn(new PlayerLoggedInEvent(MineTweakerMC.getIPlayer(ev.player))); + } + + @SubscribeEvent + public void onPlayerItemCrafted(PlayerEvent.ItemCraftedEvent ev) { + IPlayer iPlayer = MineTweakerMC.getIPlayer(ev.player); + if(MineTweakerMod.INSTANCE.recipes.hasTransformerRecipes()) { + MineTweakerMod.INSTANCE.recipes.applyTransformations(MCCraftingInventory.get(ev.craftMatrix, ev.player), iPlayer); + } + if(ev.craftMatrix instanceof InventoryCrafting) { + + CraftingManager.getInstance().getRecipeList().stream().filter(i -> i instanceof IMTRecipe && i.getRecipeOutput().isItemEqual(ev.crafting)).forEach(i -> { + IMTRecipe rec = (IMTRecipe) i; + if(rec.getRecipe() instanceof ShapedRecipe) { + ShapedRecipe r = (ShapedRecipe) rec.getRecipe(); + if(r.getAction() != null) { + r.getAction().process(new MCItemStack(ev.crafting), new CraftingInfo(new MCCraftingInventory(ev.craftMatrix, ev.player), new MCDimension(ev.player.world)), new MCPlayer(ev.player)); + } + } else if(rec.getRecipe() instanceof ShapelessRecipe) { + ShapelessRecipe r = (ShapelessRecipe) rec.getRecipe(); + if(r.getAction() != null) { + r.getAction().process(new MCItemStack(ev.crafting), new CraftingInfo(new MCCraftingInventory(ev.craftMatrix, ev.player), new MCDimension(ev.player.world)), new MCPlayer(ev.player)); + } + } + }); + } + if(MineTweakerImplementationAPI.events.hasPlayerCrafted()) { + MineTweakerImplementationAPI.events.publishPlayerCrafted(new PlayerCraftedEvent(iPlayer, MineTweakerMC.getIItemStack(ev.crafting), MCCraftingInventory.get(ev.craftMatrix, ev.player))); + } + } + + @SubscribeEvent + public void onPlayerItemSmelted(PlayerEvent.ItemSmeltedEvent ev) { + if(MineTweakerImplementationAPI.events.hasPlayerSmelted()) { + MineTweakerImplementationAPI.events.publishPlayerSmelted(new PlayerSmeltedEvent(MineTweakerMC.getIPlayer(ev.player), MineTweakerMC.getIItemStack(ev.smelting))); + } + } + + @SubscribeEvent + public void onPlayerLoggedOut(PlayerEvent.PlayerLoggedOutEvent ev) { + MineTweakerImplementationAPI.events.publishPlayerLoggedOut(new PlayerLoggedOutEvent(MineTweakerMC.getIPlayer(ev.player))); + } + +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/ForgeEventHandler.java b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/ForgeEventHandler.java new file mode 100644 index 0000000..d76e692 --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/ForgeEventHandler.java @@ -0,0 +1,94 @@ +package minetweaker.mc1112; + +import minetweaker.*; +import minetweaker.api.entity.IEntityDefinition; +import minetweaker.api.formatting.IFormattedText; +import minetweaker.api.item.IItemStack; +import minetweaker.api.minecraft.MineTweakerMC; +import minetweaker.api.tooltip.IngredientTooltips; +import minetweaker.mc1112.formatting.IMCFormattedString; +import minetweaker.mc1112.item.MCItemStack; +import net.minecraft.entity.*; +import net.minecraft.entity.item.EntityItem; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import net.minecraftforge.event.entity.living.LivingDropsEvent; +import net.minecraftforge.event.entity.player.*; +import net.minecraftforge.fml.common.eventhandler.SubscribeEvent; +import org.lwjgl.input.Keyboard; + +import java.util.*; + +/** + * @author Stan + */ +public class ForgeEventHandler { + + @SubscribeEvent + public void onPlayerInteract(PlayerInteractEvent ev) { + minetweaker.api.event.PlayerInteractEvent event = new minetweaker.api.event.PlayerInteractEvent(MineTweakerMC.getIPlayer(ev.getEntityPlayer()), MineTweakerMC.getDimension(ev.getWorld()), ev.getPos() == null ? 0 : ev.getPos().getX(), ev.getPos() == null ? 0 : ev.getPos().getY(), ev.getPos() == null ? 0 : ev.getPos().getZ()); + MineTweakerImplementationAPI.events.publishPlayerInteract(event); + } + + @SubscribeEvent + public void onItemTooltip(ItemTooltipEvent ev) { + if(ev.getItemStack() != null) { + IItemStack itemStack = MineTweakerMC.getIItemStack(ev.getItemStack()); + for(IFormattedText tooltip : IngredientTooltips.getTooltips(itemStack)) { + ev.getToolTip().add(((IMCFormattedString) tooltip).getTooltipString()); + } + if(!Keyboard.isCreated()) { + return; + } + if(Keyboard.isKeyDown(Keyboard.KEY_LSHIFT) || Keyboard.isKeyDown(Keyboard.KEY_RSHIFT)) { + for(IFormattedText tooltip : IngredientTooltips.getShiftTooltips(itemStack)) { + ev.getToolTip().add(((IMCFormattedString) tooltip).getTooltipString()); + } + } + } + } + + @SubscribeEvent + public void mobDrop(LivingDropsEvent ev) { + Entity entity = ev.getEntity(); + IEntityDefinition entityDefinition = MineTweakerAPI.game.getEntity(EntityList.getEntityString(ev.getEntity())); + if(entityDefinition != null) { + if(!entityDefinition.getDropsToAdd().isEmpty()) { + entityDefinition.getDropsToAdd().forEach((key, val) -> { + EntityItem item = null; + if(val.getMin() == 0 && val.getMax() == 0) { + item = new EntityItem(entity.world, entity.posX + 0.5, entity.posY + 0.5, entity.posZ + 0.5, ((ItemStack) key.getInternal()).copy()); + } else { + item = new EntityItem(entity.world, entity.posX + 0.5, entity.posY + 0.5, entity.posZ + 0.5, ((ItemStack) key.withAmount(val.getRandom()).getInternal()).copy()); + } + ev.getDrops().add(item); + }); + } + if(ev.getSource().getEntity() instanceof EntityPlayer) { + if(!entityDefinition.getDropsToAddPlayerOnly().isEmpty()) { + entityDefinition.getDropsToAddPlayerOnly().forEach((key, val) -> { + EntityItem item = null; + if(val.getMin() == 0 && val.getMax() == 0) { + item = new EntityItem(entity.world, entity.posX + 0.5, entity.posY + 0.5, entity.posZ + 0.5, ((ItemStack) key.getInternal()).copy()); + } else { + item = new EntityItem(entity.world, entity.posX + 0.5, entity.posY + 0.5, entity.posZ + 0.5, ((ItemStack) key.withAmount(val.getRandom()).getInternal()).copy()); + } + ev.getDrops().add(item); + }); + } + } + if(!entityDefinition.getDropsToRemove().isEmpty()) { + List removedDrops = new ArrayList<>(); + entityDefinition.getDropsToRemove().forEach(drop -> { + // if(drop.matches(new MCItemStack())) + ev.getDrops().forEach(drops -> { + if(drop.matches(new MCItemStack(drops.getEntityItem()))) { + removedDrops.add(drops); + } + }); + }); + ev.getDrops().removeAll(removedDrops); + } + } + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/GuiCannotRemodify.java b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/GuiCannotRemodify.java new file mode 100644 index 0000000..fe47942 --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/GuiCannotRemodify.java @@ -0,0 +1,46 @@ +package minetweaker.mc1112; + +import net.minecraft.client.gui.*; + +/** + * This screen is shown when a client has been modified with a permanent + * modification and the player logs into a game with a different script. It asks + * the player to restart the game. + * + * @author Stan Hebben + */ +public class GuiCannotRemodify extends GuiScreen { + + private final String message1; + private final String message2; + private final String message3; + + public GuiCannotRemodify(String message1, String message2, String message3) { + this.message1 = message1; + this.message2 = message2; + this.message3 = message3; + } + + @Override + public void initGui() { + this.buttonList.clear(); + this.buttonList.add(new GuiButton(0, this.width / 2 - 100, this.height / 4 + 120 + 12, "Close")); + } + + @Override + public void drawScreen(int par1, int par2, float par3) { + this.drawDefaultBackground(); + this.drawCenteredString(this.fontRendererObj, message1, this.width / 2, this.height / 2 - 40, 11184810); + this.drawCenteredString(this.fontRendererObj, message2, this.width / 2, this.height / 2 - 20, 11184810); + this.drawCenteredString(this.fontRendererObj, message3, this.width / 2, this.height / 2, 11184810); + + super.drawScreen(par1, par2, par3); + } + + @Override + protected void actionPerformed(GuiButton par1GuiButton) { + if(par1GuiButton.id == 0) { + System.exit(0); + } + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/MCPlatformFunctions.java b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/MCPlatformFunctions.java new file mode 100644 index 0000000..0f2160d --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/MCPlatformFunctions.java @@ -0,0 +1,43 @@ +package minetweaker.mc1112; + +import minetweaker.IPlatformFunctions; +import minetweaker.api.chat.IChatMessage; +import minetweaker.api.item.IItemDefinition; +import minetweaker.mc1112.chat.MCChatMessage; +import minetweaker.mc1112.item.MCItemDefinition; +import minetweaker.mc1112.network.MineTweakerLoadScriptsPacket; +import net.minecraft.item.Item; +import net.minecraft.util.ResourceLocation; + +import static minetweaker.mc1112.MineTweakerMod.NETWORK; + +/** + * @author Stan + */ +public class MCPlatformFunctions implements IPlatformFunctions { + + public static final MCPlatformFunctions INSTANCE = new MCPlatformFunctions(); + + private MCPlatformFunctions() { + } + + @Override + public IChatMessage getMessage(String message) { + return new MCChatMessage(message); + } + + @Override + public void distributeScripts(byte[] data) { + NETWORK.sendToAll(new MineTweakerLoadScriptsPacket(data)); + } + + @Override + public IItemDefinition getItemDefinition(int id) { + Item item = Item.getItemById(id); + if(item == null) + return null; + ResourceLocation res = Item.REGISTRY.getNameForObject(item); + String sid = res.getResourceDomain() + ":" + res.getResourcePath(); + return new MCItemDefinition(sid, item); + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/MineTweakerMod.java b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/MineTweakerMod.java new file mode 100644 index 0000000..ebfa92b --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/MineTweakerMod.java @@ -0,0 +1,195 @@ +package minetweaker.mc1112; + +import minetweaker.*; +import minetweaker.annotations.BracketHandler; +import minetweaker.api.item.IItemStack; +import minetweaker.api.minecraft.MineTweakerMC; +import minetweaker.mc1112.brackets.*; +import minetweaker.mc1112.client.MCClient; +import minetweaker.mc1112.formatting.MCFormatter; +import minetweaker.mc1112.furnace.*; +import minetweaker.mc1112.game.MCGame; +import minetweaker.mc1112.logger.MCLogger; +import minetweaker.mc1112.mods.MCLoadedMods; +import minetweaker.mc1112.network.*; +import minetweaker.mc1112.oredict.MCOreDict; +import minetweaker.mc1112.recipes.MCRecipeManager; +import minetweaker.mc1112.server.MCServer; +import minetweaker.mc1112.util.*; +import minetweaker.mc1112.vanilla.MCVanilla; +import minetweaker.runtime.*; +import minetweaker.runtime.providers.*; +import net.minecraft.item.crafting.*; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.server.MinecraftServer; +import net.minecraftforge.common.MinecraftForge; +import net.minecraftforge.fml.common.*; +import net.minecraftforge.fml.common.Mod.EventHandler; +import net.minecraftforge.fml.common.event.*; +import net.minecraftforge.fml.common.network.NetworkRegistry; +import net.minecraftforge.fml.common.network.simpleimpl.SimpleNetworkWrapper; +import net.minecraftforge.fml.relauncher.Side; +import stanhebben.zenscript.annotations.*; + +import java.io.File; +import java.util.*; + +/** + * Main mod class. Performs some general logic, initialization of the API and + * FML event handling. + * + * @author Stan Hebben + */ +@Mod(modid = MineTweakerMod.MODID, version = "3.1.0", name = MineTweakerMod.NAME, dependencies = "after:jei@[4.5.0.287,)") +public class MineTweakerMod { + + public static final String MODID = "crafttweaker"; + public static final String NAME = "Crafttweaker"; + public static final String MCVERSION = "1.11.2"; + + public static final SimpleNetworkWrapper NETWORK = NetworkRegistry.INSTANCE.newSimpleChannel(MODID); + + private static final String[] REGISTRIES = {"minetweaker.mods.jei.ClassRegistry"}; + private static final String[] REGISTRY_DESCRIPTIONS = {"JEI mod support"}; + public static MinecraftServer server; + @Mod.Instance(MODID) + public static MineTweakerMod INSTANCE; + + static { + NETWORK.registerMessage(MineTweakerLoadScriptsHandler.class, MineTweakerLoadScriptsPacket.class, 0, Side.CLIENT); + NETWORK.registerMessage(MineTweakerOpenBrowserHandler.class, MineTweakerOpenBrowserPacket.class, 1, Side.CLIENT); + NETWORK.registerMessage(MineTweakerCopyClipboardHandler.class, MineTweakerCopyClipboardPacket.class, 2, Side.CLIENT); + } + + public final MCRecipeManager recipes; + private final IScriptProvider scriptsGlobal; + private final ScriptProviderCustom scriptsIMC; + + public MineTweakerMod() { + MineTweakerImplementationAPI.init(new MCOreDict(), recipes = new MCRecipeManager(), new MCFurnaceManager(), MCGame.INSTANCE, new MCLoadedMods(), new MCFormatter(), new MCVanilla()); + MineTweakerImplementationAPI.logger.addLogger(new MCLogger(new File("minetweaker.log"))); + MineTweakerImplementationAPI.platform = MCPlatformFunctions.INSTANCE; + File globalDir = new File("scripts"); + if(!globalDir.exists()) + globalDir.mkdirs(); + scriptsIMC = new ScriptProviderCustom("intermod"); + scriptsGlobal = new ScriptProviderDirectory(globalDir); + MineTweakerImplementationAPI.setScriptProvider(scriptsGlobal); + } + + // ########################## + // ### FML Event Handlers ### + // ########################## + + @EventHandler + public void onIMCEvent(FMLInterModComms.IMCEvent event) { + event.getMessages().stream().filter(imcMessage -> imcMessage.key.equalsIgnoreCase("addMineTweakerScript")).forEach(imcMessage -> { + if(imcMessage.isStringMessage()) { + scriptsIMC.add(imcMessage.getSender() + "::imc", imcMessage.getStringValue()); + } else if(imcMessage.isNBTMessage()) { + NBTTagCompound message = imcMessage.getNBTValue(); + scriptsIMC.add(imcMessage.getSender() + "::" + message.getString("name"), message.getString("content")); + } + }); + } + + @EventHandler + public void onLoad(FMLPreInitializationEvent ev) { + MinecraftForge.EVENT_BUS.register(new ForgeEventHandler()); + MinecraftForge.EVENT_BUS.register(new FMLEventHandler()); + // List apiClasses = new ArrayList<>(); + // String[] classNames = new String[]{ZenExpansion.class.getCanonicalName(), ZenClass.class.getCanonicalName(), BracketHandler.class.getCanonicalName()}; + // for(String name : classNames) { + // ev.getAsmData().getAll(name).forEach(clazz -> { + // boolean valid = true; + // try { + // for(ModContainer mod : clazz.getCandidate().getContainedMods()) { + // if(!mod.getName().equals("MineTweaker 3") || !mod.getName().equals("CT-GUI")) { + // valid = false; + // } + // } + // if(valid) { + // Class asmClass = Class.forName(clazz.getClassName()); + // apiClasses.add(asmClass); + // } + // } catch(ClassNotFoundException e) { + // e.printStackTrace(); + // } + // }); + // } + // apiClasses.forEach(i -> { + // MineTweakerAPI.registerClass(i); + // }); + } + + @EventHandler + public void onPostInit(FMLPostInitializationEvent ev) { + MineTweakerAPI.registerClassRegistry(MineTweakerRegistry.class); + + for(int i = 0; i < REGISTRIES.length; i++) { + MineTweakerAPI.registerClassRegistry(REGISTRIES[i], REGISTRY_DESCRIPTIONS[i]); + } + FuelTweaker.INSTANCE.register(); + } + + @EventHandler + public void onComplete(FMLLoadCompleteEvent ev) { + MineTweakerAPI.logInfo("MineTweaker: Building registry"); + ItemBracketHandler.rebuildItemRegistry(); + LiquidBracketHandler.rebuildLiquidRegistry(); + EntityBracketHandler.rebuildEntityRegistry(); + MineTweakerAPI.logInfo("MineTweaker: Sucessfully built item registry"); + GlobalRegistry.registerBracketHandler(new ItemBracketHandler()); + GlobalRegistry.registerBracketHandler(new LiquidBracketHandler()); + GlobalRegistry.registerBracketHandler(new OreBracketHandler()); + GlobalRegistry.registerBracketHandler(new EntityBracketHandler()); + } + + @EventHandler + public void onServerAboutToStart(FMLServerAboutToStartEvent ev) { + server = ev.getServer(); + + } + + @EventHandler + public void onServerStarting(FMLServerStartingEvent ev) { + server = ev.getServer(); + // starts before loading worlds + // perfect place to start MineTweaker! + MineTweakerImplementationAPI.addMineTweakerCommand("itemrecipes", new String[]{"Logs items that have a crafting table recipe"}, (arguments, player) -> { + List stacks = new ArrayList<>(); + for(IRecipe recipe : CraftingManager.getInstance().getRecipeList()) { + stacks.add(MineTweakerMC.getIItemStack(recipe.getRecipeOutput())); + } + for(IItemStack stack : stacks) { + if(stack != null) + MineTweakerAPI.logCommand(stack.toString()); + } + player.sendChat("Recipe list generated; see minetweaker.log in your minecraft dir"); + + }); + if(MineTweakerPlatformUtils.isClient()) { + MineTweakerAPI.client = new MCClient(); + } + + File scriptsDir = new File(MineTweakerHacks.getWorldDirectory(ev.getServer()), "scripts"); + if(!scriptsDir.exists()) { + scriptsDir.mkdir(); + } + + IScriptProvider scriptsLocal = new ScriptProviderDirectory(scriptsDir); + IScriptProvider cascaded = new ScriptProviderCascade(scriptsIMC, scriptsGlobal, scriptsLocal); + + MineTweakerImplementationAPI.setScriptProvider(cascaded); + MineTweakerImplementationAPI.onServerStart(new MCServer(ev.getServer())); + } + + @EventHandler + public void onServerStopped(FMLServerStoppedEvent ev) { + MineTweakerImplementationAPI.onServerStop(); + MineTweakerImplementationAPI.setScriptProvider(scriptsGlobal); + MineTweakerAPI.logInfo("Server stopping, Scripts are being rolled back!"); +// MineTweakerAPI.tweaker.rollback(); + server = null; + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/MineTweakerRegistry.java b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/MineTweakerRegistry.java new file mode 100644 index 0000000..66d05c9 --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/MineTweakerRegistry.java @@ -0,0 +1,13 @@ +package minetweaker.mc1112; + +import java.util.List; + +/** + * @author Stan + */ +public class MineTweakerRegistry { + + public static void getClasses(List classes) { + // method stub, actual content is generated by build process + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/actions/SetBlockHardnessAction.java b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/actions/SetBlockHardnessAction.java new file mode 100644 index 0000000..a1adc77 --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/actions/SetBlockHardnessAction.java @@ -0,0 +1,79 @@ +package minetweaker.mc1112.actions; + +import minetweaker.*; +import net.minecraft.block.Block; +import net.minecraft.item.ItemStack; +import net.minecraft.util.ResourceLocation; + +/** + * @author Jared + */ +public class SetBlockHardnessAction implements IUndoableAction { + + private final ItemStack stack; + private final float hardness; + private final float oldHardness; + + public SetBlockHardnessAction(ItemStack stack, float hardness) { + this.stack = stack; + this.hardness = hardness; + this.oldHardness = Block.getBlockFromItem(stack.getItem()).getBlockHardness(null, null, null); + } + + private static void set(ItemStack stack, float hardness) { + if(isBlock(stack)) { + Block block = Block.getBlockFromItem(stack.getItem()); + block.setHardness(hardness); + } else { + MineTweakerAPI.logError("Item is not a block"); + } + } + + public static boolean isBlock(ItemStack stack) { + if(stack.isEmpty()) { + return false; + } + ResourceLocation name = Block.REGISTRY.getNameForObject(Block.getBlockFromItem(stack.getItem())); + return !name.toString().equals("minecraft:air") && Block.REGISTRY.containsKey(name); + + } + + @Override + public void apply() { + if(isBlock(stack)) { + set(stack, hardness); + } + } + + @Override + public boolean canUndo() { + return true; + } + + @Override + public void undo() { + if(isBlock(stack)) + set(stack, oldHardness); + } + + @Override + public String describe() { + if(isBlock(stack)) { + return "Setting hardness of " + stack.getDisplayName() + " to " + hardness; + } + return "Unable to set hardness of " + stack.getDisplayName() + " because it is an Item"; + } + + @Override + public String describeUndo() { + if(isBlock(stack)) { + return "Reverting hardness of " + stack.getDisplayName() + " to " + oldHardness; + } + return "Unable to revert hardness of " + stack.getDisplayName() + " because it is an Item"; + } + + @Override + public Object getOverrideKey() { + return null; + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/actions/SetStackSizeAction.java b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/actions/SetStackSizeAction.java new file mode 100644 index 0000000..b0072a8 --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/actions/SetStackSizeAction.java @@ -0,0 +1,55 @@ +package minetweaker.mc1112.actions; + +import minetweaker.IUndoableAction; +import net.minecraft.item.ItemStack; + +/** + * @author Jared + */ +public class SetStackSizeAction implements IUndoableAction { + + private final ItemStack stack; + private final int size; + private final int oldSize; + + public SetStackSizeAction(ItemStack stack, int size) { + this.stack = stack; + this.size = size; + this.oldSize = stack.getMaxStackSize(); + } + + private static void set(ItemStack stack, int size) { + if(!stack.isEmpty()) + stack.getItem().setMaxStackSize(size); + } + + @Override + public void apply() { + set(stack, size); + } + + @Override + public boolean canUndo() { + return true; + } + + @Override + public void undo() { + set(stack, oldSize); + } + + @Override + public String describe() { + return "Setting max stack size of " + stack.getDisplayName() + " to " + size; + } + + @Override + public String describeUndo() { + return "Reverting max stack size of " + stack.getDisplayName() + " to " + oldSize; + } + + @Override + public Object getOverrideKey() { + return null; + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/actions/SetStackmaxDamageAction.java b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/actions/SetStackmaxDamageAction.java new file mode 100644 index 0000000..e03f80c --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/actions/SetStackmaxDamageAction.java @@ -0,0 +1,55 @@ +package minetweaker.mc1112.actions; + +import minetweaker.IUndoableAction; +import net.minecraft.item.ItemStack; + +/** + * @author Jared + */ +public class SetStackmaxDamageAction implements IUndoableAction { + + private final ItemStack stack; + private final int damage; + private final int oldDamage; + + public SetStackmaxDamageAction(ItemStack stack, int damage) { + this.stack = stack; + this.damage = damage; + this.oldDamage = stack.getMaxDamage(); + } + + private static void set(ItemStack stack, int damage) { + if(!stack.isEmpty()) + stack.getItem().setMaxDamage(damage); + } + + @Override + public void apply() { + set(stack, damage); + } + + @Override + public boolean canUndo() { + return true; + } + + @Override + public void undo() { + set(stack, oldDamage); + } + + @Override + public String describe() { + return "Setting max damage of " + stack.getDisplayName() + " to " + damage; + } + + @Override + public String describeUndo() { + return "Reverting max damage of " + stack.getDisplayName() + " to " + oldDamage; + } + + @Override + public Object getOverrideKey() { + return null; + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/actions/SetTranslationAction.java b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/actions/SetTranslationAction.java new file mode 100644 index 0000000..854263b --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/actions/SetTranslationAction.java @@ -0,0 +1,70 @@ +package minetweaker.mc1112.actions; + +import minetweaker.IUndoableAction; +import minetweaker.MineTweakerAPI; +import minetweaker.api.item.IItemStack; +import minetweaker.mc1112.util.MineTweakerHacks; +import net.minecraft.util.text.translation.LanguageMap; + +import java.io.ByteArrayInputStream; +import java.nio.charset.Charset; + +/** + * @author Stan + */ +public class SetTranslationAction implements IUndoableAction { + + private static final LanguageMap INSTANCE = MineTweakerHacks.getStringTranslateInstance(); + private static final Charset UTF8 = Charset.forName("utf-8"); + + private final IItemStack stack; + private final String key; + private final String newValue; + private final String oldValue; + + public SetTranslationAction(IItemStack stack, String key, String value) { + this.stack = stack; + this.key = key; + newValue = value; + oldValue = INSTANCE.translateKey(key); + } + + private static void set(IItemStack stack, String key, String value) { + if(value.contains("\\\"")) { + value = value.replace("\\\"", "\""); + } + MineTweakerAPI.getIjeiRecipeRegistry().removeItem(stack.getInternal()); + LanguageMap.inject(new ByteArrayInputStream((key + "=" + value).getBytes(UTF8))); + MineTweakerAPI.getIjeiRecipeRegistry().addItem(stack.getInternal()); + } + + @Override + public void apply() { + set(stack, key, newValue); + } + + @Override + public boolean canUndo() { + return true; + } + + @Override + public void undo() { + set(stack, key, oldValue); + } + + @Override + public String describe() { + return "Translating " + key + " to " + newValue; + } + + @Override + public String describeUndo() { + return "Reverting " + key + " to " + oldValue; + } + + @Override + public Object getOverrideKey() { + return null; + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/block/MCBlockDefinition.java b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/block/MCBlockDefinition.java new file mode 100644 index 0000000..3657cd0 --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/block/MCBlockDefinition.java @@ -0,0 +1,30 @@ +package minetweaker.mc1112.block; + +import minetweaker.api.block.IBlockDefinition; +import net.minecraft.block.Block; + +/** + * @author Stan + */ +public class MCBlockDefinition implements IBlockDefinition { + + private final Block block; + + public MCBlockDefinition(Block block) { + this.block = block; + } + + public Block getInternalBlock() { + return block; + } + + @Override + public String getId() { + return Block.REGISTRY.getNameForObject(block).toString(); + } + + @Override + public String getDisplayName() { + return block.getLocalizedName(); + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/block/MCItemBlock.java b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/block/MCItemBlock.java new file mode 100644 index 0000000..2339088 --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/block/MCItemBlock.java @@ -0,0 +1,63 @@ +package minetweaker.mc1112.block; + +import minetweaker.api.block.*; +import minetweaker.api.data.IData; +import minetweaker.api.minecraft.MineTweakerMC; +import net.minecraft.block.Block; +import net.minecraft.item.ItemStack; +import net.minecraftforge.oredict.OreDictionary; + +import java.util.*; + +/** + * @author Stan + */ +public class MCItemBlock implements IBlock { + + private final ItemStack item; + + public MCItemBlock(ItemStack item) { + this.item = item; + } + + @Override + public IBlockDefinition getDefinition() { + return MineTweakerMC.getBlockDefinition(Block.getBlockFromItem(item.getItem())); + } + + @Override + public int getMeta() { + return item.getItemDamage(); + } + + @Override + public IData getTileData() { + if(!item.isEmpty()) { + return null; + } + if(item.getTagCompound() == null) + return null; + + return MineTweakerMC.getIData(item.getTagCompound()); + } + + @Override + public String getDisplayName() { + return item.getDisplayName(); + } + + @Override + public List getBlocks() { + return Collections.singletonList(this); + } + + @Override + public boolean matches(IBlock block) { + return getDefinition() == block.getDefinition() && (getMeta() == OreDictionary.WILDCARD_VALUE || getMeta() == block.getMeta()) && (getTileData() == null || (block.getTileData() != null && block.getTileData().contains(getTileData()))); + } + + @Override + public IBlockPattern or(IBlockPattern pattern) { + return new BlockPatternOr(this, pattern); + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/block/MCSpecificBlock.java b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/block/MCSpecificBlock.java new file mode 100644 index 0000000..d9ef6d3 --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/block/MCSpecificBlock.java @@ -0,0 +1,67 @@ +package minetweaker.mc1112.block; + +import minetweaker.api.block.*; +import minetweaker.api.data.IData; +import minetweaker.api.minecraft.MineTweakerMC; +import net.minecraft.block.Block; +import net.minecraftforge.oredict.OreDictionary; + +import java.util.*; + +/** + * @author Stan + */ +public class MCSpecificBlock implements IBlock { + + private final Block block; + private final int meta; + + public MCSpecificBlock(Block block, int meta) { + this.block = block; + this.meta = meta; + } + + private static String getBlockId(Block block) { + return Block.REGISTRY.getNameForObject(block).toString(); + } + + @Override + public IBlockDefinition getDefinition() { + return MineTweakerMC.getBlockDefinition(block); + } + + @Override + public int getMeta() { + return meta; + } + + @Override + public IData getTileData() { + return null; + } + + @Override + public List getBlocks() { + return Collections.singletonList(this); + } + + @Override + public boolean matches(IBlock block) { + return block.getDefinition() == getDefinition() && (meta == OreDictionary.WILDCARD_VALUE || block.getMeta() == meta); + } + + @Override + public IBlockPattern or(IBlockPattern pattern) { + return new BlockPatternOr(this, pattern); + } + + @Override + public String getDisplayName() { + return block.getLocalizedName(); + } + + @Override + public String toString() { + return ""; + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/block/MCWorldBlock.java b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/block/MCWorldBlock.java new file mode 100644 index 0000000..e1098a9 --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/block/MCWorldBlock.java @@ -0,0 +1,82 @@ +package minetweaker.mc1112.block; + +import minetweaker.api.block.*; +import minetweaker.api.data.IData; +import minetweaker.api.minecraft.MineTweakerMC; +import net.minecraft.block.Block; +import net.minecraft.item.*; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.math.BlockPos; +import net.minecraft.world.IBlockAccess; +import net.minecraftforge.oredict.OreDictionary; + +import java.util.*; + +/** + * @author Stan + */ +public class MCWorldBlock implements IBlock { + + private final IBlockAccess blocks; + private final int x; + private final int y; + private final int z; + private final BlockPos pos; + + public MCWorldBlock(IBlockAccess blocks, int x, int y, int z) { + this.blocks = blocks; + this.x = x; + this.y = y; + this.z = z; + this.pos = new BlockPos(x, y, z); + } + + @Override + public IBlockDefinition getDefinition() { + return MineTweakerMC.getBlockDefinition(blocks.getBlockState(pos).getBlock()); + } + + @Override + public int getMeta() { + return blocks.getBlockState(pos).getBlock().getMetaFromState(blocks.getBlockState(pos)); + } + + @Override + public IData getTileData() { + TileEntity tileEntity = blocks.getTileEntity(pos); + + if(tileEntity == null) + return null; + + NBTTagCompound nbt = new NBTTagCompound(); + tileEntity.writeToNBT(nbt); + return MineTweakerMC.getIData(nbt); + } + + @Override + public String getDisplayName() { + Block block = blocks.getBlockState(pos).getBlock(); + Item item = Item.getItemFromBlock(block); + if(item != null) { + return (new ItemStack(item, 1, getMeta())).getDisplayName(); + } else { + return block.getLocalizedName(); + } + } + + @Override + public List getBlocks() { + return Collections.singletonList(this); + } + + @Override + public boolean matches(IBlock block) { + return getDefinition() == block.getDefinition() && (getMeta() == OreDictionary.WILDCARD_VALUE || getMeta() == block.getMeta()) && (getTileData() == null || (block.getTileData() != null && block.getTileData().contains(getTileData()))); + } + + @Override + public IBlockPattern or(IBlockPattern pattern) { + return new BlockPatternOr(this, pattern); + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/brackets/EntityBracketHandler.java b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/brackets/EntityBracketHandler.java new file mode 100644 index 0000000..db6221b --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/brackets/EntityBracketHandler.java @@ -0,0 +1,77 @@ +package minetweaker.mc1112.brackets; + +import minetweaker.*; +import minetweaker.annotations.BracketHandler; +import minetweaker.api.entity.IEntityDefinition; +import stanhebben.zenscript.compiler.IEnvironmentGlobal; +import stanhebben.zenscript.expression.*; +import stanhebben.zenscript.expression.partial.IPartialExpression; +import stanhebben.zenscript.parser.Token; +import stanhebben.zenscript.symbols.IZenSymbol; +import stanhebben.zenscript.type.natives.IJavaMethod; +import stanhebben.zenscript.util.ZenPosition; + +import java.util.*; + +/** + * @author Jared + */ +@BracketHandler(priority = 100) +public class EntityBracketHandler implements IBracketHandler { + + private static final Map entityNames = new HashMap<>(); + private final IJavaMethod method; + + public EntityBracketHandler() { + method = MineTweakerAPI.getJavaMethod(EntityBracketHandler.class, "getEntity", String.class); + } + + @SuppressWarnings("unchecked") + public static void rebuildEntityRegistry() { + entityNames.clear(); + MineTweakerAPI.game.getEntities().forEach(ent -> { + entityNames.put(ent.getName().toLowerCase(), ent); + }); + } + + public static IEntityDefinition getEntity(String name) { + return entityNames.get(name.toLowerCase()); + } + + @Override + public IZenSymbol resolve(IEnvironmentGlobal environment, List tokens) { + if(tokens.size() > 2) { + if(tokens.get(0).getValue().equals("entity") && tokens.get(1).getValue().equals(":")) { + return find(environment, tokens, 2, tokens.size()); + } + } + + return null; + } + + private IZenSymbol find(IEnvironmentGlobal environment, List tokens, int startIndex, int endIndex) { + StringBuilder valueBuilder = new StringBuilder(); + for(int i = startIndex; i < endIndex; i++) { + Token token = tokens.get(i); + valueBuilder.append(token.getValue()); + } + + return new EntityReferenceSymbol(environment, valueBuilder.toString()); + } + + private class EntityReferenceSymbol implements IZenSymbol { + + private final IEnvironmentGlobal environment; + private final String name; + + public EntityReferenceSymbol(IEnvironmentGlobal environment, String name) { + this.environment = environment; + this.name = name; + } + + @Override + public IPartialExpression instance(ZenPosition position) { + return new ExpressionCallStatic(position, environment, method, new ExpressionString(position, name)); + } + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/brackets/ItemBracketHandler.java b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/brackets/ItemBracketHandler.java new file mode 100644 index 0000000..d2a37fc --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/brackets/ItemBracketHandler.java @@ -0,0 +1,138 @@ +package minetweaker.mc1112.brackets; + +import minetweaker.*; +import minetweaker.annotations.BracketHandler; +import minetweaker.api.item.*; +import net.minecraft.block.Block; +import net.minecraft.item.*; +import net.minecraft.util.ResourceLocation; +import net.minecraftforge.oredict.OreDictionary; +import stanhebben.zenscript.ZenTokener; +import stanhebben.zenscript.compiler.IEnvironmentGlobal; +import stanhebben.zenscript.expression.*; +import stanhebben.zenscript.expression.partial.IPartialExpression; +import stanhebben.zenscript.parser.Token; +import stanhebben.zenscript.symbols.IZenSymbol; +import stanhebben.zenscript.type.ZenType; +import stanhebben.zenscript.type.natives.IJavaMethod; +import stanhebben.zenscript.util.ZenPosition; + +import java.util.*; + +import static minetweaker.api.minecraft.MineTweakerMC.getIItemStackWildcardSize; + +/** + * @author Stan + */ +@BracketHandler(priority = 100) +public class ItemBracketHandler implements IBracketHandler { + + private static final Map itemNames = new HashMap<>(); + private static final Map blockNames = new HashMap<>(); + + private final IZenSymbol symbolAny; + private final IJavaMethod method; + + public ItemBracketHandler() { + symbolAny = MineTweakerAPI.getJavaStaticFieldSymbol(IngredientAny.class, "INSTANCE"); + method = MineTweakerAPI.getJavaMethod(ItemBracketHandler.class, "getItem", String.class, int.class); + } + + public static Map getItemNames() { + return itemNames; + } + + public static Map getBlockNames() { + return blockNames; + } + + @SuppressWarnings("unchecked") + public static void rebuildItemRegistry() { + itemNames.clear(); + blockNames.clear(); + for(ResourceLocation itemName : Item.REGISTRY.getKeys()) { + String domain = itemName.toString().replace(" ", "").replace("'", ""); + itemNames.put(domain, Item.REGISTRY.getObject(itemName)); + } + for(ResourceLocation blockName : Block.REGISTRY.getKeys()) { + String domain = blockName.toString().replace(" ", "").replace("'", ""); + blockNames.put(domain, Block.REGISTRY.getObject(blockName)); + } + } + + public static IItemStack getItem(String name, int meta) { + // Item item = (Item) Item.itemRegistry.getObject(name); + Item item = itemNames.get(name); + if(item != null) { + return getIItemStackWildcardSize(item, meta); + } else if(blockNames.containsKey(name)) { + return getIItemStackWildcardSize(new ItemStack(blockNames.get(name), 1, meta)); + } else { + return null; + } + } + + @Override + public IZenSymbol resolve(IEnvironmentGlobal environment, List tokens) { + // any symbol + if(tokens.size() == 1 && tokens.get(0).getValue().equals("*")) { + return symbolAny; + } + + // detect special cases: + // item: at the start means item-specific syntax + // :xxx with xxx an integer means sub-item syntax + // :* means any-subitem-syntax + int fromIndex = 0; + int toIndex = tokens.size(); + int meta = 0; + + if(tokens.size() > 2) { + if(tokens.get(0).getValue().equals("item") && tokens.get(1).getValue().equals(":")) { + fromIndex = 2; + } + if(tokens.get(tokens.size() - 1).getType() == ZenTokener.T_INTVALUE && tokens.get(tokens.size() - 2).getValue().equals(":")) { + toIndex = tokens.size() - 2; + meta = Integer.parseInt(tokens.get(tokens.size() - 1).getValue()); + } else if(tokens.get(tokens.size() - 1).getValue().equals("*") && tokens.get(tokens.size() - 2).getValue().equals(":")) { + toIndex = tokens.size() - 2; + meta = OreDictionary.WILDCARD_VALUE; + } + } + + return find(environment, tokens, fromIndex, toIndex, meta); + } + + private IZenSymbol find(IEnvironmentGlobal environment, List tokens, int startIndex, int endIndex, int meta) { + StringBuilder valueBuilder = new StringBuilder(); + for(int i = startIndex; i < endIndex; i++) { + Token token = tokens.get(i); + valueBuilder.append(token.getValue()); + } + + String itemName = valueBuilder.toString(); + if(itemNames.containsKey(itemName) || blockNames.containsKey(itemName)) { + return new ItemReferenceSymbol(environment, itemName, meta); + } + + return null; + } + + private class ItemReferenceSymbol implements IZenSymbol { + + private final IEnvironmentGlobal environment; + private final String name; + private final int meta; + + public ItemReferenceSymbol(IEnvironmentGlobal environment, String name, int meta) { + this.environment = environment; + this.name = name; + this.meta = meta; + } + + @Override + public IPartialExpression instance(ZenPosition position) { + return new ExpressionCallStatic(position, environment, method, new ExpressionString(position, name), new ExpressionInt(position, meta, ZenType.INT)); + } + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/brackets/LiquidBracketHandler.java b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/brackets/LiquidBracketHandler.java new file mode 100644 index 0000000..82096a8 --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/brackets/LiquidBracketHandler.java @@ -0,0 +1,87 @@ +package minetweaker.mc1112.brackets; + +import minetweaker.IBracketHandler; +import minetweaker.annotations.BracketHandler; +import minetweaker.api.liquid.ILiquidStack; +import minetweaker.mc1112.liquid.MCLiquidStack; +import minetweaker.runtime.GlobalRegistry; +import net.minecraftforge.fluids.*; +import stanhebben.zenscript.compiler.IEnvironmentGlobal; +import stanhebben.zenscript.expression.*; +import stanhebben.zenscript.expression.partial.IPartialExpression; +import stanhebben.zenscript.parser.Token; +import stanhebben.zenscript.symbols.IZenSymbol; +import stanhebben.zenscript.type.natives.*; +import stanhebben.zenscript.util.ZenPosition; + +import java.util.*; + +/** + * @author Stan + */ +@BracketHandler +public class LiquidBracketHandler implements IBracketHandler { + + private static final Map fluidNames = new HashMap<>(); + + @SuppressWarnings("unchecked") + public static void rebuildLiquidRegistry() { + fluidNames.clear(); + for(String fluidName : FluidRegistry.getRegisteredFluids().keySet()) { + fluidNames.put(fluidName.replace(" ", ""), FluidRegistry.getFluid(fluidName)); + } + } + + public static ILiquidStack getLiquid(String name) { + Fluid fluid = fluidNames.get(name); + if(fluid != null) { + return new MCLiquidStack(new FluidStack(fluid, 1)); + } else { + return null; + } + } + + @Override + public IZenSymbol resolve(IEnvironmentGlobal environment, List tokens) { + if(tokens.size() > 2) { + if(tokens.get(0).getValue().equals("liquid") && tokens.get(1).getValue().equals(":")) { + return find(environment, tokens, 2, tokens.size()); + } + } + + return null; + } + + private IZenSymbol find(IEnvironmentGlobal environment, List tokens, int startIndex, int endIndex) { + StringBuilder valueBuilder = new StringBuilder(); + for(int i = startIndex; i < endIndex; i++) { + Token token = tokens.get(i); + valueBuilder.append(token.getValue()); + } + + Fluid fluid = fluidNames.get(valueBuilder.toString()); + if(fluid != null) { + return new LiquidReferenceSymbol(environment, valueBuilder.toString()); + } + + return null; + } + + private class LiquidReferenceSymbol implements IZenSymbol { + + private final IEnvironmentGlobal environment; + private final String name; + + public LiquidReferenceSymbol(IEnvironmentGlobal environment, String name) { + this.environment = environment; + this.name = name; + } + + @Override + public IPartialExpression instance(ZenPosition position) { + IJavaMethod method = JavaMethod.get(GlobalRegistry.getTypeRegistry(), LiquidBracketHandler.class, "getLiquid", String.class); + + return new ExpressionCallStatic(position, environment, method, new ExpressionString(position, name)); + } + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/brackets/OreBracketHandler.java b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/brackets/OreBracketHandler.java new file mode 100644 index 0000000..88be797 --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/brackets/OreBracketHandler.java @@ -0,0 +1,81 @@ +package minetweaker.mc1112.brackets; + +import minetweaker.*; +import minetweaker.annotations.BracketHandler; +import minetweaker.api.oredict.IOreDictEntry; +import minetweaker.mc1112.oredict.MCOreDictEntry; +import minetweaker.runtime.GlobalRegistry; +import stanhebben.zenscript.compiler.IEnvironmentGlobal; +import stanhebben.zenscript.expression.*; +import stanhebben.zenscript.expression.partial.IPartialExpression; +import stanhebben.zenscript.parser.Token; +import stanhebben.zenscript.symbols.IZenSymbol; +import stanhebben.zenscript.type.natives.*; +import stanhebben.zenscript.util.ZenPosition; + +import java.util.*; +import java.util.regex.Pattern; + +/** + * @author Stan + */ +@BracketHandler +public class OreBracketHandler implements IBracketHandler { + + public static IOreDictEntry getOre(String name) { + return new MCOreDictEntry(name); + } + + public static List getOreList(String wildcardName) { + List result = new ArrayList<>(); + Pattern wildcardPattern = Pattern.compile(wildcardName.replaceAll("\\*", ".+")); + + for(IOreDictEntry someOreDict : MineTweakerAPI.oreDict.getEntries()) { + String oreDictName = someOreDict.getName(); + if(wildcardPattern.matcher(oreDictName).matches()) { + result.add(getOre(oreDictName)); + } + } + + return result; + } + + @Override + public IZenSymbol resolve(IEnvironmentGlobal environment, List tokens) { + if(tokens.size() > 2) { + if(tokens.get(0).getValue().equals("ore") && tokens.get(1).getValue().equals(":")) { + return find(environment, tokens, 2, tokens.size()); + } + } + + return null; + } + + private IZenSymbol find(IEnvironmentGlobal environment, List tokens, int startIndex, int endIndex) { + StringBuilder valueBuilder = new StringBuilder(); + for(int i = startIndex; i < endIndex; i++) { + Token token = tokens.get(i); + valueBuilder.append(token.getValue()); + } + + return new OreReferenceSymbol(environment, valueBuilder.toString()); + } + + private class OreReferenceSymbol implements IZenSymbol { + + private final IEnvironmentGlobal environment; + private final String name; + + public OreReferenceSymbol(IEnvironmentGlobal environment, String name) { + this.environment = environment; + this.name = name; + } + + @Override + public IPartialExpression instance(ZenPosition position) { + IJavaMethod method = JavaMethod.get(GlobalRegistry.getTypeRegistry(), OreBracketHandler.class, name.contains("*") ? "getOreList" : "getOre", String.class); + + return new ExpressionCallStatic(position, environment, method, new ExpressionString(position, name)); + } + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/brewing/MCBrewingManager.java b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/brewing/MCBrewingManager.java new file mode 100644 index 0000000..2d4a6fa --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/brewing/MCBrewingManager.java @@ -0,0 +1,73 @@ +package minetweaker.mc1112.brewing; + +import minetweaker.api.item.*; +import minetweaker.api.recipes.BrewingRecipe; +import minetweaker.api.recipes.*; +import minetweaker.api.recipes.IBrewingRecipe; +import minetweaker.mc1112.item.MCItemStack; +import net.minecraft.item.ItemStack; +import net.minecraftforge.common.brewing.*; + +import java.util.*; + +public class MCBrewingManager implements IBrewingManager { + + @Override + public List getAll() { + List ret = new ArrayList<>(); + for(net.minecraftforge.common.brewing.IBrewingRecipe rec : BrewingRecipeRegistry.getRecipes()) { + if(rec instanceof net.minecraftforge.common.brewing.AbstractBrewingRecipe) { + AbstractBrewingRecipe abs = (AbstractBrewingRecipe) rec; + if(abs instanceof BrewingOreRecipe) { + BrewingOreRecipe brew = (BrewingOreRecipe) abs; + ret.add(new BrewingRecipe(new MCItemStack(brew.getOutput()), new MCItemStack(brew.getInput()), convert(brew.getIngredient()))); + } + } + } + return ret; + } + + @Override + public void remove(IItemStack output) { + // if (output == null) + // throw new IllegalArgumentException("output cannot be null"); + // + // for(net.minecraftforge.common.brewing.IBrewingRecipe recipe : BrewingRecipeRegistry.getRecipes()){ + // if(recipe.is) + // } + // Map smeltingList = FurnaceRecipes.instance().getSmeltingList(); + // + // List toRemove = new ArrayList(); + // List toRemoveValues = new ArrayList(); + // for (Map.Entry entry : smeltingList.entrySet()) { + // if (output.matches(new MCItemStack(entry.getValue())) && (input == null || input.matches(new MCItemStack(entry.getKey())))) { + // toRemove.add(entry.getKey()); + // toRemoveValues.add(entry.getValue()); + // } + // } + // + // if (toRemove.isEmpty()) { + // MineTweakerAPI.logWarning("No furnace recipes for " + output.toString()); + // } else { + // MineTweakerAPI.apply(new MCFurnaceManager.RemoveAction(toRemove, toRemoveValues)); + // } + } + + @Override + public void add(IItemStack output, IItemStack ingredient, IItemStack input) { + + } + + @Override + public int remove(IItemStack output, IItemStack ingredients) { + return 0; + } + + private IngredientOr convert(List ingredients) { + IngredientOr ing; + + ing = new IngredientOr((IngredientItem[]) ingredients.toArray()); + + return ing; + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/chat/MCChatMessage.java b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/chat/MCChatMessage.java new file mode 100644 index 0000000..139878a --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/chat/MCChatMessage.java @@ -0,0 +1,30 @@ +package minetweaker.mc1112.chat; + +import minetweaker.api.chat.IChatMessage; +import net.minecraft.util.text.*; + +/** + * @author Stan + */ +public class MCChatMessage implements IChatMessage { + + private final ITextComponent data; + + public MCChatMessage(String message) { + data = new TextComponentString(message); + } + + public MCChatMessage(ITextComponent data) { + this.data = data; + } + + @Override + public IChatMessage add(IChatMessage other) { + return new MCChatMessage(data.appendSibling((ITextComponent) other.getInternal())); + } + + @Override + public Object getInternal() { + return data; + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/client/MCClient.java b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/client/MCClient.java new file mode 100644 index 0000000..4c41603 --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/client/MCClient.java @@ -0,0 +1,23 @@ +package minetweaker.mc1112.client; + +import minetweaker.api.client.IClient; +import minetweaker.api.minecraft.MineTweakerMC; +import minetweaker.api.player.IPlayer; +import net.minecraft.client.Minecraft; +import net.minecraftforge.fml.client.FMLClientHandler; + +/** + * @author Stan + */ +public class MCClient implements IClient { + + @Override + public IPlayer getPlayer() { + return MineTweakerMC.getIPlayer(Minecraft.getMinecraft().player); + } + + @Override + public String getLanguage() { + return FMLClientHandler.instance().getCurrentLanguage(); + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/data/NBTConverter.java b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/data/NBTConverter.java new file mode 100644 index 0000000..f1c21b5 --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/data/NBTConverter.java @@ -0,0 +1,138 @@ +package minetweaker.mc1112.data; + +import minetweaker.api.data.*; +import minetweaker.mc1112.util.MineTweakerHacks; +import net.minecraft.nbt.*; + +import java.util.*; +import java.util.stream.Collectors; + +/** + * @author Stan + */ +public class NBTConverter implements IDataConverter { + + private static final NBTConverter INSTANCE = new NBTConverter(); + + public NBTConverter() { + } + + public static NBTBase from(IData data) { + return data.convert(INSTANCE); + } + + public static IData from(NBTBase nbt, boolean immutable) { + if(nbt == null) + return null; + + switch(nbt.getId()) { + case 1: // byte + return new DataByte(((NBTPrimitive) nbt).getByte()); + case 2: // short + return new DataShort(((NBTPrimitive) nbt).getShort()); + case 3: // int + return new DataInt(((NBTPrimitive) nbt).getInt()); + case 4: // long + return new DataLong(((NBTPrimitive) nbt).getLong()); + case 5: // float + return new DataFloat(((NBTPrimitive) nbt).getFloat()); + case 6: // double + return new DataDouble(((NBTPrimitive) nbt).getDouble()); + case 7: // byte[] + return new DataByteArray(((NBTTagByteArray) nbt).getByteArray(), immutable); + case 8: // string + return new DataString(((NBTTagString) nbt).getString()); + case 9: { // list + List values = new ArrayList<>(); + List original = MineTweakerHacks.getTagList((NBTTagList) nbt); + values.addAll(original.stream().map(value -> from(value, immutable)).collect(Collectors.toList())); + return new DataList(values, immutable); + } + case 10: { // compound + Map values = new HashMap<>(); + NBTTagCompound original = (NBTTagCompound) nbt; + for(String key : original.getKeySet()) { + values.put(key, from(original.getTag(key), immutable)); + } + return new DataMap(values, immutable); + } + case 11: // int[] + return new DataIntArray(((NBTTagIntArray) nbt).getIntArray(), immutable); + default: + throw new RuntimeException("Unknown tag type: " + nbt.getId()); + } + } + + public static void updateMap(NBTTagCompound nbt, IData data) { + NBTUpdater updater = new NBTUpdater(nbt); + data.convert(updater); + } + + @Override + public NBTBase fromBool(boolean value) { + return new NBTTagInt(value ? 1 : 0); + } + + @Override + public NBTBase fromByte(byte value) { + return new NBTTagByte(value); + } + + @Override + public NBTBase fromShort(short value) { + return new NBTTagShort(value); + } + + @Override + public NBTBase fromInt(int value) { + return new NBTTagInt(value); + } + + @Override + public NBTBase fromLong(long value) { + return new NBTTagLong(value); + } + + @Override + public NBTBase fromFloat(float value) { + return new NBTTagFloat(value); + } + + @Override + public NBTBase fromDouble(double value) { + return new NBTTagDouble(value); + } + + @Override + public NBTBase fromString(String value) { + return new NBTTagString(value); + } + + @Override + public NBTBase fromList(List values) { + NBTTagList result = new NBTTagList(); + for(IData value : values) { + result.appendTag(from(value)); + } + return result; + } + + @Override + public NBTBase fromMap(Map values) { + NBTTagCompound result = new NBTTagCompound(); + for(Map.Entry entry : values.entrySet()) { + result.setTag(entry.getKey(), from(entry.getValue())); + } + return result; + } + + @Override + public NBTBase fromByteArray(byte[] value) { + return new NBTTagByteArray(value); + } + + @Override + public NBTBase fromIntArray(int[] value) { + return new NBTTagIntArray(value); + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/data/NBTUpdater.java b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/data/NBTUpdater.java new file mode 100644 index 0000000..c5a1007 --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/data/NBTUpdater.java @@ -0,0 +1,39 @@ +package minetweaker.mc1112.data; + +import minetweaker.api.data.*; +import net.minecraft.nbt.*; + +import java.util.Map; + +/** + * @author Stan + */ +public class NBTUpdater extends NBTConverter implements IDataConverter { + + private final NBTTagCompound nbt; + + public NBTUpdater(NBTTagCompound compound) { + this.nbt = compound; + } + + @Override + public NBTBase fromMap(Map map) { + for(Map.Entry entry : map.entrySet()) { + if(nbt.hasKey(entry.getKey())) { + if(entry.getValue() == null) { + nbt.removeTag(entry.getKey()); + } else { + if(nbt.getTag(entry.getKey()).getId() == 10) { + nbt.setTag(entry.getKey(), entry.getValue().convert(new NBTUpdater(nbt))); + } else { + nbt.setTag(entry.getKey(), NBTConverter.from(entry.getValue())); + } + } + } else if(entry.getValue() != null) { + nbt.setTag(entry.getKey(), from(entry.getValue())); + } + } + + return nbt; + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/entity/MCEntityDefinition.java b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/entity/MCEntityDefinition.java new file mode 100644 index 0000000..61b56b7 --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/entity/MCEntityDefinition.java @@ -0,0 +1,67 @@ +package minetweaker.mc1112.entity; + +import minetweaker.api.entity.IEntityDefinition; +import minetweaker.api.item.IItemStack; +import net.minecraft.entity.Entity; +import stanhebben.zenscript.value.*; + +import java.util.*; + +/** + * @author Stan + */ +public class MCEntityDefinition implements IEntityDefinition { + + private final Class entityClass; + private final String entityName; + + private final Map dropsToAdd = new HashMap<>(); + private final Map dropsToAddPlayerOnly = new HashMap<>(); + private final List dropsToRemove = new ArrayList<>(); + + public MCEntityDefinition(Class entityClass, String entityName) { + this.entityClass = entityClass; + this.entityName = entityName; + } + + + @Override + public String getId() { + return entityClass.getName(); + } + + @Override + public String getName() { + return entityName; + } + + @Override + public void addDrop(IItemStack stack, int min, int max) { + dropsToAdd.put(stack, new IntRange(min, max)); + } + + @Override + public void addPlayerOnlyDrop(IItemStack stack, int min, int max) { + dropsToAddPlayerOnly.put(stack, new IntRange(min, max)); + } + + @Override + public void removeDrop(IItemStack stack) { + dropsToRemove.add(stack); + } + + @Override + public Map getDropsToAdd() { + return dropsToAdd; + } + + @Override + public Map getDropsToAddPlayerOnly() { + return dropsToAddPlayerOnly; + } + + @Override + public List getDropsToRemove() { + return dropsToRemove; + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/formatting/FormattedMarkupString.java b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/formatting/FormattedMarkupString.java new file mode 100644 index 0000000..ec8631f --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/formatting/FormattedMarkupString.java @@ -0,0 +1,38 @@ +package minetweaker.mc1112.formatting; + +import minetweaker.api.formatting.IFormattedText; +import net.minecraft.util.text.TextFormatting; + +/** + * @author Stan + */ +public class FormattedMarkupString implements IMCFormattedString { + + private final TextFormatting markup; + private final IMCFormattedString contents; + + public FormattedMarkupString(TextFormatting markup, IMCFormattedString contents) { + this.markup = markup; + this.contents = contents; + } + + @Override + public String getTooltipString() { + return markup + contents.getTooltipString(markup.toString()); + } + + @Override + public String getTooltipString(String context) { + return markup + contents.getTooltipString(context + markup); + } + + @Override + public IFormattedText add(IFormattedText other) { + return cat(other); + } + + @Override + public IFormattedText cat(IFormattedText other) { + return new FormattedStringJoin(this, (IMCFormattedString) other); + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/formatting/FormattedString.java b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/formatting/FormattedString.java new file mode 100644 index 0000000..339b5c8 --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/formatting/FormattedString.java @@ -0,0 +1,35 @@ +package minetweaker.mc1112.formatting; + +import minetweaker.api.formatting.IFormattedText; + +/** + * @author Stan + */ +public class FormattedString implements IMCFormattedString { + + private final String value; + + public FormattedString(String value) { + this.value = value; + } + + @Override + public String getTooltipString() { + return value; + } + + @Override + public String getTooltipString(String context) { + return value; + } + + @Override + public IFormattedText add(IFormattedText other) { + return cat(other); + } + + @Override + public IFormattedText cat(IFormattedText other) { + return new FormattedStringJoin(this, (IMCFormattedString) other); + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/formatting/FormattedStringJoin.java b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/formatting/FormattedStringJoin.java new file mode 100644 index 0000000..4547c98 --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/formatting/FormattedStringJoin.java @@ -0,0 +1,62 @@ +package minetweaker.mc1112.formatting; + +import minetweaker.api.formatting.IFormattedText; +import net.minecraft.util.text.TextFormatting; + +import java.util.Arrays; + +/** + * @author Stan + */ +public class FormattedStringJoin implements IMCFormattedString { + + private final IMCFormattedString[] values; + + public FormattedStringJoin(IMCFormattedString first, IMCFormattedString second) { + values = new IMCFormattedString[]{first, second}; + } + + public FormattedStringJoin(IMCFormattedString[] values) { + this.values = values; + } + + @Override + public String getTooltipString() { + StringBuilder result = new StringBuilder(); + for(IMCFormattedString value : values) { + result.append(value.getTooltipString()); + } + return result.toString(); + } + + @Override + public String getTooltipString(String context) { + boolean first = true; + + StringBuilder result = new StringBuilder(); + for(IMCFormattedString value : values) { + if(first) { + first = false; + } else { + result.append(context); + } + + result.append(value.getTooltipString()); + result.append(TextFormatting.RESET); + } + + return result.toString(); + } + + @Override + public IFormattedText add(IFormattedText other) { + return cat(other); + } + + @Override + public IFormattedText cat(IFormattedText other) { + IMCFormattedString[] newValues = Arrays.copyOf(values, values.length + 1); + newValues[values.length] = (IMCFormattedString) other; + return new FormattedStringJoin(newValues); + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/formatting/IMCFormattedString.java b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/formatting/IMCFormattedString.java new file mode 100644 index 0000000..634ef1b --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/formatting/IMCFormattedString.java @@ -0,0 +1,13 @@ +package minetweaker.mc1112.formatting; + +import minetweaker.api.formatting.IFormattedText; + +/** + * @author Stan + */ +public interface IMCFormattedString extends IFormattedText { + + String getTooltipString(); + + String getTooltipString(String context); +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/formatting/MCFormatter.java b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/formatting/MCFormatter.java new file mode 100644 index 0000000..6710d39 --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/formatting/MCFormatter.java @@ -0,0 +1,120 @@ +package minetweaker.mc1112.formatting; + +import minetweaker.api.formatting.*; +import net.minecraft.util.text.TextFormatting; + +/** + * @author Stan + */ +public class MCFormatter implements IFormatter { + + @Override + public IFormattedText string(String text) { + return new FormattedString(text); + } + + @Override + public IFormattedText black(IFormattedText text) { + return new FormattedMarkupString(TextFormatting.BLACK, (IMCFormattedString) text); + } + + @Override + public IFormattedText darkBlue(IFormattedText text) { + return new FormattedMarkupString(TextFormatting.DARK_BLUE, (IMCFormattedString) text); + } + + @Override + public IFormattedText darkGreen(IFormattedText text) { + return new FormattedMarkupString(TextFormatting.DARK_GREEN, (IMCFormattedString) text); + } + + @Override + public IFormattedText darkAqua(IFormattedText text) { + return new FormattedMarkupString(TextFormatting.DARK_AQUA, (IMCFormattedString) text); + } + + @Override + public IFormattedText darkRed(IFormattedText text) { + return new FormattedMarkupString(TextFormatting.DARK_RED, (IMCFormattedString) text); + } + + @Override + public IFormattedText darkPurple(IFormattedText text) { + return new FormattedMarkupString(TextFormatting.DARK_PURPLE, (IMCFormattedString) text); + } + + @Override + public IFormattedText gold(IFormattedText text) { + return new FormattedMarkupString(TextFormatting.GOLD, (IMCFormattedString) text); + } + + @Override + public IFormattedText gray(IFormattedText text) { + return new FormattedMarkupString(TextFormatting.GRAY, (IMCFormattedString) text); + } + + @Override + public IFormattedText darkGray(IFormattedText text) { + return new FormattedMarkupString(TextFormatting.DARK_GRAY, (IMCFormattedString) text); + } + + @Override + public IFormattedText blue(IFormattedText text) { + return new FormattedMarkupString(TextFormatting.BLUE, (IMCFormattedString) text); + } + + @Override + public IFormattedText green(IFormattedText text) { + return new FormattedMarkupString(TextFormatting.GREEN, (IMCFormattedString) text); + } + + @Override + public IFormattedText aqua(IFormattedText text) { + return new FormattedMarkupString(TextFormatting.AQUA, (IMCFormattedString) text); + } + + @Override + public IFormattedText red(IFormattedText text) { + return new FormattedMarkupString(TextFormatting.RED, (IMCFormattedString) text); + } + + @Override + public IFormattedText lightPurple(IFormattedText text) { + return new FormattedMarkupString(TextFormatting.LIGHT_PURPLE, (IMCFormattedString) text); + } + + @Override + public IFormattedText yellow(IFormattedText text) { + return new FormattedMarkupString(TextFormatting.YELLOW, (IMCFormattedString) text); + } + + @Override + public IFormattedText white(IFormattedText text) { + return new FormattedMarkupString(TextFormatting.WHITE, (IMCFormattedString) text); + } + + @Override + public IFormattedText obfuscated(IFormattedText text) { + return new FormattedMarkupString(TextFormatting.OBFUSCATED, (IMCFormattedString) text); + } + + @Override + public IFormattedText bold(IFormattedText text) { + return new FormattedMarkupString(TextFormatting.BOLD, (IMCFormattedString) text); + } + + @Override + public IFormattedText strikethrough(IFormattedText text) { + return new FormattedMarkupString(TextFormatting.STRIKETHROUGH, (IMCFormattedString) text); + } + + @Override + public IFormattedText underline(IFormattedText text) { + return new FormattedMarkupString(TextFormatting.UNDERLINE, (IMCFormattedString) text); + } + + @Override + public IFormattedText italic(IFormattedText text) { + return new FormattedMarkupString(TextFormatting.ITALIC, (IMCFormattedString) text); + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/furnace/FuelTweaker.java b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/furnace/FuelTweaker.java new file mode 100644 index 0000000..1f253a7 --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/furnace/FuelTweaker.java @@ -0,0 +1,89 @@ +package minetweaker.mc1112.furnace; + +import minetweaker.MineTweakerAPI; +import minetweaker.api.item.IItemStack; +import minetweaker.api.minecraft.MineTweakerMC; +import net.minecraft.item.*; +import net.minecraftforge.fml.common.IFuelHandler; +import net.minecraftforge.fml.common.registry.GameRegistry; + +import java.lang.reflect.Field; +import java.util.*; + +public class FuelTweaker { + + public static final FuelTweaker INSTANCE = new FuelTweaker(); + private final HashMap> quickList = new HashMap<>(); + private List original; + + private FuelTweaker() { + } + + public void register() { + try { + Field fuelHandlers = GameRegistry.class.getDeclaredField("fuelHandlers"); + fuelHandlers.setAccessible(true); + original = (List) fuelHandlers.get(null); + List modified = new ArrayList<>(); + modified.add(new OverridingFuelHandler()); + fuelHandlers.set(null, modified); + } catch(NoSuchFieldException ex) { + System.out.println("[MineTweaker] Error: could not get GameRegistry fuel handlers field. Cannot use custom fuel values."); + } catch(SecurityException | IllegalAccessException ex) { + System.out.println("[MineTweaker] Error: could not alter GameRegistry fuel handlers field. Cannot use custom fuel values."); + } + } + + public void addFuelPattern(SetFuelPattern pattern) { + List items = pattern.getPattern().getItems(); + if(items == null) { + MineTweakerAPI.logError("Cannot set fuel for <*>"); + return; + } + + for(IItemStack item : pattern.getPattern().getItems()) { + ItemStack itemStack = MineTweakerMC.getItemStack(item); + Item mcItem = itemStack.getItem(); + if(!quickList.containsKey(mcItem)) { + quickList.put(mcItem, new ArrayList<>()); + } + quickList.get(mcItem).add(pattern); + } + + MineTweakerAPI.getIjeiRecipeRegistry().addFuel(Arrays.asList(MineTweakerMC.getItemStacks(pattern.getPattern().getItems())), pattern.getValue()); + } + + public void removeFuelPattern(SetFuelPattern pattern) { + for(IItemStack item : pattern.getPattern().getItems()) { + ItemStack itemStack = MineTweakerMC.getItemStack(item); + Item mcItem = itemStack.getItem(); + if(quickList.containsKey(mcItem)) { + quickList.get(mcItem).remove(pattern); + } + MineTweakerAPI.getIjeiRecipeRegistry().removeFuel(itemStack); + } + + } + + private class OverridingFuelHandler implements IFuelHandler { + + @Override + public int getBurnTime(ItemStack fuel) { + if(quickList.containsKey(fuel.getItem())) { + IItemStack stack = MineTweakerMC.getIItemStack(fuel); + + for(SetFuelPattern override : quickList.get(fuel.getItem())) { + if(override.getPattern().matches(stack)) { + return override.getValue(); + } + } + } + + int max = 0; + for(IFuelHandler handler : original) { + max = Math.max(max, handler.getBurnTime(fuel)); + } + return max; + } + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/furnace/MCFurnaceManager.java b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/furnace/MCFurnaceManager.java new file mode 100644 index 0000000..7fb4578 --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/furnace/MCFurnaceManager.java @@ -0,0 +1,227 @@ +package minetweaker.mc1112.furnace; + +import minetweaker.*; +import minetweaker.api.item.*; +import minetweaker.api.recipes.*; +import minetweaker.mc1112.item.MCItemStack; +import net.minecraft.item.ItemStack; +import net.minecraft.item.crafting.FurnaceRecipes; +import net.minecraftforge.fml.common.registry.GameRegistry; +import stanhebben.zenscript.annotations.Optional; + +import java.util.*; +import java.util.stream.Collectors; + +import static minetweaker.api.minecraft.MineTweakerMC.*; + +/** + * @author Stan + */ +public class MCFurnaceManager implements IFurnaceManager { + + public MCFurnaceManager() { + + } + + @Override + public void remove(IIngredient output, @Optional IIngredient input) { + if(output == null) + throw new IllegalArgumentException("output cannot be null"); + + Map smeltingList = FurnaceRecipes.instance().getSmeltingList(); + + List toRemove = new ArrayList<>(); + List toRemoveValues = new ArrayList<>(); + + if(input == null) { + for(Map.Entry entry : smeltingList.entrySet()) { + if(output.matches(getIItemStack(entry.getValue()))) { + toRemove.add(entry.getKey()); + toRemoveValues.add(entry.getValue()); + } + } + } else { + for(Map.Entry entry : smeltingList.entrySet()) { + if(output.matches(getIItemStack(entry.getValue())) && input.matches(getIItemStack(entry.getKey()))) { + toRemove.add(entry.getKey()); + toRemoveValues.add(entry.getValue()); + } + } + } + if(toRemove.isEmpty()) { + MineTweakerAPI.logWarning("No furnace recipes for " + output.toString()); + } else { + MineTweakerAPI.apply(new RemoveAction(toRemove, toRemoveValues)); + } + } + + @Override + public void addRecipe(IItemStack output, IIngredient input, @Optional double xp) { + List items = input.getItems(); + if(items == null) { + MineTweakerAPI.logError("Cannot turn " + input.toString() + " into a furnace recipe"); + } + + ItemStack[] items2 = getItemStacks(items); + ItemStack output2 = getItemStack(output); + MineTweakerAPI.apply(new AddRecipeAction(input, items2, output2, xp)); + } + + @Override + public void setFuel(IIngredient item, int fuel) { + MineTweakerAPI.apply(new SetFuelAction(new SetFuelPattern(item, fuel))); + } + + @Override + public int getFuel(IItemStack item) { + return GameRegistry.getFuelValue(getItemStack(item)); + } + + @Override + public List getAll() { + return FurnaceRecipes.instance().getSmeltingList().entrySet().stream().map(ent -> new FurnaceRecipe(new MCItemStack(ent.getKey()), new MCItemStack(ent.getValue()), FurnaceRecipes.instance().getSmeltingExperience(ent.getValue()))).collect(Collectors.toList()); + } + + // ###################### + // ### Action classes ### + // ###################### + + private static class RemoveAction implements IUndoableAction { + + private final List items; + private final List values; + + public RemoveAction(List items, List values) { + this.items = items; + this.values = values; + } + + @Override + public void apply() { + for(ItemStack item : items) { + FurnaceRecipes.instance().getSmeltingList().remove(item); + MineTweakerAPI.getIjeiRecipeRegistry().removeFurnace(item); + } + + } + + @Override + public boolean canUndo() { + return true; + } + + @Override + public void undo() { + for(int i = 0; i < items.size(); i++) { + FurnaceRecipes.instance().getSmeltingList().put(items.get(i), values.get(i)); + MineTweakerAPI.getIjeiRecipeRegistry().addFurnace(Arrays.asList(items.toArray()), values.get(i)); + } + + } + + @Override + public String describe() { + return "Removing " + items.size() + " furnace recipes"; + } + + @Override + public String describeUndo() { + return "Restoring " + items.size() + " furnace recipes"; + } + + @Override + public Object getOverrideKey() { + return null; + } + } + + private static class AddRecipeAction implements IUndoableAction { + + private final IIngredient ingredient; + private final ItemStack[] input; + private final ItemStack output; + private final double xp; + + public AddRecipeAction(IIngredient ingredient, ItemStack[] input, ItemStack output, double xp) { + this.ingredient = ingredient; + this.input = input; + this.output = output; + this.xp = xp; + } + + @Override + public void apply() { + for(ItemStack inputStack : input) { + FurnaceRecipes.instance().addSmeltingRecipe(inputStack, output, (float) xp); + } + MineTweakerAPI.getIjeiRecipeRegistry().addFurnace(Arrays.asList(input), output); + } + + @Override + public boolean canUndo() { + return true; + } + + @Override + public void undo() { + for(ItemStack inputStack : input) { + FurnaceRecipes.instance().getSmeltingList().remove(inputStack); + MineTweakerAPI.getIjeiRecipeRegistry().removeFurnace(inputStack); + } + } + + @Override + public String describe() { + return "Adding furnace recipe for " + ingredient; + } + + @Override + public String describeUndo() { + return "Removing furnace recipe for " + ingredient; + } + + @Override + public Object getOverrideKey() { + return null; + } + } + + private static class SetFuelAction implements IUndoableAction { + + private final SetFuelPattern pattern; + + public SetFuelAction(SetFuelPattern pattern) { + this.pattern = pattern; + } + + @Override + public void apply() { + FuelTweaker.INSTANCE.addFuelPattern(pattern); + } + + @Override + public boolean canUndo() { + return true; + } + + @Override + public void undo() { + FuelTweaker.INSTANCE.removeFuelPattern(pattern); + } + + @Override + public String describe() { + return "Setting fuel for " + pattern.getPattern(); + } + + @Override + public String describeUndo() { + return "Removing fuel for " + pattern.getPattern(); + } + + @Override + public Object getOverrideKey() { + return null; + } + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/furnace/SetFuelPattern.java b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/furnace/SetFuelPattern.java new file mode 100644 index 0000000..ab7ed85 --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/furnace/SetFuelPattern.java @@ -0,0 +1,22 @@ +package minetweaker.mc1112.furnace; + +import minetweaker.api.item.IIngredient; + +public class SetFuelPattern { + + private final IIngredient pattern; + private final int value; + + public SetFuelPattern(IIngredient pattern, int value) { + this.pattern = pattern; + this.value = value; + } + + public IIngredient getPattern() { + return pattern; + } + + public int getValue() { + return value; + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/game/MCGame.java b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/game/MCGame.java new file mode 100644 index 0000000..7bef00d --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/game/MCGame.java @@ -0,0 +1,212 @@ +package minetweaker.mc1112.game; + +import com.google.common.collect.Iterables; +import minetweaker.*; +import minetweaker.api.block.IBlockDefinition; +import minetweaker.api.entity.IEntityDefinition; +import minetweaker.api.game.IGame; +import minetweaker.api.item.IItemDefinition; +import minetweaker.api.liquid.ILiquidDefinition; +import minetweaker.api.minecraft.MineTweakerMC; +import minetweaker.api.world.IBiome; +import minetweaker.mc1112.entity.MCEntityDefinition; +import minetweaker.mc1112.item.MCItemDefinition; +import minetweaker.mc1112.liquid.MCLiquidDefinition; +import minetweaker.mc1112.util.*; +import net.minecraft.block.Block; +import net.minecraft.client.Minecraft; +import net.minecraft.item.Item; +import net.minecraft.util.ResourceLocation; +import net.minecraftforge.fluids.FluidRegistry; +import net.minecraftforge.fml.common.registry.ForgeRegistries; + +import java.util.*; +import java.util.stream.Collectors; + +// TODO Find this +// import minetweaker.mc1102.GuiCannotRemodify; + +/** + * @author Stan + */ +public class MCGame implements IGame { + + public static final MCGame INSTANCE = new MCGame(); + private static final Map TRANSLATIONS = MineTweakerHacks.getTranslations(); + private static final List ENTITY_DEFINITIONS = new ArrayList<>(); + private boolean locked = false; + + private MCGame() { + } + + @Override + public List getItems() { + return Item.REGISTRY.getKeys().stream().map(item -> new MCItemDefinition(item.toString(), Item.REGISTRY.getObject(item))).collect(Collectors.toList()); + } + + @Override + public List getBlocks() { + return Block.REGISTRY.getKeys().stream().map(block -> MineTweakerMC.getBlockDefinition(Block.REGISTRY.getObject(block))).collect(Collectors.toList()); + } + + @Override + public List getLiquids() { + return FluidRegistry.getRegisteredFluids().entrySet().stream().map(entry -> new MCLiquidDefinition(entry.getValue())).collect(Collectors.toList()); + } + + @Override + public List getBiomes() { + List result = new ArrayList<>(); + for(IBiome biome : MineTweakerMC.biomes) { + if(biome != null) { + result.add(biome); + } + } + return result; + } + + @Override + public List getEntities() { + if(Iterables.size(ForgeRegistries.ENTITIES) != ENTITY_DEFINITIONS.size()) { + ENTITY_DEFINITIONS.clear(); + ForgeRegistries.ENTITIES.forEach((entry) -> { + ENTITY_DEFINITIONS.add(new MCEntityDefinition(entry.getEntityClass(), entry.getName())); + }); + } + return ENTITY_DEFINITIONS; + } + + @Override + public IEntityDefinition getEntity(String entityName) { + for(IEntityDefinition ent : getEntities()) { + if(ent.getName().equalsIgnoreCase(entityName)) { + return ent; + } + } + boolean needsReloading = false; + for(ResourceLocation res : ForgeRegistries.ENTITIES.getKeys()) { + if(res.getResourcePath().equalsIgnoreCase(entityName)) { + needsReloading = true; + break; + } + } + if(needsReloading) { + ENTITY_DEFINITIONS.clear(); + ForgeRegistries.ENTITIES.forEach((entry) -> { + ENTITY_DEFINITIONS.add(new MCEntityDefinition(entry.getEntityClass(), entry.getName())); + }); + } + return getEntities().stream().filter(ent -> ent.getName().equals(entityName)).findFirst().orElse(null); + } + + @Override + public void setLocalization(String key, String value) { + MineTweakerAPI.apply(new SetTranslation(null, key, value)); + } + + @Override + public void setLocalization(String lang, String key, String value) { + MineTweakerAPI.apply(new SetTranslation(lang, key, value)); + } + + @Override + public String localize(String key) { + return net.minecraft.util.text.translation.I18n.translateToLocal(key); + } + + @Override + public String localize(String key, String lang) { + return net.minecraft.util.text.translation.I18n.translateToLocal(key); + } + + @Override + public void lock() { + locked = true; + } + + @Override + public boolean isLocked() { + return locked; + } + + @Override + public void signalLockError() { + MineTweakerAPI.getLogger().logError("Reload of scripts blocked (script lock)"); + + if(Minecraft.isGuiEnabled()) { + // Commented out due to unresolved import + /** + * Minecraft.getMinecraft().displayGuiScreen( new GuiCannotRemodify( + * "Minecraft has been tweaked for another server", + * "with modifications that cannot be rolled back.", + * "Please restart your game.")); + **/ + } + } + + // ###################### + // ### Action classes ### + // ###################### + + /** + * Ported from ModTweaker. + * + * @author Joshiejack + */ + private static class SetTranslation implements IUndoableAction { + + private final String lang; + private final String key; + private final String text; + private String original; + private boolean added; + + public SetTranslation(String lang, String key, String text) { + this.lang = lang; + this.key = key; + this.text = text; + } + + @Override + public void apply() { + if(lang == null || MineTweakerPlatformUtils.isLanguageActive(lang)) { + original = TRANSLATIONS.get(key); + TRANSLATIONS.put(key, text); + added = true; + } else { + added = false; + } + } + + @Override + public boolean canUndo() { + return TRANSLATIONS != null; + } + + @Override + public void undo() { + if(added) { + if(original == null) { + TRANSLATIONS.remove(key); + } else { + TRANSLATIONS.put(key, original); + } + } + } + + @Override + public String describe() { + return "Setting localization for the key: " + key + " to " + text; + } + + @Override + public String describeUndo() { + return "Setting localization for the key: " + key + " to " + original; + } + + @Override + public Object getOverrideKey() { + return null; + } + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/item/MCItemDefinition.java b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/item/MCItemDefinition.java new file mode 100644 index 0000000..f4cd2f7 --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/item/MCItemDefinition.java @@ -0,0 +1,79 @@ +package minetweaker.mc1112.item; + +import minetweaker.MineTweakerAPI; +import minetweaker.api.item.*; +import minetweaker.api.minecraft.MineTweakerMC; +import minetweaker.api.oredict.IOreDictEntry; +import net.minecraft.item.*; +import net.minecraftforge.oredict.OreDictionary; +import stanhebben.zenscript.annotations.Optional; + +import java.util.*; + +/** + * @author Stan + */ +public class MCItemDefinition implements IItemDefinition { + + private final String id; + private final Item item; + + public MCItemDefinition(String id, Item item) { + this.id = id; + this.item = item; + } + + @Override + public String getId() { + return id; + } + + @Override + public String getName() { + return item.getUnlocalizedName(); + } + + @Override + public IItemStack makeStack(@Optional int meta) { + return MineTweakerMC.getIItemStackWildcardSize(new ItemStack(item, 1, meta)); + } + + @Override + public List getOres() { + List result = new ArrayList<>(); + + for(String key : OreDictionary.getOreNames()) { + for(ItemStack is : OreDictionary.getOres(key)) { + if(is.getItem() == item) { + result.add(MineTweakerAPI.oreDict.get(key)); + break; + } + } + } + + return result; + } + + // ############################# + // ### Object implementation ### + // ############################# + + @Override + public int hashCode() { + int hash = 7; + hash = 37 * hash + (this.item != null ? this.item.hashCode() : 0); + return hash; + } + + @Override + public boolean equals(Object obj) { + if(obj == null) { + return false; + } + if(getClass() != obj.getClass()) { + return false; + } + final MCItemDefinition other = (MCItemDefinition) obj; + return !(this.item != other.item && (this.item == null || !this.item.equals(other.item))); + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/item/MCItemStack.java b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/item/MCItemStack.java new file mode 100644 index 0000000..6ed2920 --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/item/MCItemStack.java @@ -0,0 +1,405 @@ +package minetweaker.mc1112.item; + +import minetweaker.MineTweakerAPI; +import minetweaker.api.block.IBlock; +import minetweaker.api.data.*; +import minetweaker.api.item.*; +import minetweaker.api.liquid.ILiquidStack; +import minetweaker.api.oredict.IOreDictEntry; +import minetweaker.api.player.IPlayer; +import minetweaker.mc1112.actions.*; +import minetweaker.mc1112.block.MCItemBlock; +import minetweaker.mc1112.data.NBTConverter; +import minetweaker.mc1112.liquid.MCLiquidStack; +import minetweaker.util.ArrayUtil; +import net.minecraft.block.Block; +import net.minecraft.item.*; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.util.ResourceLocation; +import net.minecraftforge.fluids.*; +import net.minecraftforge.fml.relauncher.ReflectionHelper; +import net.minecraftforge.oredict.OreDictionary; + +import java.util.*; + +import static minetweaker.api.minecraft.MineTweakerMC.getItemStack; + +/** + * @author Stan + */ +public class MCItemStack implements IItemStack { + + private final ItemStack stack; + private final List items; + private IData tag = null; + private boolean wildcardSize; + + public MCItemStack(ItemStack itemStack) { + if(itemStack.isEmpty()) + throw new IllegalArgumentException("stack cannot be null"); + + stack = itemStack.copy(); + items = Collections.singletonList(this); + } + + public MCItemStack(ItemStack itemStack, boolean wildcardSize) { + this(itemStack); + + this.wildcardSize = wildcardSize; + } + + private MCItemStack(ItemStack itemStack, IData tag) { + if(itemStack.isEmpty()) + throw new IllegalArgumentException("stack cannot be null"); + + stack = itemStack; + items = Collections.singletonList(this); + this.tag = tag; + } + + private MCItemStack(ItemStack itemStack, IData tag, boolean wildcardSize) { + if(itemStack.isEmpty()) + throw new IllegalArgumentException("stack cannot be null"); + stack = itemStack; + items = Collections.singletonList(this); + this.tag = tag; + this.wildcardSize = wildcardSize; + } + + @Override + public IItemDefinition getDefinition() { + return new MCItemDefinition(Item.REGISTRY.getNameForObject(stack.getItem()).toString(), stack.getItem()); + } + + @Override + public String getName() { + return stack.getUnlocalizedName(); + } + + @Override + public String getDisplayName() { + return stack.getDisplayName(); + } + + @Override + public void setDisplayName(String name) { + MineTweakerAPI.apply(new SetTranslationAction(this, getName() + ".name", name)); + } + + @Override + public int getMaxStackSize() { + return stack.getMaxStackSize(); + } + + @Override + public void setMaxStackSize(int size) { + MineTweakerAPI.apply(new SetStackSizeAction((ItemStack) getInternal(), size)); + } + + @Override + public float getBlockHardness() { + return ReflectionHelper.getPrivateValue(Block.class, Block.getBlockFromItem(stack.getItem()), "blockHardness"); + } + + @Override + public void setBlockHardness(float hardness) { + MineTweakerAPI.apply(new SetBlockHardnessAction(stack, hardness)); + } + + @Override + public int getDamage() { + return stack.getItemDamage(); + } + + @Override + public IData getTag() { + if(tag == null) { + if(stack.getTagCompound() == null) { + return DataMap.EMPTY; + } + + tag = NBTConverter.from(stack.getTagCompound(), true); + } + return tag; + } + + @Override + public int getMaxDamage() { + return stack.getMaxDamage(); + } + + @Override + public void setMaxDamage(int damage) { + MineTweakerAPI.apply(new SetStackmaxDamageAction(stack, damage)); + } + + @Override + public ILiquidStack getLiquid() { + FluidStack liquid = FluidUtil.getFluidContained(stack); + return liquid == null ? null : new MCLiquidStack(liquid); + } + + @Override + public IIngredient anyDamage() { + ItemStack result = new ItemStack(stack.getItem(), stack.getCount(), OreDictionary.WILDCARD_VALUE); + result.setTagCompound(stack.getTagCompound()); + return new MCItemStack(result, tag); + } + + @Override + public IItemStack withDamage(int damage) { + ItemStack result = new ItemStack(stack.getItem(), stack.getCount(), damage); + result.setTagCompound(stack.getTagCompound()); + return new MCItemStack(result, tag); + } + + @Override + public IItemStack anyAmount() { + ItemStack result = new ItemStack(stack.getItem(), 1, stack.getItemDamage()); + result.setTagCompound(stack.getTagCompound()); + return new MCItemStack(result, tag, true); + } + + @Override + public IItemStack withAmount(int amount) { + ItemStack result = new ItemStack(stack.getItem(), amount, stack.getItemDamage()); + result.setTagCompound(stack.getTagCompound()); + return new MCItemStack(result, tag); + } + + @Override + public IItemStack withTag(IData tag) { + ItemStack result = new ItemStack(stack.getItem(), stack.getCount(), stack.getItemDamage()); + if(tag == null) { + result.setTagCompound(null); + } else { + result.setTagCompound((NBTTagCompound) NBTConverter.from(tag)); + } + return new MCItemStack(result, tag); + } + + @Override + public IItemStack withEmptyTag() { + ItemStack result = new ItemStack(stack.getItem(), stack.getCount(), stack.getItemDamage()); + result.setTagCompound(new NBTTagCompound()); + return new MCItemStack(result, NBTConverter.from(new NBTTagCompound(), true)); + } + + @Override + public IItemStack updateTag(IData tagUpdate) { + if(tag == null) { + if(stack.getTagCompound() == null) { + return withTag(tagUpdate); + } + + tag = NBTConverter.from(stack.getTagCompound(), true); + } + + IData updated = tag.update(tagUpdate); + return withTag(updated); + } + + @Override + public IItemStack removeTag(String tag) { + ItemStack result = new ItemStack(stack.getItem(), stack.getCount(), stack.getItemDamage()); + + if(tag == null) { + result.setTagCompound(null); + } else { + result.getTagCompound().removeTag(tag); + } + IData dataTag = NBTConverter.from(result.getTagCompound(), false); + return new MCItemStack(result, dataTag); + } + + @Override + public String getMark() { + return null; + } + + @Override + public int getAmount() { + return stack.getCount(); + } + + @Override + public List getItems() { + return items; + } + + @Override + public List getLiquids() { + return Collections.emptyList(); + } + + @Override + public IItemStack amount(int amount) { + return withAmount(amount); + } + + @Override + public WeightedItemStack percent(float chance) { + return new WeightedItemStack(this, chance * 0.01f); + } + + @Override + public WeightedItemStack weight(float chance) { + return new WeightedItemStack(this, chance); + } + + @Override + public IIngredient transform(IItemTransformer transformer) { + return new IngredientItem(this, null, ArrayUtil.EMPTY_CONDITIONS, new IItemTransformer[]{transformer}); + } + + @Override + public IIngredient only(IItemCondition condition) { + return new IngredientItem(this, null, new IItemCondition[]{condition}, ArrayUtil.EMPTY_TRANSFORMERS); + } + + @Override + public IIngredient marked(String mark) { + return new IngredientItem(this, mark, ArrayUtil.EMPTY_CONDITIONS, ArrayUtil.EMPTY_TRANSFORMERS); + } + + @Override + public IIngredient or(IIngredient ingredient) { + return new IngredientOr(this, ingredient); + } + + @Override + public boolean matches(IItemStack item) { + ItemStack internal = getItemStack(item); + if(stack.hasTagCompound()) { + return matchesExact(item); + } + return !internal.isEmpty() && !stack.isEmpty() && internal.getItem() == stack.getItem() && (wildcardSize || internal.getCount() >= stack.getCount()) && (stack.getItemDamage() == OreDictionary.WILDCARD_VALUE || stack.getItemDamage() == internal.getItemDamage() || (!stack.getHasSubtypes() && !stack.getItem().isDamageable())); + } + + @Override + public boolean matchesExact(IItemStack item) { + ItemStack internal = getItemStack(item); + if(internal.getTagCompound() != null && stack.getTagCompound() == null) { + return false; + } + if(internal.getTagCompound() == null && stack.getTagCompound() != null) { + return false; + } + if(internal.getTagCompound() == null && stack.getTagCompound() == null) { + return stack.getItem() == internal.getItem() && (internal.getMetadata() == 32767 || stack.getMetadata() == internal.getMetadata()); + } + if(internal.getTagCompound().getKeySet().equals(stack.getTagCompound().getKeySet())) { + for(String s : internal.getTagCompound().getKeySet()) { + if(!internal.getTagCompound().getTag(s).equals(stack.getTagCompound().getTag(s))) { + return false; + } + } + } + return stack.getItem() == internal.getItem() && (internal.getMetadata() == 32767 || stack.getMetadata() == internal.getMetadata()); + } + + @Override + public boolean matches(ILiquidStack liquid) { + return false; + } + + @Override + public boolean contains(IIngredient ingredient) { + List iitems = ingredient.getItems(); + return !(iitems == null || iitems.size() != 1) && matches(iitems.get(0)); + } + + @Override + public IItemStack applyTransform(IItemStack item, IPlayer byPlayer) { + return item; + } + + @Override + public boolean hasTransformers() { + return false; + } + + @Override + public Object getInternal() { + return stack; + } + + @Override + public IBlock asBlock() { + ResourceLocation name = Block.REGISTRY.getNameForObject(Block.getBlockFromItem(stack.getItem())); + if(Block.REGISTRY.containsKey(name)) { + return new MCItemBlock(stack); + } else { + throw new ClassCastException("This item is not a block"); + } + } + + @Override + public List getOres() { + List result = new ArrayList<>(); + + for(String key : OreDictionary.getOreNames()) { + for(ItemStack is : OreDictionary.getOres(key)) { + if(is.getItem() == stack.getItem() && (is.getItemDamage() == OreDictionary.WILDCARD_VALUE || is.getItemDamage() == stack.getItemDamage())) { + result.add(MineTweakerAPI.oreDict.get(key)); + break; + } + } + } + + return result; + } + + // ############################# + // ### Object implementation ### + // ############################# + + @Override + public int hashCode() { + int hash = 7; + hash = 41 * hash + stack.getItem().hashCode(); + hash = 41 * hash + stack.getItemDamage(); + hash = 41 * hash + stack.getCount(); + hash = 41 * hash + (stack.getTagCompound() == null ? 0 : stack.getTagCompound().hashCode()); + hash = 41 * hash + (this.wildcardSize ? 1 : 0); + return hash; + } + + @Override + public boolean equals(Object obj) { + if(obj == null) { + return false; + } + if(getClass() != obj.getClass()) { + return false; + } + final MCItemStack other = (MCItemStack) obj; + return this.stack.getItem() == other.stack.getItem() && this.stack.getItemDamage() == other.stack.getItemDamage() && this.stack.getCount() == other.stack.getCount() && !(this.stack.getTagCompound() != other.stack.getTagCompound() && (this.stack == null || this.stack.equals(other.stack))) && this.wildcardSize == other.wildcardSize; + } + + @Override + public String toString() { + StringBuilder result = new StringBuilder(); + result.append('<'); + result.append(Item.REGISTRY.getNameForObject(stack.getItem())); + + if(stack.getItemDamage() == OreDictionary.WILDCARD_VALUE) { + result.append(":*"); + } else if(stack.getItemDamage() > 0) { + result.append(':').append(stack.getItemDamage()); + } + result.append('>'); + + if(stack.getTagCompound() != null) { + result.append(".withTag("); + result.append(NBTConverter.from(stack.getTagCompound(), wildcardSize).toString()); + result.append(")"); + } + if(!wildcardSize && stack.getCount() > 1) { + result.append(" * ").append(stack.getCount()); + } + return result.toString(); + } + + +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/liquid/MCLiquidDefinition.java b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/liquid/MCLiquidDefinition.java new file mode 100644 index 0000000..06a97ba --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/liquid/MCLiquidDefinition.java @@ -0,0 +1,416 @@ +package minetweaker.mc1112.liquid; + +import minetweaker.*; +import minetweaker.api.item.IItemStack; +import minetweaker.api.liquid.*; +import net.minecraftforge.fluids.*; + +import java.util.*; + +/** + * @author Stan + */ +public class MCLiquidDefinition implements ILiquidDefinition { + + private final Fluid fluid; + + public MCLiquidDefinition(Fluid fluid) { + this.fluid = fluid; + } + + @Override + public String getName() { + return fluid.getName(); + } + + @Override + public String getDisplayName() { + return fluid.getLocalizedName(new FluidStack(fluid, 1000)); + } + + @Override + public ILiquidStack asStack(int millibuckets) { + return new MCLiquidStack(new FluidStack(fluid, millibuckets)); + } + + @Override + public int getLuminosity() { + return fluid.getLuminosity(); + } + + @Override + public void setLuminosity(int value) { + MineTweakerAPI.apply(new ActionSetLuminosity(value)); + } + + @Override + public int getDensity() { + return fluid.getDensity(); + } + + @Override + public void setDensity(int density) { + MineTweakerAPI.apply(new ActionSetDensity(density)); + } + + @Override + public int getTemperature() { + return fluid.getTemperature(); + } + + @Override + public void setTemperature(int temperature) { + MineTweakerAPI.apply(new ActionSetTemperature(temperature)); + } + + @Override + public int getViscosity() { + return fluid.getViscosity(); + } + + @Override + public void setViscosity(int viscosity) { + MineTweakerAPI.apply(new ActionSetViscosity(viscosity)); + } + + @Override + public boolean isGaseous() { + return fluid.isGaseous(); + } + + @Override + public void setGaseous(boolean gaseous) { + MineTweakerAPI.apply(new ActionSetGaseous(gaseous)); + } + + @Override + public List getContainers() { + List result = new ArrayList<>(); + //TODO I need updating! + MineTweakerAPI.logError("getContainers not supported in 1.11!"); + return result; + } + + @Override + public void addContainer(IItemStack filled, IItemStack empty, int amount) { + MineTweakerAPI.logError("addContainer not supported in 1.11!"); + // MineTweakerAPI.apply(new AddContainerAction(filled, empty, amount)); + } + + @Override + public void removeContainer(IItemStack filled) { + // MineTweakerAPI.apply(new RemoveContainerAction(filled)); + MineTweakerAPI.logError("removeContainer not supported in 1.11!"); + + } + + // ####################### + // ### Private methods ### + // ####################### + + /* + * private void removeContainerInner(IItemStack filled) { ItemStack + * filledItem = MineTweakerMC.getItemStack(filled); + * FluidContainerRegistry.FluidContainerData data = + * filledContainerMap.get(Arrays.asList(filledItem.itemID, + * filledItem.getItemDamage())); if (data != null) { + * filledContainerMap.remove(Arrays.asList(filledItem.itemID, + * filledItem.getItemDamage())); + * containerFluidMap.remove(Arrays.asList(data.emptyContainer.itemID, + * data.emptyContainer.getItemDamage())); + * + * // rebuild empty containers set emptyContainers.clear(); for + * (FluidContainerRegistry.FluidContainerData fdata : + * filledContainerMap.values()) { + * emptyContainers.add(Arrays.asList(fdata.emptyContainer.itemID, + * fdata.emptyContainer.getItemDamage())); } } + * MineTweakerAPI.logError("Removal of containers is not possible in 1.7.X" + * ); } + */ + + /* + * private FluidContainerRegistry.FluidContainerData getData(IItemStack + * filled) { ItemStack filledStack = MineTweakerMC.getItemStack(filled); + * return filledContainerMap.get(Arrays.asList(filledStack.itemID, + * filledStack.getItemDamage())); } + */ + + // ###################### + // ### Action classes ### + // ###################### + + // private class AddContainerAction implements IUndoableAction{ + // private final IItemStack filled; + // private final IItemStack empty; + // private final int amount; + // + // public AddContainerAction(IItemStack filled, IItemStack empty, int amount){ + // this.filled = filled; + // this.empty = empty; + // this.amount = amount; + // } + // + // @Override + // public void apply(){ + // FluidContainerRegistry.registerFluidContainer(new FluidStack(fluid, amount), MineTweakerMC.getItemStack(filled), MineTweakerMC.getItemStack(empty)); + // } + // + // @Override + // public boolean canUndo(){ + // return false; + // // return true; + // } + // + // @Override + // public void undo(){ + // // removeContainerInner(filled); + // } + // + // @Override + // public String describe(){ + // return "Adding " + filled.getDisplayName() + " as liquid container for " + fluid.getLocalizedName(new FluidStack(fluid, 1000)); + // } + // + // @Override + // public String describeUndo(){ + // return "Removing liquid container " + filled; + // } + // + // @Override + // public Object getOverrideKey(){ + // return null; + // } + // } + + /* + * private class RemoveContainerAction implements IUndoableAction { private + * final IItemStack filled; private final IItemStack empty; private final + * FluidStack amount; + * + * public RemoveContainerAction(IItemStack filled) { this.filled = filled; + * + * FluidContainerRegistry.FluidContainerData data = getData(filled); empty = + * MineTweakerMC.getIItemStack(data.emptyContainer); amount = data.fluid; } + * + * @Override public void apply() { removeContainerInner(filled); } + * + * @Override public boolean canUndo() { return true; } + * + * @Override public void undo() { + * FluidContainerRegistry.registerFluidContainer(amount, + * MineTweakerMC.getItemStack(filled), MineTweakerMC.getItemStack(empty)); } + * + * @Override public String describe() { return "Removing liquid container " + * + filled; } + * + * @Override public String describeUndo() { return + * "Restoring liquid container " + filled; } + * + * @Override public Object getOverrideKey() { return null; } } + */ + + private class ActionSetLuminosity implements IUndoableAction { + + private final int oldValue; + private final int newValue; + + public ActionSetLuminosity(int newValue) { + oldValue = getLuminosity(); + this.newValue = newValue; + } + + @Override + public void apply() { + fluid.setLuminosity(newValue); + } + + @Override + public boolean canUndo() { + return true; + } + + @Override + public void undo() { + fluid.setLuminosity(oldValue); + } + + @Override + public String describe() { + return "Setting " + fluid.getName() + " luminosity to " + newValue; + } + + @Override + public String describeUndo() { + return "Restoring " + fluid.getName() + " luminosity to " + oldValue; + } + + @Override + public Object getOverrideKey() { + return null; + } + } + + private class ActionSetDensity implements IUndoableAction { + + private final int oldValue; + private final int newValue; + + public ActionSetDensity(int newValue) { + oldValue = getDensity(); + this.newValue = newValue; + } + + @Override + public void apply() { + fluid.setDensity(newValue); + } + + @Override + public boolean canUndo() { + return true; + } + + @Override + public void undo() { + fluid.setDensity(oldValue); + } + + @Override + public String describe() { + return "Setting " + fluid.getName() + " density to " + newValue; + } + + @Override + public String describeUndo() { + return "Restoring " + fluid.getName() + " density to " + oldValue; + } + + @Override + public Object getOverrideKey() { + return null; + } + } + + private class ActionSetTemperature implements IUndoableAction { + + private final int oldValue; + private final int newValue; + + public ActionSetTemperature(int newValue) { + oldValue = getTemperature(); + this.newValue = newValue; + } + + @Override + public void apply() { + fluid.setTemperature(newValue); + } + + @Override + public boolean canUndo() { + return true; + } + + @Override + public void undo() { + fluid.setTemperature(oldValue); + } + + @Override + public String describe() { + return "Setting " + fluid.getName() + " temperature to " + newValue; + } + + @Override + public String describeUndo() { + return "Restoring " + fluid.getName() + " temperature to " + oldValue; + } + + @Override + public Object getOverrideKey() { + return null; + } + } + + private class ActionSetViscosity implements IUndoableAction { + + private final int oldValue; + private final int newValue; + + public ActionSetViscosity(int newValue) { + oldValue = getViscosity(); + this.newValue = newValue; + } + + @Override + public void apply() { + fluid.setViscosity(newValue); + } + + @Override + public boolean canUndo() { + return true; + } + + @Override + public void undo() { + fluid.setViscosity(oldValue); + } + + @Override + public String describe() { + return "Setting " + fluid.getName() + " viscosity to " + newValue; + } + + @Override + public String describeUndo() { + return "Restoring " + fluid.getName() + " viscosity to " + oldValue; + } + + @Override + public Object getOverrideKey() { + return null; + } + } + + private class ActionSetGaseous implements IUndoableAction { + + private final boolean oldValue; + private final boolean newValue; + + public ActionSetGaseous(boolean newValue) { + oldValue = isGaseous(); + this.newValue = newValue; + } + + @Override + public void apply() { + fluid.setGaseous(newValue); + } + + @Override + public boolean canUndo() { + return true; + } + + @Override + public void undo() { + fluid.setGaseous(oldValue); + } + + @Override + public String describe() { + return "Setting " + fluid.getName() + " gaseous to " + newValue; + } + + @Override + public String describeUndo() { + return "Restoring " + fluid.getName() + " gaseous to " + oldValue; + } + + @Override + public Object getOverrideKey() { + return null; + } + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/liquid/MCLiquidStack.java b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/liquid/MCLiquidStack.java new file mode 100644 index 0000000..72cb403 --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/liquid/MCLiquidStack.java @@ -0,0 +1,188 @@ +package minetweaker.mc1112.liquid; + +import minetweaker.api.data.IData; +import minetweaker.api.item.*; +import minetweaker.api.liquid.*; +import minetweaker.api.player.IPlayer; +import minetweaker.mc1112.data.NBTConverter; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraftforge.fluids.FluidStack; + +import java.util.*; + +/** + * @author Stan + */ +public class MCLiquidStack implements ILiquidStack { + + private final FluidStack stack; + private IData tag = null; + + public MCLiquidStack(FluidStack stack) { + this.stack = stack; + } + + private MCLiquidStack(FluidStack stack, IData tag) { + this.stack = stack; + this.tag = tag; + } + + @Override + public ILiquidDefinition getDefinition() { + return new MCLiquidDefinition(stack.getFluid()); + } + + @Override + public String getName() { + return stack.getFluid().getName(); + } + + @Override + public String getDisplayName() { + return stack.getFluid().getLocalizedName(stack); + } + + @Override + public int getAmount() { + return stack.amount; + } + + @Override + public IData getTag() { + if(tag == null) { + if(stack.tag == null) { + return null; + } + + tag = NBTConverter.from(stack.tag, true); + } + + return tag; + } + + @Override + public ILiquidStack withTag(IData data) { + FluidStack result = new FluidStack(stack.getFluid(), stack.amount); + result.tag = (NBTTagCompound) NBTConverter.from(data); + return new MCLiquidStack(result, data.immutable()); + } + + @Override + public ILiquidStack withAmount(int amount) { + FluidStack result = new FluidStack(stack.getFluid(), amount); + result.tag = stack.tag; + return new MCLiquidStack(result, tag); + } + + @Override + public int getLuminosity() { + return stack.getFluid().getLuminosity(stack); + } + + @Override + public int getDensity() { + return stack.getFluid().getDensity(stack); + } + + @Override + public int getTemperature() { + return stack.getFluid().getTemperature(stack); + } + + @Override + public int getViscosity() { + return stack.getFluid().getViscosity(stack); + } + + @Override + public boolean isGaseous() { + return stack.getFluid().isGaseous(stack); + } + + @Override + public Object getInternal() { + return stack; + } + + // ################################## + // ### IIngredient implementation ### + // ################################## + + @Override + public String getMark() { + return null; + } + + @Override + public List getItems() { + return Collections.emptyList(); + } + + @Override + public List getLiquids() { + return Collections.singletonList(this); + } + + @Override + public IIngredient amount(int amount) { + return withAmount(amount); + } + + @Override + public IIngredient or(IIngredient ingredient) { + return new IngredientOr(this, ingredient); + } + + @Override + public IIngredient transform(IItemTransformer transformer) { + throw new UnsupportedOperationException("Liquid stack can't have transformers"); + } + + @Override + public IIngredient only(IItemCondition condition) { + throw new UnsupportedOperationException("Liquid stack can't have conditions"); + } + + @Override + public IIngredient marked(String mark) { + throw new UnsupportedOperationException("Liquid stack can't be marked"); + } + + @Override + public boolean matches(IItemStack item) { + return false; + } + + @Override + public boolean matchesExact(IItemStack item) { + return false; + } + + @Override + public boolean matches(ILiquidStack liquid) { + return getDefinition().equals(liquid.getDefinition()) && getAmount() <= liquid.getAmount(); + } + + @Override + public boolean contains(IIngredient ingredient) { + if(!ingredient.getItems().isEmpty()) + return false; + + for(ILiquidStack liquid : ingredient.getLiquids()) { + if(!matches(liquid)) + return false; + } + + return false; + } + + @Override + public IItemStack applyTransform(IItemStack item, IPlayer byPlayer) { + return item; + } + + @Override + public boolean hasTransformers() { + return false; + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/logger/MCLogger.java b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/logger/MCLogger.java new file mode 100644 index 0000000..0844b74 --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/logger/MCLogger.java @@ -0,0 +1,80 @@ +package minetweaker.mc1112.logger; + +import minetweaker.runtime.ILogger; +import net.minecraftforge.fml.common.*; + +import java.io.*; +import java.util.regex.Pattern; + +public class MCLogger implements ILogger { + + private static final Pattern FORMATTING_CODE_PATTERN = Pattern.compile("(?i)" + String.valueOf('\u00a7') + "[0-9A-FK-OR]"); + private final Writer writer; + private final PrintWriter printWriter; + + public MCLogger(File output) { + try { + writer = new OutputStreamWriter(new FileOutputStream(output), "utf-8"); + printWriter = new PrintWriter(writer); + } catch(UnsupportedEncodingException ex) { + throw new RuntimeException("What the heck?"); + } catch(FileNotFoundException ex) { + throw new RuntimeException("Could not open log file " + output); + } + } + + @Override + public void logCommand(String message) { + try { + writer.write(stripMessage(message) + "\n"); + writer.flush(); + } catch(IOException ex) { + throw new RuntimeException(ex); + } + } + + @Override + public void logInfo(String message) { + try { + writer.write("[" + Loader.instance().getLoaderState() + "][" + FMLCommonHandler.instance().getEffectiveSide() + "][INFO] " + stripMessage(message) + "\n"); + writer.flush(); + } catch(IOException ex) { + throw new RuntimeException(ex); + } + } + + @Override + public void logWarning(String message) { + try { + writer.write("[" + Loader.instance().getLoaderState() + "][" + FMLCommonHandler.instance().getEffectiveSide() + "][WARNING] " + stripMessage(message) + "\n"); + writer.flush(); + } catch(IOException ex) { + throw new RuntimeException(ex); + } + } + + @Override + public void logError(String message) { + logError(message, null); + } + + @Override + public void logError(String message, Throwable exception) { + try { + writer.write("[" + Loader.instance().getLoaderState() + "][" + FMLCommonHandler.instance().getEffectiveSide() + "][ERROR] " + stripMessage(message) + "\n"); + if(exception != null) { + exception.printStackTrace(printWriter); + } + writer.flush(); + } catch(IOException ex) { + throw new RuntimeException(ex); + } + } + + /** + * Returns a copy of the given string, with formatting codes stripped away. + */ + public String stripMessage(String message) { + return message == null ? null : FORMATTING_CODE_PATTERN.matcher(message).replaceAll(""); + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/mods/MCLoadedMods.java b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/mods/MCLoadedMods.java new file mode 100644 index 0000000..d270b1f --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/mods/MCLoadedMods.java @@ -0,0 +1,43 @@ +package minetweaker.mc1112.mods; + +import minetweaker.api.mods.*; +import net.minecraftforge.fml.common.*; +import stanhebben.zenscript.util.MappingIterator; + +import java.util.*; + +/** + * @author Stan + */ +public class MCLoadedMods implements ILoadedMods { + + public MCLoadedMods() { + } + + @Override + public boolean contains(String name) { + return Loader.isModLoaded(name); + } + + @Override + public IMod get(String name) { + for(ModContainer mod : Loader.instance().getActiveModList()) { + if(mod.getModId().equals(name)) { + return new MCMod(mod); + } + } + + return null; + } + + @Override + public Iterator iterator() { + List mods = Loader.instance().getActiveModList(); + return new MappingIterator(mods.iterator()) { + @Override + public IMod map(ModContainer value) { + return new MCMod(value); + } + }; + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/mods/MCMod.java b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/mods/MCMod.java new file mode 100644 index 0000000..9d34962 --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/mods/MCMod.java @@ -0,0 +1,36 @@ +package minetweaker.mc1112.mods; + +import minetweaker.api.mods.IMod; +import net.minecraftforge.fml.common.ModContainer; + +/** + * @author Stan + */ +public class MCMod implements IMod { + + private final ModContainer mod; + + public MCMod(ModContainer mod) { + this.mod = mod; + } + + @Override + public String getId() { + return mod.getModId(); + } + + @Override + public String getName() { + return mod.getName(); + } + + @Override + public String getVersion() { + return mod.getVersion(); + } + + @Override + public String getDescription() { + return mod.getMetadata().description; + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/network/MineTweakerCopyClipboardHandler.java b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/network/MineTweakerCopyClipboardHandler.java new file mode 100644 index 0000000..2f93fc4 --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/network/MineTweakerCopyClipboardHandler.java @@ -0,0 +1,27 @@ +package minetweaker.mc1112.network; + +import net.minecraft.client.Minecraft; +import net.minecraftforge.fml.common.network.simpleimpl.*; + +import java.awt.*; +import java.awt.datatransfer.*; + +/** + * @author Stan + */ +public class MineTweakerCopyClipboardHandler implements IMessageHandler { + + @Override + public IMessage onMessage(MineTweakerCopyClipboardPacket message, MessageContext ctx) { + Minecraft.getMinecraft().addScheduledTask(() -> handle(message, ctx)); + return null; + } + + private void handle(MineTweakerCopyClipboardPacket message, MessageContext ctx) { + if(Desktop.isDesktopSupported()) { + StringSelection stringSelection = new StringSelection(message.getData()); + Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard(); + clipboard.setContents(stringSelection, null); + } + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/network/MineTweakerCopyClipboardPacket.java b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/network/MineTweakerCopyClipboardPacket.java new file mode 100644 index 0000000..b3ed246 --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/network/MineTweakerCopyClipboardPacket.java @@ -0,0 +1,37 @@ +package minetweaker.mc1112.network; + +import io.netty.buffer.ByteBuf; +import net.minecraftforge.fml.common.network.simpleimpl.IMessage; + +import java.nio.ByteBuffer; + +import static com.google.common.base.Charsets.UTF_8; + +/** + * @author Stan + */ +public class MineTweakerCopyClipboardPacket implements IMessage { + + private String data; + + public MineTweakerCopyClipboardPacket() { + } + + public MineTweakerCopyClipboardPacket(String data) { + this.data = data; + } + + public String getData() { + return data; + } + + @Override + public void fromBytes(ByteBuf buf) { + data = UTF_8.decode(ByteBuffer.wrap(buf.array())).toString().trim(); + } + + @Override + public void toBytes(ByteBuf buf) { + buf.writeBytes(UTF_8.encode(data).array()); + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/network/MineTweakerLoadScriptsHandler.java b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/network/MineTweakerLoadScriptsHandler.java new file mode 100644 index 0000000..fbd4d41 --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/network/MineTweakerLoadScriptsHandler.java @@ -0,0 +1,28 @@ +package minetweaker.mc1112.network; + +import minetweaker.*; +import minetweaker.mc1112.client.MCClient; +import minetweaker.runtime.providers.ScriptProviderMemory; +import net.minecraft.client.Minecraft; +import net.minecraftforge.fml.common.network.simpleimpl.*; + +/** + * @author Stan + */ +public class MineTweakerLoadScriptsHandler implements IMessageHandler { + + @Override + public IMessage onMessage(MineTweakerLoadScriptsPacket message, MessageContext ctx) { + Minecraft.getMinecraft().addScheduledTask(() -> handle(message, ctx)); + return null; + } + + private void handle(MineTweakerLoadScriptsPacket message, MessageContext ctx) { + if(MineTweakerAPI.server == null) { + MineTweakerAPI.client = new MCClient(); + + MineTweakerImplementationAPI.setScriptProvider(new ScriptProviderMemory(message.getData())); + MineTweakerImplementationAPI.reload(); + } + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/network/MineTweakerLoadScriptsPacket.java b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/network/MineTweakerLoadScriptsPacket.java new file mode 100644 index 0000000..0553728 --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/network/MineTweakerLoadScriptsPacket.java @@ -0,0 +1,37 @@ +package minetweaker.mc1112.network; + +import io.netty.buffer.ByteBuf; +import net.minecraftforge.fml.common.network.simpleimpl.IMessage; + +/** + * @author Stan + */ +public class MineTweakerLoadScriptsPacket implements IMessage { + + private byte[] data; + + public MineTweakerLoadScriptsPacket() { + // used for deserialization + } + + public MineTweakerLoadScriptsPacket(byte[] data) { + this.data = data; + } + + public byte[] getData() { + return data; + } + + @Override + public void fromBytes(ByteBuf buf) { + int size = buf.readInt(); + data = new byte[size]; + buf.readBytes(data); + } + + @Override + public void toBytes(ByteBuf buf) { + buf.writeInt(data.length); + buf.writeBytes(data); + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/network/MineTweakerOpenBrowserHandler.java b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/network/MineTweakerOpenBrowserHandler.java new file mode 100644 index 0000000..56af2f9 --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/network/MineTweakerOpenBrowserHandler.java @@ -0,0 +1,32 @@ +package minetweaker.mc1112.network; + +import net.minecraft.client.Minecraft; +import net.minecraftforge.fml.common.network.simpleimpl.*; + +import java.awt.*; +import java.io.IOException; +import java.net.*; + +/** + * @author Stan + */ +public class MineTweakerOpenBrowserHandler implements IMessageHandler { + + @Override + public IMessage onMessage(MineTweakerOpenBrowserPacket message, MessageContext ctx) { + Minecraft.getMinecraft().addScheduledTask(() -> handle(message, ctx)); + return null; + } + + private void handle(MineTweakerOpenBrowserPacket message, MessageContext ctx) { + if(Desktop.isDesktopSupported()) { + Desktop desktop = Desktop.getDesktop(); + try { + desktop.browse(new URI(message.getUrl())); + } catch(IOException | URISyntaxException ignored) { + } + } else { + System.out.println("Desktop not supported"); + } + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/network/MineTweakerOpenBrowserPacket.java b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/network/MineTweakerOpenBrowserPacket.java new file mode 100644 index 0000000..58d2e17 --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/network/MineTweakerOpenBrowserPacket.java @@ -0,0 +1,39 @@ +package minetweaker.mc1112.network; + +import io.netty.buffer.ByteBuf; +import net.minecraftforge.fml.common.network.simpleimpl.IMessage; + +import java.nio.ByteBuffer; +import java.nio.charset.Charset; + +/** + * @author Stan + */ +public class MineTweakerOpenBrowserPacket implements IMessage { + + private static final Charset UTF8 = Charset.forName("utf-8"); + + private String url; + + public MineTweakerOpenBrowserPacket() { + + } + + public MineTweakerOpenBrowserPacket(String url) { + this.url = url; + } + + public String getUrl() { + return url; + } + + @Override + public void fromBytes(ByteBuf buf) { + url = UTF8.decode(ByteBuffer.wrap(buf.array())).toString().trim(); + } + + @Override + public void toBytes(ByteBuf buf) { + buf.writeBytes(UTF8.encode(url).array()); + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/oredict/MCOreDict.java b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/oredict/MCOreDict.java new file mode 100644 index 0000000..1847a14 --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/oredict/MCOreDict.java @@ -0,0 +1,31 @@ +package minetweaker.mc1112.oredict; + +import minetweaker.api.minecraft.MineTweakerMC; +import minetweaker.api.oredict.*; +import net.minecraftforge.oredict.OreDictionary; + +import java.util.*; + +import static minetweaker.api.minecraft.MineTweakerMC.getOreDict; + +/** + * @author Stan + */ +public class MCOreDict implements IOreDict { + + @Override + public IOreDictEntry get(String name) { + return getOreDict(name); + } + + @Override + public List getEntries() { + List entries = new ArrayList<>(); + for(String key : OreDictionary.getOreNames()) { + if(!OreDictionary.getOres(key).isEmpty()) { + entries.add(MineTweakerMC.getOreDict(key)); + } + } + return entries; + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/oredict/MCOreDictEntry.java b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/oredict/MCOreDictEntry.java new file mode 100644 index 0000000..0603b29 --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/oredict/MCOreDictEntry.java @@ -0,0 +1,464 @@ +package minetweaker.mc1112.oredict; + +import minetweaker.*; +import minetweaker.api.item.*; +import minetweaker.api.liquid.ILiquidStack; +import minetweaker.api.minecraft.MineTweakerMC; +import minetweaker.api.oredict.*; +import minetweaker.api.player.IPlayer; +import minetweaker.mc1112.util.MineTweakerHacks; +import minetweaker.util.ArrayUtil; +import net.minecraft.item.ItemStack; +import net.minecraft.util.NonNullList; +import net.minecraftforge.oredict.OreDictionary; + +import java.util.*; +import java.util.stream.Collectors; + +import static minetweaker.api.minecraft.MineTweakerMC.*; + +/** + * @author Stan + */ +public class MCOreDictEntry implements IOreDictEntry { + + private static final List> OREDICT_CONTENTS = MineTweakerHacks.getOreIdStacks(); + private static final List> OREDICT_CONTENTS_UN = MineTweakerHacks.getOreIdStacksUn(); + + + private final String id; + + public MCOreDictEntry(String id) { + this.id = id; + } + + private static void reloadJEIItem(ItemStack stack) { + MineTweakerAPI.getIjeiRecipeRegistry().removeItem(stack); + MineTweakerAPI.getIjeiRecipeRegistry().addItem(stack); + } + + // #################################### + // ### IOreDictEntry implementation ### + // #################################### + + @Override + public String getName() { + return id; + } + + @Override + public boolean isEmpty() { + return OreDictionary.getOres(getName()).isEmpty(); + } + + @Override + public IItemStack getFirstItem() { + return getItems().get(0); + } + + @Override + public void add(IItemStack item) { + ItemStack stack = getItemStack(item); + if(!stack.isEmpty()) { + MineTweakerAPI.apply(new ActionAddItem(id, stack)); + } + } + + @Override + public void addItems(IItemStack[] items) { + for(IItemStack item : items) { + ItemStack stack = getItemStack(item); + if(!stack.isEmpty()) { + MineTweakerAPI.apply(new ActionAddItem(id, stack)); + } + } + } + + @Override + public void addAll(IOreDictEntry entry) { + if(entry instanceof MCOreDictEntry) { + MineTweakerAPI.apply(new ActionAddAll(id, ((MCOreDictEntry) entry).id)); + } else { + MineTweakerAPI.logError("not a valid entry"); + } + } + + @Override + public void remove(IItemStack item) { + ItemStack result = ItemStack.EMPTY; + for(ItemStack itemStack : OreDictionary.getOres(getName())) { + if(item.matches(getIItemStackWildcardSize(itemStack))) { + result = itemStack; + break; + } + } + + if(!result.isEmpty()) { + MineTweakerAPI.apply(new ActionRemoveItem(id, result)); + } + } + + @Override + public void removeItems(IItemStack[] items) { + for(IItemStack item : items) { + ItemStack result = ItemStack.EMPTY; + for(ItemStack itemStack : OreDictionary.getOres(id)) { + if(item.matches(getIItemStackWildcardSize(itemStack))) { + result = itemStack; + break; + } + } + + if(!result.isEmpty()) { + MineTweakerAPI.apply(new ActionRemoveItem(id, result)); + } + } + } + + @Override + public boolean contains(IItemStack item) { + for(ItemStack itemStack : OreDictionary.getOres(getName())) { + if(getIItemStackWildcardSize(itemStack).matches(item)) { + return true; + } + } + + return false; + } + + @Override + public void mirror(IOreDictEntry other) { + if(other instanceof MCOreDictEntry) { + MineTweakerAPI.apply(new ActionMirror(id, ((MCOreDictEntry) other).id)); + } else { + MineTweakerAPI.logError("not a valid oredict entry"); + } + } + + @Override + public String getMark() { + return null; + } + + @Override + public int getAmount() { + return 1; + } + + @Override + public List getItems() { + return OreDictionary.getOres(getName()).stream().map(MineTweakerMC::getIItemStackWildcardSize).collect(Collectors.toList()); + } + + @Override + public List getLiquids() { + return Collections.emptyList(); + } + + @Override + public IIngredient amount(int amount) { + return new IngredientStack(this, amount); + } + + @Override + public IIngredient transform(IItemTransformer transformer) { + return new IngredientOreDict(this, null, ArrayUtil.EMPTY_CONDITIONS, new IItemTransformer[]{transformer}); + } + + @Override + public IIngredient only(IItemCondition condition) { + return new IngredientOreDict(this, null, new IItemCondition[]{condition}, ArrayUtil.EMPTY_TRANSFORMERS); + } + + @Override + public IIngredient marked(String mark) { + return new IngredientOreDict(this, mark, ArrayUtil.EMPTY_CONDITIONS, ArrayUtil.EMPTY_TRANSFORMERS); + } + + @Override + public IIngredient or(IIngredient ingredient) { + return new IngredientOr(this, ingredient); + } + + @Override + public boolean matches(IItemStack item) { + return contains(item); + } + + @Override + public boolean matchesExact(IItemStack item) { + return contains(item); + } + + @Override + public boolean matches(ILiquidStack liquid) { + return false; + } + + @Override + public boolean contains(IIngredient ingredient) { + List items = ingredient.getItems(); + for(IItemStack item : items) { + if(!matches(item)) + return false; + } + + return true; + } + + @Override + public IItemStack applyTransform(IItemStack item, IPlayer byPlayer) { + return item; + } + + @Override + public boolean hasTransformers() { + return false; + } + + @Override + public Object getInternal() { + return id; + } + + // ############################# + // ### Object implementation ### + // ############################# + + @Override + public String toString() { + return ""; + } + + @Override + public int hashCode() { + return id.hashCode(); + } + + @Override + public boolean equals(Object other) { + return other instanceof MCOreDictEntry && Objects.equals(((MCOreDictEntry) other).id, id); + } + + // ###################### + // ### Action classes ### + // ###################### + + private static class ActionAddItem implements IUndoableAction { + + private final String id; + private final ItemStack item; + + public ActionAddItem(String id, ItemStack item) { + this.id = id; + this.item = item; + } + + @Override + public void apply() { + OreDictionary.registerOre(id, item); + reloadJEIItem(item); + } + + @Override + public boolean canUndo() { + return true; + } + + @Override + public void undo() { + int oreId = OreDictionary.getOreID(id); + ItemStack removeStack = item; + for (ItemStack stack: OreDictionary.getOres(id)) { + if (ItemStack.areItemStacksEqual(item, stack)) { + removeStack = stack; + break; + } + } + OREDICT_CONTENTS.get(oreId).remove(removeStack); + OreDictionary.rebakeMap(); + reloadJEIItem(removeStack); + } + + @Override + public String describe() { + return "Adding " + item.getDisplayName() + " to ore dictionary entry " + id; + } + + @Override + public String describeUndo() { + return "Removing " + item.getDisplayName() + " from ore dictionary entry " + id; + } + + @Override + public Object getOverrideKey() { + return null; + } + + } + + private static class ActionMirror implements IUndoableAction { + + private final String idTarget; + private final String idSource; + + private final NonNullList targetCopy; + private final NonNullList targetCopyUn; + + public ActionMirror(String idTarget, String idSource) { + this.idTarget = idTarget; + this.idSource = idSource; + + int targetOreId = OreDictionary.getOreID(idTarget); + targetCopy = OREDICT_CONTENTS.get(targetOreId); + targetCopyUn = OREDICT_CONTENTS_UN.get(targetOreId); + } + + @Override + public void apply() { + int sourceOreId = OreDictionary.getOreID(idSource); + int targetOreId = OreDictionary.getOreID(idTarget); + OREDICT_CONTENTS.set(targetOreId, OREDICT_CONTENTS.get(sourceOreId)); + OREDICT_CONTENTS_UN.set(targetOreId, OREDICT_CONTENTS_UN.get(sourceOreId)); + OreDictionary.rebakeMap(); + targetCopy.forEach(MCOreDictEntry::reloadJEIItem); + targetCopyUn.forEach(MCOreDictEntry::reloadJEIItem); + } + + @Override + public boolean canUndo() { + return true; + } + + @Override + public void undo() { + int targetOreId = OreDictionary.getOreID(idTarget); + OREDICT_CONTENTS.set(targetOreId, targetCopy); + OREDICT_CONTENTS_UN.set(targetOreId, targetCopyUn); + OreDictionary.rebakeMap(); + targetCopy.forEach(MCOreDictEntry::reloadJEIItem); + targetCopyUn.forEach(MCOreDictEntry::reloadJEIItem); + } + + @Override + public String describe() { + return "Mirroring " + idSource + " to " + idTarget; + } + + @Override + public String describeUndo() { + return "Undoing mirror of " + idSource + " to " + idTarget; + } + + @Override + public Object getOverrideKey() { + return null; + } + } + + private static class ActionRemoveItem implements IUndoableAction { + + private final String id; + private final ItemStack item; + + public ActionRemoveItem(String id, ItemStack item) { + this.id = id; + this.item = item; + } + + @Override + public void apply() { + int oreId = OreDictionary.getOreID(id); + OREDICT_CONTENTS.get(oreId).remove(item); + OreDictionary.rebakeMap(); + reloadJEIItem(item); + } + + @Override + public boolean canUndo() { + return true; + } + + @Override + public void undo() { + int oreId = OreDictionary.getOreID(id); + OREDICT_CONTENTS.get(oreId).add(item); + OreDictionary.rebakeMap(); + reloadJEIItem(item); + } + + @Override + public String describe() { + return "Removing " + item.getDisplayName() + " from ore dictionary entry " + id; + } + + @Override + public String describeUndo() { + return "Restoring " + item.getDisplayName() + " to ore dictionary entry " + id; + } + + @Override + public Object getOverrideKey() { + return null; + } + } + + private static class ActionAddAll implements IUndoableAction { + + private final String idTarget; + private final String idSource; + + public ActionAddAll(String idTarget, String idSource) { + this.idTarget = idTarget; + this.idSource = idSource; + } + + @Override + public void apply() { + for(ItemStack stack : OreDictionary.getOres(idSource)) { + OreDictionary.registerOre(idTarget, stack); + } + OreDictionary.getOres(idSource).forEach(MCOreDictEntry::reloadJEIItem); + } + + @Override + public boolean canUndo() { + return true; + } + + @Override + public void undo() { + int targetOreId = OreDictionary.getOreID(idTarget); + NonNullList targetOres = OreDictionary.getOres(idTarget); + List removeStacks = new ArrayList<>(); + for (ItemStack stack: OreDictionary.getOres(idSource)) { + for (ItemStack target: targetOres) { + if (ItemStack.areItemStacksEqual(target, stack)) { + removeStacks.add(target); + break; + } + } + } + for(ItemStack stack : removeStacks) { + OREDICT_CONTENTS.get(targetOreId).remove(stack); + } + OreDictionary.rebakeMap(); + removeStacks.forEach(MCOreDictEntry::reloadJEIItem); + } + + @Override + public String describe() { + return "Copying contents of ore dictionary entry " + idSource + " to " + idTarget; + } + + @Override + public String describeUndo() { + return "Removing contents of ore dictionary entry " + idSource + " from " + idTarget; + } + + @Override + public Object getOverrideKey() { + return null; + } + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/player/CommandBlockPlayer.java b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/player/CommandBlockPlayer.java new file mode 100644 index 0000000..0999a0c --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/player/CommandBlockPlayer.java @@ -0,0 +1,135 @@ +package minetweaker.mc1112.player; + +import minetweaker.MineTweakerAPI; +import minetweaker.api.chat.IChatMessage; +import minetweaker.api.data.IData; +import minetweaker.api.item.IItemStack; +import minetweaker.api.player.IPlayer; +import net.minecraft.command.ICommandSender; +import net.minecraft.util.text.*; + +/** + * @author Jared + */ +public class CommandBlockPlayer implements IPlayer { + + private final ICommandSender sender; + + public CommandBlockPlayer(ICommandSender sender) { + this.sender = sender; + } + + public ICommandSender getInternal() { + return sender; + } + + @Override + public String getId() { + return null; // TODO: we should be having this for MC 1.7.10, right? + } + + @Override + public String getName() { + return sender.getName(); + } + + @Override + public IData getData() { + return null; + } + + @Override + public int getXP() { + return 0; + } + + @Override + public void setXP(int xp) { + + } + + @Override + public void removeXP(int xp) { + + } + + @Override + public void update(IData data) { + + } + + @Override + public void sendChat(IChatMessage message) { + Object internal = message.getInternal(); + if(!(internal instanceof ITextComponent)) { + MineTweakerAPI.logError("not a valid chat message"); + return; + } + sender.sendMessage((ITextComponent) internal); + } + + @Override + public void sendChat(String message) { + sender.sendMessage(new TextComponentString(message)); + } + + @Override + public int getHotbarSize() { + return 0; + } + + @Override + public IItemStack getHotbarStack(int i) { + return null; + } + + @Override + public int getInventorySize() { + return 0; + } + + @Override + public IItemStack getInventoryStack(int i) { + return null; + } + + @Override + public IItemStack getCurrentItem() { + return null; + } + + @Override + public boolean isCreative() { + return false; + } + + @Override + public boolean isAdventure() { + return false; + } + + @Override + public void openBrowser(String url) { + } + + @Override + public void copyToClipboard(String value) { + } + + @Override + public boolean equals(Object other) { + return other.getClass() == this.getClass() && ((CommandBlockPlayer) other).sender.equals(sender); + + } + + @Override + public int hashCode() { + int hash = 5; + hash = 23 * hash + (this.sender != null ? this.sender.hashCode() : 0); + return hash; + } + + @Override + public void give(IItemStack stack) { + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/player/MCPlayer.java b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/player/MCPlayer.java new file mode 100644 index 0000000..3242722 --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/player/MCPlayer.java @@ -0,0 +1,147 @@ +package minetweaker.mc1112.player; + +import minetweaker.MineTweakerAPI; +import minetweaker.api.chat.IChatMessage; +import minetweaker.api.data.IData; +import minetweaker.api.item.IItemStack; +import minetweaker.api.minecraft.MineTweakerMC; +import minetweaker.api.player.IPlayer; +import minetweaker.mc1112.MineTweakerMod; +import minetweaker.mc1112.data.NBTConverter; +import minetweaker.mc1112.network.*; +import net.minecraft.entity.player.*; +import net.minecraft.util.text.*; + +/** + * @author Stan + */ +public class MCPlayer implements IPlayer { + + private final EntityPlayer player; + + public MCPlayer(EntityPlayer player) { + this.player = player; + } + + public EntityPlayer getInternal() { + return player; + } + + @Override + public String getId() { + return null; // TODO: we should be having this for MC 1.7.10, right? + } + + @Override + public String getName() { + return player.getName(); + } + + @Override + public IData getData() { + return NBTConverter.from(player.getEntityData(), true); + } + + @Override + public int getXP() { + return player.experienceLevel; + } + + @Override + public void setXP(int xp) { + player.removeExperienceLevel(player.experienceLevel); + player.addExperienceLevel(xp); + } + + @Override + public void removeXP(int xp) { + player.removeExperienceLevel(xp); + } + + @Override + public void update(IData data) { + NBTConverter.updateMap(player.getEntityData(), data); + } + + @Override + public void sendChat(IChatMessage message) { + Object internal = message.getInternal(); + if(!(internal instanceof ITextComponent)) { + MineTweakerAPI.logError("not a valid chat message"); + return; + } + player.sendMessage((ITextComponent) internal); + } + + @Override + public void sendChat(String message) { + player.sendMessage(new TextComponentString(message)); + } + + @Override + public int getHotbarSize() { + return 9; + } + + @Override + public IItemStack getHotbarStack(int i) { + return i < 0 || i >= 9 ? null : MineTweakerMC.getIItemStack(player.inventory.getStackInSlot(i)); + } + + @Override + public int getInventorySize() { + return player.inventory.getSizeInventory(); + } + + @Override + public IItemStack getInventoryStack(int i) { + return MineTweakerMC.getIItemStack(player.inventory.getStackInSlot(i)); + } + + @Override + public IItemStack getCurrentItem() { + return MineTweakerMC.getIItemStack(player.inventory.getCurrentItem()); + } + + @Override + public boolean isCreative() { + return player.capabilities.isCreativeMode; + } + + @Override + public boolean isAdventure() { + return !player.capabilities.allowEdit; + } + + @Override + public void openBrowser(String url) { + if(player instanceof EntityPlayerMP) { + MineTweakerMod.NETWORK.sendTo(new MineTweakerOpenBrowserPacket(url), (EntityPlayerMP) player); + } + } + + @Override + public void copyToClipboard(String value) { + if(player instanceof EntityPlayerMP) { + MineTweakerMod.NETWORK.sendTo(new MineTweakerCopyClipboardPacket(value), (EntityPlayerMP) player); + } + } + + @Override + public boolean equals(Object other) { + return other.getClass() == this.getClass() && ((MCPlayer) other).player == player; + + } + + @Override + public int hashCode() { + int hash = 5; + hash = 23 * hash + (this.player != null ? this.player.hashCode() : 0); + return hash; + } + + @Override + public void give(IItemStack stack) { + player.inventory.addItemStackToInventory(MineTweakerMC.getItemStack(stack).copy()); + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/player/RconPlayer.java b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/player/RconPlayer.java new file mode 100644 index 0000000..f4fd25c --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/player/RconPlayer.java @@ -0,0 +1,135 @@ +package minetweaker.mc1112.player; + +import minetweaker.MineTweakerAPI; +import minetweaker.api.chat.IChatMessage; +import minetweaker.api.data.IData; +import minetweaker.api.item.IItemStack; +import minetweaker.api.player.IPlayer; +import net.minecraft.command.ICommandSender; +import net.minecraft.util.text.*; + +/** + * @author Jared + */ +public class RconPlayer implements IPlayer { + + private final ICommandSender sender; + + public RconPlayer(ICommandSender sender) { + this.sender = sender; + } + + public ICommandSender getInternal() { + return sender; + } + + @Override + public String getId() { + return null; // TODO: we should be having this for MC 1.7.10, right? + } + + @Override + public String getName() { + return sender.getName(); + } + + @Override + public IData getData() { + return null; + } + + @Override + public int getXP() { + return 0; + } + + @Override + public void setXP(int xp) { + + } + + @Override + public void removeXP(int xp) { + + } + + @Override + public void update(IData data) { + + } + + @Override + public void sendChat(IChatMessage message) { + Object internal = message.getInternal(); + if(!(internal instanceof ITextComponent)) { + MineTweakerAPI.logError("not a valid chat message"); + return; + } + sender.sendMessage((ITextComponent) internal); + } + + @Override + public void sendChat(String message) { + sender.sendMessage(new TextComponentString(message)); + } + + @Override + public int getHotbarSize() { + return 0; + } + + @Override + public IItemStack getHotbarStack(int i) { + return null; + } + + @Override + public int getInventorySize() { + return 0; + } + + @Override + public IItemStack getInventoryStack(int i) { + return null; + } + + @Override + public IItemStack getCurrentItem() { + return null; + } + + @Override + public boolean isCreative() { + return false; + } + + @Override + public boolean isAdventure() { + return false; + } + + @Override + public void openBrowser(String url) { + } + + @Override + public void copyToClipboard(String value) { + } + + @Override + public boolean equals(Object other) { + return other.getClass() == this.getClass() && ((RconPlayer) other).sender == sender; + + } + + @Override + public int hashCode() { + int hash = 5; + hash = 23 * hash + (this.sender != null ? this.sender.hashCode() : 0); + return hash; + } + + @Override + public void give(IItemStack stack) { + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/recipes/MCCraftingInventory.java b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/recipes/MCCraftingInventory.java new file mode 100644 index 0000000..7ee015c --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/recipes/MCCraftingInventory.java @@ -0,0 +1,179 @@ +package minetweaker.mc1112.recipes; + +import minetweaker.api.item.IItemStack; +import minetweaker.api.player.IPlayer; +import minetweaker.api.recipes.ICraftingInventory; +import minetweaker.mc1112.player.MCPlayer; +import minetweaker.mc1112.util.MineTweakerHacks; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.inventory.*; +import net.minecraft.item.ItemStack; + +import java.util.List; + +import static minetweaker.api.minecraft.MineTweakerMC.*; + +/** + * @author Stan + */ +public class MCCraftingInventory implements ICraftingInventory { + + private final IInventory inventory; + private final IPlayer player; + private final EntityPlayer playerOrig; + private int width; + private int height; + private IItemStack[] stacks; + private ItemStack[] original; + private int stackCount; + + private MCCraftingInventory(InventoryCrafting inventory) { + this.inventory = inventory; + width = height = (int) Math.sqrt(inventory.getSizeInventory()); + stacks = new IItemStack[width * height]; + original = new ItemStack[stacks.length]; + stackCount = 0; + update(); + + Container container = MineTweakerHacks.getCraftingContainer(inventory); + if(container != null) { + List slots = container.inventorySlots; + if(!slots.isEmpty() && slots.get(0) instanceof SlotCrafting) { + SlotCrafting slotCrafting = (SlotCrafting) slots.get(0); + playerOrig = MineTweakerHacks.getCraftingSlotPlayer(slotCrafting); + player = getIPlayer(playerOrig); + } else { + playerOrig = null; + player = null; + } + } else { + playerOrig = null; + player = null; + } + } + + public MCCraftingInventory(IInventory inventory, EntityPlayer player) { + this.inventory = inventory; + width = height = (int) Math.sqrt(inventory.getSizeInventory()); + stacks = new IItemStack[width * height]; + original = new ItemStack[stacks.length]; + stackCount = 0; + update(); + + playerOrig = player; + this.player = player == null ? null : new MCPlayer(player); + } + + public static MCCraftingInventory get(InventoryCrafting inventory) { + return new MCCraftingInventory(inventory); + } + + public static MCCraftingInventory get(IInventory inventory, EntityPlayer player) { + return new MCCraftingInventory(inventory, player); + } + + private void update() { + if(inventory.getSizeInventory() != original.length) { + width = height = (int) Math.sqrt(inventory.getSizeInventory()); + stacks = new IItemStack[inventory.getSizeInventory()]; + original = new ItemStack[stacks.length]; + stackCount = 0; + } + + for(int i = 0; i < inventory.getSizeInventory(); i++) { + if(changed(i)) { + // System.out.println("Slot " + i + " changed"); + original[i] = inventory.getStackInSlot(i); + if(!inventory.getStackInSlot(i).isEmpty()) { + if(stacks[i] == null) + stackCount++; + stacks[i] = getIItemStack(original[i]); + } else { + if(stacks[i] != null) + stackCount--; + stacks[i] = null; + } + } + } + // System.out.println("Num stack count: " + stackCount); + } + + @Override + public IPlayer getPlayer() { + return player; + } + + @Override + public int getSize() { + return width * height; + } + + @Override + public int getWidth() { + return width; + } + + @Override + public int getHeight() { + return height; + } + + @Override + public int getStackCount() { + return stackCount; + } + + @Override + public IItemStack getStack(int i) { + return stacks[i]; + } + + @Override + public IItemStack getStack(int x, int y) { + return stacks[y * width + x]; + } + + @Override + public void setStack(int x, int y, IItemStack stack) { + // System.out.println("SetStack(" + x + ", " + y + ") " + stack); + + int ix = y * width + x; + if(stack != stacks[ix]) { + if(stack == null) { + stackCount--; + inventory.setInventorySlotContents(ix, ItemStack.EMPTY); + } else { + inventory.setInventorySlotContents(ix, getItemStack(stack)); + + if(stacks[ix] == null) { + stackCount++; + } + } + stacks[ix] = stack; + } + } + + @Override + public void setStack(int i, IItemStack stack) { + // System.out.println("SetStack(" + i + ") " + stack); + + if(stack != stacks[i]) { + if(stack == null) { + stackCount--; + inventory.setInventorySlotContents(i, ItemStack.EMPTY); + } else { + inventory.setInventorySlotContents(i, getItemStack(stack)); + + if(stacks[i] == null) { + stackCount++; + } + } + stacks[i] = stack; + } + } + + private boolean changed(int i) { + return original[i] != inventory.getStackInSlot(i) || !original[i].isEmpty() && stacks[i].getAmount() != original[i].getCount(); + + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/recipes/MCRecipeManager.java b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/recipes/MCRecipeManager.java new file mode 100644 index 0000000..5edb13d --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/recipes/MCRecipeManager.java @@ -0,0 +1,439 @@ +package minetweaker.mc1112.recipes; + +import minetweaker.*; +import minetweaker.api.item.*; +import minetweaker.api.minecraft.MineTweakerMC; +import minetweaker.api.player.IPlayer; +import minetweaker.api.recipes.*; +import minetweaker.mc1112.util.MineTweakerHacks; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.inventory.*; +import net.minecraft.item.ItemStack; +import net.minecraft.item.crafting.*; +import net.minecraft.util.NonNullList; +import net.minecraftforge.oredict.*; +import stanhebben.zenscript.annotations.Optional; + +import java.util.*; + +import static minetweaker.api.minecraft.MineTweakerMC.*; + +/** + * @author Stan + */ +public class MCRecipeManager implements IRecipeManager { + + public static List recipes; + private static List transformerRecipes; + + public MCRecipeManager() { + recipes = CraftingManager.getInstance().getRecipeList(); + transformerRecipes = new ArrayList<>(); + } + + private static boolean matches(Object input, IIngredient ingredient) { + if((input == null) != (ingredient == null)) { + return false; + } else if(ingredient != null) { + if(input instanceof ItemStack) { + if(((ItemStack)input).isEmpty() != (ingredient == null)) { + return false; + } + if(!ingredient.matches(getIItemStack((ItemStack) input))) { + return false; + } + } else if(input instanceof String) { + if(!ingredient.contains(getOreDict((String) input))) { + return false; + } + } + } + + return true; + } + + public boolean hasTransformerRecipes() { + return transformerRecipes.size() > 0; + } + + public void applyTransformations(ICraftingInventory inventory, IPlayer byPlayer) { + for(ICraftingRecipe recipe : transformerRecipes) { + if(recipe.matches(inventory)) { + recipe.applyTransformers(inventory, byPlayer); + return; + } + } + } + + @Override + public List getRecipesFor(IIngredient ingredient) { + List results = new ArrayList<>(); + + recipes.stream().filter(recipe -> ingredient.matches(MineTweakerMC.getIItemStack(recipe.getRecipeOutput()))).forEach(recipe -> { + ICraftingRecipe converted = RecipeConverter.toCraftingRecipe(recipe); + results.add(converted); + }); + + return results; + } + + @Override + public List getAll() { + List results = new ArrayList<>(); + + for(IRecipe recipe : recipes) { + ICraftingRecipe converted = RecipeConverter.toCraftingRecipe(recipe); + results.add(converted); + } + + return results; + } + + @Override + public int remove(IIngredient output, @Optional boolean nbtMatch) { + List toRemove = new ArrayList<>(); + List removeIndex = new ArrayList<>(); + for(int i = 0; i < recipes.size(); i++) { + IRecipe recipe = recipes.get(i); + + // certain special recipes have no predefined output. ignore those + // since these cannot be removed with MineTweaker scripts + if(!recipe.getRecipeOutput().isEmpty()) { + if(nbtMatch ? output.matchesExact(getIItemStack(recipe.getRecipeOutput())) : output.matches(getIItemStack(recipe.getRecipeOutput()))) { + toRemove.add(recipe); + removeIndex.add(i); + } + } + } + + MineTweakerAPI.apply(new ActionRemoveRecipes(toRemove, removeIndex)); + return toRemove.size(); + } + + @Override + public void addShaped(IItemStack output, IIngredient[][] ingredients, @Optional IRecipeFunction function, @Optional IRecipeAction action) { + addShaped(output, ingredients, function, action, false); + } + + @Override + public void addShapedMirrored(IItemStack output, IIngredient[][] ingredients, @Optional IRecipeFunction function, @Optional IRecipeAction action) { + addShaped(output, ingredients, function, action, true); + } + + @Override + public void addShapeless(IItemStack output, IIngredient[] ingredients, @Optional IRecipeFunction function, @Optional IRecipeAction action) { + ShapelessRecipe recipe = new ShapelessRecipe(output, ingredients, function, action); + IRecipe irecipe = RecipeConverter.convert(recipe); + MineTweakerAPI.apply(new ActionAddRecipe(irecipe, recipe)); + } + + @Override + public int removeShaped(IIngredient output, IIngredient[][] ingredients) { + int ingredientsWidth = 0; + int ingredientsHeight = 0; + + if(ingredients != null) { + ingredientsHeight = ingredients.length; + + for(int i = 0; i < ingredients.length; i++) { + ingredientsWidth = Math.max(ingredientsWidth, ingredients[i].length); + } + } + + List toRemove = new ArrayList(); + List removeIndex = new ArrayList(); + outer: + for(int i = 0; i < recipes.size(); i++) { + IRecipe recipe = recipes.get(i); + + if(recipe.getRecipeOutput().isEmpty() || !output.matches(getIItemStack(recipe.getRecipeOutput()))) { + continue; + } + + if(ingredients != null) { + if(recipe instanceof ShapedRecipes) { + ShapedRecipes srecipe = (ShapedRecipes) recipe; + if(ingredientsWidth != srecipe.recipeWidth || ingredientsHeight != srecipe.recipeHeight) { + continue; + } + + for(int j = 0; j < ingredientsHeight; j++) { + IIngredient[] row = ingredients[j]; + for(int k = 0; k < ingredientsWidth; k++) { + IIngredient ingredient = k > row.length ? null : row[k]; + ItemStack recipeIngredient = srecipe.recipeItems[j * srecipe.recipeWidth + k]; + + if(!matches(recipeIngredient, ingredient)) { + continue outer; + } + } + } + } else if(recipe instanceof ShapedOreRecipe) { + ShapedOreRecipe srecipe = (ShapedOreRecipe) recipe; + int recipeWidth = MineTweakerHacks.getShapedOreRecipeWidth(srecipe); + int recipeHeight = srecipe.getRecipeSize() / recipeWidth; + if(ingredientsWidth != recipeWidth || ingredientsHeight != recipeHeight) { + continue; + } + + for(int j = 0; j < ingredientsHeight; j++) { + IIngredient[] row = ingredients[j]; + for(int k = 0; k < ingredientsWidth; k++) { + IIngredient ingredient = k > row.length ? null : row[k]; + Object input = srecipe.getInput()[j * recipeWidth + k]; + if(!matches(input, ingredient)) { + continue outer; + } + } + } + } else { + if(recipe instanceof ShapelessRecipes) { + continue; + } else if(recipe instanceof ShapelessOreRecipe) { + continue; + } else { + } + } + } else { + if(recipe instanceof ShapelessRecipes) { + continue; + } else if(recipe instanceof ShapelessOreRecipe) { + continue; + } else { + } + } + + toRemove.add(recipe); + removeIndex.add(i); + } + + MineTweakerAPI.apply(new ActionRemoveRecipes(toRemove, removeIndex)); + return toRemove.size(); + } + + @Override + public int removeShapeless(IIngredient output, IIngredient[] ingredients, boolean wildcard) { + List toRemove = new ArrayList(); + List removeIndex = new ArrayList(); + outer: + for(int i = 0; i < recipes.size(); i++) { + IRecipe recipe = recipes.get(i); + + if(recipe.getRecipeOutput().isEmpty() || !output.matches(getIItemStack(recipe.getRecipeOutput()))) { + continue; + } + + if(ingredients != null) { + if(recipe instanceof ShapelessRecipes) { + ShapelessRecipes srecipe = (ShapelessRecipes) recipe; + + if(ingredients.length > srecipe.getRecipeSize()) { + continue; + } else if(!wildcard && ingredients.length < srecipe.getRecipeSize()) { + continue; + } + + checkIngredient: + for(int j = 0; j < ingredients.length; j++) { + for(int k = 0; k < srecipe.getRecipeSize(); k++) { + if(matches(srecipe.recipeItems.get(k), ingredients[j])) { + continue checkIngredient; + } + } + + continue outer; + } + } else if(recipe instanceof ShapelessOreRecipe) { + ShapelessOreRecipe srecipe = (ShapelessOreRecipe) recipe; + NonNullList inputs = srecipe.getInput(); + + if(inputs.size() < ingredients.length) { + continue; + } + if(!wildcard && inputs.size() > ingredients.length) { + continue; + } + + checkIngredient: + for(int j = 0; j < ingredients.length; j++) { + for(int k = 0; k < srecipe.getRecipeSize(); k++) { + if(matches(inputs.get(k), ingredients[j])) { + continue checkIngredient; + } + } + + continue outer; + } + } + if(recipe instanceof ShapedRecipes) { + continue; + } else if(recipe instanceof ShapedOreRecipe) { + continue; + } else { + } + } else { + if(recipe instanceof ShapedRecipes) { + continue; + } else if(recipe instanceof ShapedOreRecipe) { + continue; + } else { + + } + } + toRemove.add(recipe); + removeIndex.add(i); + } + + MineTweakerAPI.apply(new ActionRemoveRecipes(toRemove, removeIndex)); + return toRemove.size(); + } + + @Override + public IItemStack craft(IItemStack[][] contents) { + Container container = new ContainerVirtual(); + + int width = 0; + int height = contents.length; + for(IItemStack[] row : contents) { + width = Math.max(width, row.length); + } + + ItemStack[] iContents = new ItemStack[width * height]; + for(int i = 0; i < height; i++) { + for(int j = 0; j < contents[i].length; j++) { + if(contents[i][j] != null) { + iContents[i * width + j] = getItemStack(contents[i][j]); + } + } + } + + InventoryCrafting inventory = new InventoryCrafting(container, width, height); + for(int i = 0; i < iContents.length; i++) { + inventory.setInventorySlotContents(i, iContents[i]); + } + ItemStack result = CraftingManager.getInstance().findMatchingRecipe(inventory, null); + if(result.isEmpty()) { + return null; + } else { + return getIItemStack(result); + } + } + + private void addShaped(IItemStack output, IIngredient[][] ingredients, IRecipeFunction function, IRecipeAction action, boolean mirrored) { + ShapedRecipe recipe = new ShapedRecipe(output, ingredients, function, action, mirrored); + IRecipe irecipe = RecipeConverter.convert(recipe); + MineTweakerAPI.apply(new ActionAddRecipe(irecipe, recipe)); + } + + private class ContainerVirtual extends Container { + + @Override + public boolean canInteractWith(EntityPlayer var1) { + return false; + } + } + + public static class ActionRemoveRecipes implements IUndoableAction { + + private final List removingIndices; + private final List removingRecipes; + + public ActionRemoveRecipes(List recipes, List indices) { + this.removingIndices = indices; + this.removingRecipes = recipes; + } + + @Override + public void apply() { + for(int i = removingIndices.size() - 1; i >= 0; i--) { + recipes.remove((int) removingIndices.get(i)); + if(removingRecipes.get(i) != null) + MineTweakerAPI.getIjeiRecipeRegistry().removeRecipe(removingRecipes.get(i), "minecraft.crafting"); + } + } + + @Override + public boolean canUndo() { + return true; + } + + @Override + public void undo() { + for(int i = 0; i < removingIndices.size(); i++) { + int index = Math.min(recipes.size(), removingIndices.get(i)); + recipes.add(index, removingRecipes.get(i)); + if(removingRecipes.get(i) != null) + MineTweakerAPI.getIjeiRecipeRegistry().addRecipe(removingRecipes.get(i), "minecraft.crafting"); + } + } + + @Override + public String describe() { + return "Removing " + removingIndices.size() + " recipes"; + } + + @Override + public String describeUndo() { + return "Restoring " + removingIndices.size() + " recipes"; + } + + @Override + public Object getOverrideKey() { + return null; + } + } + + private class ActionAddRecipe implements IUndoableAction { + + private final IRecipe recipe; + private final ICraftingRecipe craftingRecipe; + + public ActionAddRecipe(IRecipe recipe, ICraftingRecipe craftingRecipe) { + this.recipe = recipe; + this.craftingRecipe = craftingRecipe; + } + + @Override + public void apply() { + recipes.add(recipe); + if(recipe instanceof ShapedRecipeBasic) { + ShapedRecipeBasic r = (ShapedRecipeBasic) recipe; + } + if(craftingRecipe.hasTransformers()) { + transformerRecipes.add(craftingRecipe); + } + if(recipe != null) + MineTweakerAPI.getIjeiRecipeRegistry().addRecipe(recipe, "minecraft.crafting"); + } + + @Override + public boolean canUndo() { + return true; + } + + @Override + public void undo() { + recipes.remove(recipe); + if(craftingRecipe.hasTransformers()) { + transformerRecipes.remove(craftingRecipe); + } + if(recipe != null) + MineTweakerAPI.getIjeiRecipeRegistry().removeRecipe(recipe,"minecraft.crafting"); + } + + @Override + public String describe() { + return "Adding recipe for " + recipe.getRecipeOutput().getDisplayName(); + } + + @Override + public String describeUndo() { + return "Removing recipe for " + recipe.getRecipeOutput().getDisplayName(); + } + + @Override + public Object getOverrideKey() { + return null; + } + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/recipes/RecipeConverter.java b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/recipes/RecipeConverter.java new file mode 100644 index 0000000..dd2a039 --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/recipes/RecipeConverter.java @@ -0,0 +1,169 @@ +package minetweaker.mc1112.recipes; + +import minetweaker.api.item.*; +import minetweaker.api.minecraft.MineTweakerMC; +import minetweaker.api.recipes.*; +import net.minecraft.item.ItemStack; +import net.minecraft.item.crafting.*; +import net.minecraftforge.oredict.*; + +import java.util.*; + +import static minetweaker.api.minecraft.MineTweakerMC.getItemStack; + +/** + * @author Stan + */ +public class RecipeConverter { + + public static final int TYPE_ADVANCED = 0; + public static final int TYPE_ORE = 1; + public static final int TYPE_BASIC = 2; + + private RecipeConverter() { + } + + private static int getIngredientType(IIngredient pattern) { + Object internal = pattern.getInternal(); + if(internal == null) { + return TYPE_ADVANCED; + } else if(internal instanceof ItemStack) { + return TYPE_BASIC; + } else { + return TYPE_ORE; + } + } + + private static int getRecipeType(IIngredient[] ingredients) { + int type = TYPE_BASIC; + for(IIngredient ingredient : ingredients) { + type = Math.min(type, getIngredientType(ingredient)); + } + return type; + } + + public static IRecipe convert(ShapelessRecipe recipe) { + IIngredient[] ingredients = recipe.getIngredients(); + int type = getRecipeType(ingredients); + + if(type == TYPE_BASIC) { + ItemStack[] items = new ItemStack[ingredients.length]; + for(int i = 0; i < ingredients.length; i++) { + items[i] = getItemStack(ingredients[i]); + } + return new ShapelessRecipeBasic(items, recipe); + } else if(type == TYPE_ORE) { + Object[] items = new Object[ingredients.length]; + for(int i = 0; i < ingredients.length; i++) { + items[i] = ingredients[i].getInternal(); + } + return new ShapelessRecipeOre(items, recipe); + } else { + return new ShapelessRecipeAdvanced(recipe); + } + } + + public static IRecipe convert(ShapedRecipe recipe) { + IIngredient[] ingredients = recipe.getIngredients(); + byte[] posx = recipe.getIngredientsX(); + byte[] posy = recipe.getIngredientsY(); + + // determine recipe type + int type = getRecipeType(ingredients); + + // construct recipe + if(type == TYPE_BASIC) { + ItemStack[] basicIngredients = new ItemStack[recipe.getHeight() * recipe.getWidth()]; + for(int i = 0; i < ingredients.length; i++) { + basicIngredients[posx[i] + posy[i] * recipe.getWidth()] = getItemStack(ingredients[i]); + } + + return new ShapedRecipeBasic(basicIngredients, recipe); + } else if(type == TYPE_ORE) { + Object[] converted = new Object[recipe.getHeight() * recipe.getWidth()]; + for(int i = 0; i < ingredients.length; i++) { + converted[posx[i] + posy[i] * recipe.getWidth()] = ingredients[i].getInternal(); + } + + // arguments contents: + // 1) recipe patterns + // 2) characters + ingredients + + int counter = 0; + String[] parts = new String[recipe.getHeight()]; + ArrayList rarguments = new ArrayList(); + for(int i = 0; i < recipe.getHeight(); i++) { + char[] pattern = new char[recipe.getWidth()]; + for(int j = 0; j < recipe.getWidth(); j++) { + int off = i * recipe.getWidth() + j; + if(converted[off] == null) { + pattern[j] = ' '; + } else { + pattern[j] = (char) ('A' + counter); + rarguments.add(pattern[j]); + rarguments.add(converted[off]); + counter++; + } + } + parts[i] = new String(pattern); + } + + rarguments.addAll(0, Arrays.asList(parts)); + + return new ShapedRecipeOre(rarguments.toArray(), recipe); + } else { + return new ShapedRecipeAdvanced(recipe); + } + } + + public static ICraftingRecipe toCraftingRecipe(IRecipe recipe) { + IItemStack output = MineTweakerMC.getIItemStack(recipe.getRecipeOutput()); + + if(recipe instanceof ShapelessRecipes) { + ShapelessRecipes shapeless = (ShapelessRecipes) recipe; + + IIngredient[] ingredients = new IIngredient[shapeless.recipeItems.size()]; + for(int i = 0; i < ingredients.length; i++) { + ingredients[i] = MineTweakerMC.getIIngredient(shapeless.recipeItems.get(i)); + } + + return new ShapelessRecipe(output, ingredients, null, null); + } else if(recipe instanceof ShapedRecipes) { + ShapedRecipes shaped = (ShapedRecipes) recipe; + + IIngredient[][] ingredients = new IIngredient[shaped.recipeHeight][shaped.recipeWidth]; + for(int i = 0; i < shaped.recipeHeight; i++) { + for(int j = 0; j < shaped.recipeWidth; j++) { + ingredients[i][j] = MineTweakerMC.getIItemStack(shaped.recipeItems[i * shaped.recipeWidth + j]); + } + } + + return new ShapedRecipe(output, ingredients, null, null, false); + } else if(recipe instanceof ShapedOreRecipe) { + ShapedOreRecipe shaped = (ShapedOreRecipe) recipe; + + int width = (int) Math.sqrt(recipe.getRecipeSize()); + int height = recipe.getRecipeSize() / width; + + IIngredient[][] recipeIngredients = new IIngredient[height][width]; + for(int i = 0; i < height; i++) { + for(int j = 0; j < width; j++) { + recipeIngredients[i][j] = MineTweakerMC.getIIngredient(shaped.getInput()[i * width + j]); + } + } + + return new ShapedRecipe(output, recipeIngredients, null, null, false); + } else if(recipe instanceof ShapelessOreRecipe) { + ShapelessOreRecipe shapeless = (ShapelessOreRecipe) recipe; + + IIngredient[] ingredients = new IIngredient[shapeless.getRecipeSize()]; + for(int i = 0; i < ingredients.length; i++) { + ingredients[i] = MineTweakerMC.getIIngredient(shapeless.getInput().get(i)); + } + + return new ShapelessRecipe(output, ingredients, null, null); + } else { + return new UnknownRecipe(output); + } + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/recipes/ShapedRecipeAdvanced.java b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/recipes/ShapedRecipeAdvanced.java new file mode 100644 index 0000000..9cfc808 --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/recipes/ShapedRecipeAdvanced.java @@ -0,0 +1,54 @@ +package minetweaker.mc1112.recipes; + +import minetweaker.api.recipes.*; +import net.minecraft.inventory.InventoryCrafting; +import net.minecraft.item.ItemStack; +import net.minecraft.item.crafting.IRecipe; +import net.minecraft.util.NonNullList; +import net.minecraft.world.World; + +import static minetweaker.api.minecraft.MineTweakerMC.getItemStack; + +/** + * TODO: NEI integration for this kind of recipes. + * + * @author Stan + */ +public class ShapedRecipeAdvanced implements IRecipe, IMTRecipe { + + private final ShapedRecipe recipe; + + public ShapedRecipeAdvanced(ShapedRecipe recipe) { + this.recipe = recipe; + } + + @Override + public boolean matches(InventoryCrafting inventory, World world) { + return recipe.matches(MCCraftingInventory.get(inventory)); + } + + @Override + public ItemStack getCraftingResult(InventoryCrafting inventory) { + return getItemStack(recipe.getCraftingResult(MCCraftingInventory.get(inventory))).copy(); + } + + @Override + public int getRecipeSize() { + return recipe.getWidth() * recipe.getHeight(); + } + + @Override + public ItemStack getRecipeOutput() { + return getItemStack(recipe.getOutput()); + } + + @Override + public NonNullList getRemainingItems(InventoryCrafting inv) { + return NonNullList.create(); + } + + @Override + public ICraftingRecipe getRecipe() { + return recipe; + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/recipes/ShapedRecipeBasic.java b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/recipes/ShapedRecipeBasic.java new file mode 100644 index 0000000..8f107a1 --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/recipes/ShapedRecipeBasic.java @@ -0,0 +1,44 @@ +package minetweaker.mc1112.recipes; + +import minetweaker.api.item.IItemStack; +import minetweaker.api.recipes.*; +import net.minecraft.inventory.InventoryCrafting; +import net.minecraft.item.ItemStack; +import net.minecraft.item.crafting.ShapedRecipes; +import net.minecraft.world.World; + +import static minetweaker.api.minecraft.MineTweakerMC.getItemStack; + +/** + * @author Stan + */ +public class ShapedRecipeBasic extends ShapedRecipes implements IMTRecipe { + + private final ShapedRecipe recipe; + + public ShapedRecipeBasic(ItemStack[] basicInputs, ShapedRecipe recipe) { + super(recipe.getWidth(), recipe.getHeight(), basicInputs, getItemStack(recipe.getOutput())); + + this.recipe = recipe; + } + + @Override + public boolean matches(InventoryCrafting inventory, World world) { + return recipe.matches(MCCraftingInventory.get(inventory)); + } + + @Override + public ItemStack getCraftingResult(InventoryCrafting inventory) { + IItemStack result = recipe.getCraftingResult(MCCraftingInventory.get(inventory)); + if(result == null) { + return ItemStack.EMPTY; + } else { + return getItemStack(result).copy(); + } + } + + @Override + public ICraftingRecipe getRecipe() { + return recipe; + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/recipes/ShapedRecipeOre.java b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/recipes/ShapedRecipeOre.java new file mode 100644 index 0000000..3ccaf70 --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/recipes/ShapedRecipeOre.java @@ -0,0 +1,43 @@ +package minetweaker.mc1112.recipes; + +import minetweaker.api.recipes.*; +import net.minecraft.inventory.InventoryCrafting; +import net.minecraft.item.ItemStack; +import net.minecraft.world.World; +import net.minecraftforge.oredict.ShapedOreRecipe; + +import static minetweaker.api.minecraft.MineTweakerMC.getItemStack; + +/** + * @author Stan + */ +public class ShapedRecipeOre extends ShapedOreRecipe implements IMTRecipe { + + private final ShapedRecipe recipe; + + public ShapedRecipeOre(Object[] contents, ShapedRecipe recipe) { + super(getItemStack(recipe.getOutput()), contents); + + this.recipe = recipe; + } + + @Override + public boolean matches(InventoryCrafting inventory, World world) { + return recipe.matches(MCCraftingInventory.get(inventory)); + } + + @Override + public ItemStack getCraftingResult(InventoryCrafting inventory) { + if(recipe != null) { + if(recipe.getCraftingResult(MCCraftingInventory.get(inventory)) != null) { + return getItemStack(recipe.getCraftingResult(MCCraftingInventory.get(inventory))).copy(); + } + } + return ItemStack.EMPTY; + } + + @Override + public ICraftingRecipe getRecipe() { + return recipe; + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/recipes/ShapelessRecipeAdvanced.java b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/recipes/ShapelessRecipeAdvanced.java new file mode 100644 index 0000000..78a5377 --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/recipes/ShapelessRecipeAdvanced.java @@ -0,0 +1,52 @@ +package minetweaker.mc1112.recipes; + +import minetweaker.api.recipes.*; +import net.minecraft.inventory.InventoryCrafting; +import net.minecraft.item.ItemStack; +import net.minecraft.item.crafting.IRecipe; +import net.minecraft.util.NonNullList; +import net.minecraft.world.World; + +import static minetweaker.api.minecraft.MineTweakerMC.getItemStack; + +/** + * @author Stan + */ +public class ShapelessRecipeAdvanced implements IRecipe, IMTRecipe { + + private final ShapelessRecipe recipe; + + public ShapelessRecipeAdvanced(ShapelessRecipe recipe) { + this.recipe = recipe; + } + + @Override + public boolean matches(InventoryCrafting inventory, World world) { + return recipe.matches(MCCraftingInventory.get(inventory)); + } + + @Override + public ItemStack getCraftingResult(InventoryCrafting inventory) { + return getItemStack(recipe.getCraftingResult(MCCraftingInventory.get(inventory))).copy(); + } + + @Override + public int getRecipeSize() { + return recipe.getSize(); + } + + @Override + public ItemStack getRecipeOutput() { + return getItemStack(recipe.getOutput()); + } + + @Override + public NonNullList getRemainingItems(InventoryCrafting inv) { + return NonNullList.create(); + } + + @Override + public ICraftingRecipe getRecipe() { + return recipe; + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/recipes/ShapelessRecipeBasic.java b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/recipes/ShapelessRecipeBasic.java new file mode 100644 index 0000000..7d5b989 --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/recipes/ShapelessRecipeBasic.java @@ -0,0 +1,43 @@ +package minetweaker.mc1112.recipes; + +import minetweaker.api.recipes.*; +import net.minecraft.inventory.InventoryCrafting; +import net.minecraft.item.ItemStack; +import net.minecraft.item.crafting.ShapelessRecipes; +import net.minecraft.world.World; + +import java.util.Arrays; + +import static minetweaker.api.minecraft.MineTweakerMC.getItemStack; + +/** + * @author Stan + */ +public class ShapelessRecipeBasic extends ShapelessRecipes implements IMTRecipe { + + private final ShapelessRecipe recipe; + + public ShapelessRecipeBasic(ItemStack[] ingredients, ShapelessRecipe recipe) { + super(getItemStack(recipe.getOutput()), Arrays.asList(ingredients)); + + this.recipe = recipe; + } + + @Override + public boolean matches(InventoryCrafting inventory, World world) { + return recipe.matches(MCCraftingInventory.get(inventory)); + } + + @Override + public ItemStack getCraftingResult(InventoryCrafting inventory) { + if(recipe.getCraftingResult(MCCraftingInventory.get(inventory)) != null) { + return getItemStack(recipe.getCraftingResult(MCCraftingInventory.get(inventory))).copy(); + } + return ItemStack.EMPTY; + } + + @Override + public ICraftingRecipe getRecipe() { + return recipe; + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/recipes/ShapelessRecipeOre.java b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/recipes/ShapelessRecipeOre.java new file mode 100644 index 0000000..ad47b67 --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/recipes/ShapelessRecipeOre.java @@ -0,0 +1,38 @@ +package minetweaker.mc1112.recipes; + +import minetweaker.api.recipes.*; +import net.minecraft.inventory.InventoryCrafting; +import net.minecraft.item.ItemStack; +import net.minecraft.world.World; +import net.minecraftforge.oredict.ShapelessOreRecipe; + +import static minetweaker.api.minecraft.MineTweakerMC.getItemStack; + +/** + * @author Stan + */ +public class ShapelessRecipeOre extends ShapelessOreRecipe implements IMTRecipe { + + private final ShapelessRecipe recipe; + + public ShapelessRecipeOre(Object[] ingredients, ShapelessRecipe recipe) { + super(getItemStack(recipe.getOutput()), ingredients); + + this.recipe = recipe; + } + + @Override + public boolean matches(InventoryCrafting inventory, World world) { + return recipe.matches(MCCraftingInventory.get(inventory)); + } + + @Override + public ItemStack getCraftingResult(InventoryCrafting inventory) { + return getItemStack(recipe.getCraftingResult(MCCraftingInventory.get(inventory))).copy(); + } + + @Override + public ICraftingRecipe getRecipe() { + return recipe; + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/server/MCServer.java b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/server/MCServer.java new file mode 100644 index 0000000..52a5da1 --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/server/MCServer.java @@ -0,0 +1,186 @@ +package minetweaker.mc1112.server; + +import minetweaker.*; +import minetweaker.api.minecraft.MineTweakerMC; +import minetweaker.api.player.IPlayer; +import minetweaker.api.server.*; +import minetweaker.mc1112.MineTweakerMod; +import minetweaker.mc1112.player.*; +import net.minecraft.command.*; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.network.rcon.RConConsoleSource; +import net.minecraft.server.MinecraftServer; +import net.minecraft.server.management.UserListOps; +import net.minecraft.tileentity.CommandBlockBaseLogic; +import net.minecraft.util.math.BlockPos; +import stanhebben.zenscript.annotations.Optional; + +import java.util.*; + +/** + * @author Stan + */ +public class MCServer extends AbstractServer { + + private final MinecraftServer server; + + public MCServer(MinecraftServer server) { + this.server = server; + } + + private static IPlayer getPlayer(ICommandSender commandSender) { + if(commandSender instanceof EntityPlayer) { + return MineTweakerMC.getIPlayer((EntityPlayer) commandSender); + } else if(commandSender instanceof RConConsoleSource) { + return new RconPlayer(commandSender); + } else if(commandSender instanceof CommandBlockBaseLogic) { + return new CommandBlockPlayer(commandSender); + } else if(commandSender.getName().equals("Server")) { + return ServerPlayer.INSTANCE; + } else { + System.out.println("Unsupported command sender: " + commandSender + " defaulting to server player!"); + System.out.println("player name: " + commandSender.getName()); + System.out.println("Please report to mod author if this is incorrect!"); + return ServerPlayer.INSTANCE; + } + } + + @Override + public void addCommand(String name, String usage, String[] aliases, ICommandFunction function, @Optional ICommandValidator validator, @Optional ICommandTabCompletion completion) { + ICommand command = new MCCommand(name, usage, aliases, function, validator, completion); + MineTweakerAPI.apply(new AddCommandAction(command)); + } + + @Override + public boolean isOp(IPlayer player) { + if(player == ServerPlayer.INSTANCE) + return true; + + UserListOps ops = MineTweakerMod.server.getPlayerList().getOppedPlayers(); + if(server != null && server.isDedicatedServer() && ops != null) { + //TODO figure if this is correct + // return ops.func_152690_d() || ops.func_152700_a(player.getName()) != null || player instanceof RconPlayer; + return ops.isEmpty() || ops.getGameProfileFromName(player.getName()) != null || player instanceof RconPlayer; + } else { + return true; + } + } + + @Override + public boolean isCommandAdded(String name) { + return MineTweakerMod.server.getCommandManager().getCommands().containsKey(name); + } + + private class MCCommand implements ICommand { + + private final String name; + private final String usage; + private final List aliases; + private final ICommandFunction function; + private final ICommandValidator validator; + private final ICommandTabCompletion completion; + + public MCCommand(String name, String usage, String[] aliases, ICommandFunction function, ICommandValidator validator, ICommandTabCompletion completion) { + this.name = name; + this.usage = usage; + this.aliases = Arrays.asList(aliases); + this.function = function; + this.validator = validator; + this.completion = completion; + } + + @Override + public String getName() { + return name; + } + + @Override + public String getUsage(ICommandSender var1) { + return usage; + } + + @Override + public List getAliases() { + return aliases; + } + + + @Override + public void execute(MinecraftServer server, ICommandSender sender, String[] args) throws CommandException { + function.execute(args, getPlayer(sender)); + } + + @Override + public boolean checkPermission(MinecraftServer server, ICommandSender sender) { + if(validator == null) { + return true; + } else { + return validator.canExecute(getPlayer(sender)); + } + } + + @Override + public List getTabCompletions(MinecraftServer server, ICommandSender sender, String[] args, BlockPos pos) { + if(completion != null) { + return Arrays.asList(completion.getTabCompletionOptions(args, getPlayer(sender))); + } else { + return null; + } + } + + @Override + public boolean isUsernameIndex(String[] var1, int var2) { + return false; + } + + @Override + public int compareTo(ICommand o) { + return this.getName().compareTo(o.getName()); + } + } + + private class AddCommandAction implements IUndoableAction { + + private final ICommand command; + + public AddCommandAction(ICommand command) { + this.command = command; + } + + @Override + public void apply() { + CommandHandler ch = (CommandHandler) MineTweakerMod.server.getCommandManager(); + if(!ch.getCommands().containsValue(command)) + ch.registerCommand(command); + } + + @Override + public boolean canUndo() { + return true; + } + + @Override + public void undo() { + + } + + @Override + public String describe() { + CommandHandler ch = (CommandHandler) MineTweakerMod.server.getCommandManager(); + if(!ch.getCommands().containsValue(command)) + return "Adding command " + command.getName(); + return ""; + } + + @Override + public String describeUndo() { + return "tried to remove command: " + command.getName() + " failed. THIS IS NOT AN ERROR!"; + } + + @Override + public Object getOverrideKey() { + return null; + } + } + +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/server/ServerPlayer.java b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/server/ServerPlayer.java new file mode 100644 index 0000000..a70f822 --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/server/ServerPlayer.java @@ -0,0 +1,132 @@ +package minetweaker.mc1112.server; + +import minetweaker.api.chat.IChatMessage; +import minetweaker.api.data.IData; +import minetweaker.api.item.IItemStack; +import minetweaker.api.player.IPlayer; +import net.minecraft.util.text.*; +import net.minecraftforge.fml.server.FMLServerHandler; + +import java.awt.*; +import java.awt.datatransfer.*; +import java.io.IOException; +import java.net.URI; +import java.util.logging.*; + +/** + * @author Stan + */ +public class ServerPlayer implements IPlayer { + + public static final ServerPlayer INSTANCE = new ServerPlayer(); + + private ServerPlayer() { + + } + + @Override + public String getId() { + return "server"; + } + + @Override + public String getName() { + return "Server"; + } + + @Override + public IData getData() { + // TODO: implement + return null; + } + + @Override + public int getXP() { + return 0; + } + + @Override + public void setXP(int xp) { + + } + + @Override + public void removeXP(int xp) { + + } + + @Override + public void update(IData data) { + // TODO: implement + } + + @Override + public void sendChat(IChatMessage message) { + FMLServerHandler.instance().getServer().sendMessage((ITextComponent) message.getInternal()); + } + + @Override + public void sendChat(String message) { + FMLServerHandler.instance().getServer().sendMessage(new TextComponentString(message)); + } + + @Override + public int getHotbarSize() { + return 0; + } + + @Override + public IItemStack getHotbarStack(int i) { + return null; + } + + @Override + public int getInventorySize() { + return 0; + } + + @Override + public IItemStack getInventoryStack(int i) { + return null; + } + + @Override + public IItemStack getCurrentItem() { + return null; + } + + @Override + public boolean isCreative() { + return true; + } + + @Override + public boolean isAdventure() { + return false; + } + + @Override + public void openBrowser(String url) { + if(Desktop.isDesktopSupported()) { + try { + Desktop.getDesktop().browse(URI.create(url)); + } catch(IOException ex) { + Logger.getLogger(ServerPlayer.class.getName()).log(Level.SEVERE, null, ex); + } + } + } + + @Override + public void copyToClipboard(String value) { + if(Desktop.isDesktopSupported()) { + StringSelection stringSelection = new StringSelection(value); + Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard(); + clipboard.setContents(stringSelection, null); + } + } + + @Override + public void give(IItemStack stack) { + + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/util/MineTweakerHacks.java b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/util/MineTweakerHacks.java new file mode 100644 index 0000000..98be8d8 --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/util/MineTweakerHacks.java @@ -0,0 +1,238 @@ +package minetweaker.mc1112.util; + +import minetweaker.MineTweakerAPI; +import minetweaker.api.item.WeightedItemStack; +import minetweaker.api.minecraft.MineTweakerMC; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.inventory.*; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.*; +import net.minecraft.server.MinecraftServer; +import net.minecraft.util.*; +import net.minecraft.util.text.translation.*; +import net.minecraftforge.common.ForgeHooks; +import net.minecraftforge.oredict.*; + +import java.io.File; +import java.lang.reflect.*; +import java.util.*; +import java.util.logging.*; + +/** + * Common class for all runtime hacks (stuff requiring reflection). It is not + * unexpected to have it break with new minecraft versions and may need regular + * adjustment - as such, those have been collected here. + * + * @author Stan Hebben + */ +public class MineTweakerHacks { + + private static final Field NBTTAGLIST_TAGLIST; + private static final Field OREDICTIONARY_IDTOSTACK; + private static final Field OREDICTIONARY_IDTOSTACKUN; + private static final Field MINECRAFTSERVER_ANVILFILE; + private static final Field SHAPEDORERECIPE_WIDTH; + private static final Field INVENTORYCRAFTING_EVENTHANDLER; + private static final Field SLOTCRAFTING_PLAYER; + + private static final Field SEEDENTRY_SEED; + private static final Constructor SEEDENTRY_CONSTRUCTOR; + + static { + NBTTAGLIST_TAGLIST = getField(NBTTagList.class, MineTweakerObfuscation.NBTTAGLIST_TAGLIST); + OREDICTIONARY_IDTOSTACK = getField(OreDictionary.class, MineTweakerObfuscation.OREDICTIONARY_IDTOSTACK); + OREDICTIONARY_IDTOSTACKUN = getField(OreDictionary.class, MineTweakerObfuscation.OREDICTIONARY_IDTOSTACKUN); + MINECRAFTSERVER_ANVILFILE = getField(MinecraftServer.class, MineTweakerObfuscation.MINECRAFTSERVER_ANVILFILE); + SHAPEDORERECIPE_WIDTH = getField(ShapedOreRecipe.class, "width"); + INVENTORYCRAFTING_EVENTHANDLER = getField(InventoryCrafting.class, MineTweakerObfuscation.INVENTORYCRAFTING_EVENTHANDLER); + SLOTCRAFTING_PLAYER = getField(SlotCrafting.class, MineTweakerObfuscation.SLOTCRAFTING_PLAYER); + + + Class forgeSeedEntry = null; + try { + forgeSeedEntry = (Class) Class.forName("net.minecraftforge.common.ForgeHooks$SeedEntry"); + } catch(ClassNotFoundException ex) { + } + + SEEDENTRY_SEED = getField(forgeSeedEntry, "seed"); + + Constructor seedEntryConstructor = null; + + try { + seedEntryConstructor = forgeSeedEntry.getConstructor(ItemStack.class, int.class); + seedEntryConstructor.setAccessible(true); + } catch(NoSuchMethodException | SecurityException ex) { + Logger.getLogger(MineTweakerHacks.class.getName()).log(Level.SEVERE, null, ex); + } + + SEEDENTRY_CONSTRUCTOR = seedEntryConstructor; + } + + private MineTweakerHacks() { + } + + + public static List getTagList(NBTTagList list) { + if(NBTTAGLIST_TAGLIST == null) { + return null; + } + try { + return (List) NBTTAGLIST_TAGLIST.get(list); + } catch(IllegalArgumentException ex) { + return null; + } catch(IllegalAccessException ex) { + return null; + } + } + + public static List getSeeds() { + return getPrivateStaticObject(ForgeHooks.class, "seedList"); + } + + + public static Map getTranslations() { + return getPrivateObject(getPrivateStaticObject(I18n.class, "localizedName", "field_74839_a"), "languageList", "field_74816_c"); + } + + public static List> getOreIdStacks() { + try { + return (List>) OREDICTIONARY_IDTOSTACK.get(null); + } catch(IllegalAccessException ex) { + MineTweakerAPI.logError("ERROR - could not load ore dictionary stacks!"); + return null; + } + } + + public static List> getOreIdStacksUn() { + try { + return (List>) OREDICTIONARY_IDTOSTACKUN.get(null); + } catch(IllegalAccessException ex) { + MineTweakerAPI.logError("ERROR - could not load ore dictionary stacks!"); + return null; + } + } + + public static File getAnvilFile(MinecraftServer server) { + try { + return (File) MINECRAFTSERVER_ANVILFILE.get(server); + } catch(IllegalAccessException ex) { + MineTweakerAPI.logError("could not load anvil file!"); + return null; + } + } + + public static File getWorldDirectory(MinecraftServer server) { + if(server.isDedicatedServer()) { + return server.getFile("world"); + } else { + File worldsDir = getAnvilFile(server); + if(worldsDir == null) + return null; + + return new File(worldsDir, server.getFolderName()); + } + } + + public static int getShapedOreRecipeWidth(ShapedOreRecipe recipe) { + try { + return SHAPEDORERECIPE_WIDTH.getInt(recipe); + } catch(IllegalAccessException ex) { + MineTweakerAPI.logError("could not load anvil file!"); + return 3; + } + } + + public static Container getCraftingContainer(InventoryCrafting inventory) { + try { + return (Container) INVENTORYCRAFTING_EVENTHANDLER.get(inventory); + } catch(IllegalAccessException ex) { + MineTweakerAPI.logError("could not get inventory eventhandler"); + return null; + } + } + + public static EntityPlayer getCraftingSlotPlayer(SlotCrafting slot) { + try { + return (EntityPlayer) SLOTCRAFTING_PLAYER.get(slot); + } catch(IllegalAccessException ex) { + MineTweakerAPI.logError("could not get inventory eventhandler"); + return null; + } + } + + public static LanguageMap getStringTranslateInstance() { + try { + Field field = getField(LanguageMap.class, MineTweakerObfuscation.LANGUAGEMAP_INSTANCE); + return (LanguageMap) field.get(null); + } catch(IllegalAccessException ex) { + MineTweakerAPI.logError("could not get LanguageMap"); + return null; + } + } + + public static ItemStack getSeedEntrySeed(Object entry) { + try { + return (ItemStack) SEEDENTRY_SEED.get(entry); + } catch(IllegalAccessException ex) { + MineTweakerAPI.logError("could not get SeedEntry seed"); + return null; + } + } + + + public static WeightedRandom.Item constructSeedEntry(WeightedItemStack stack) { + try { + return SEEDENTRY_CONSTRUCTOR.newInstance(MineTweakerMC.getItemStack(stack.getStack()), (int) stack.getChance()); + } catch(InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException ex) { + MineTweakerAPI.logError("could not construct SeedEntry"); + } + + return null; + } + + public static T getPrivateStaticObject(Class cls, String... names) { + for(String name : names) { + try { + Field field = cls.getDeclaredField(name); + field.setAccessible(true); + return (T) field.get(null); + } catch(NoSuchFieldException | SecurityException | IllegalAccessException ignored) { + + } + } + + return null; + } + + public static T getPrivateObject(Object object, String... names) { + Class cls = object.getClass(); + for(String name : names) { + try { + Field field = cls.getDeclaredField(name); + field.setAccessible(true); + return (T) field.get(object); + } catch(NoSuchFieldException | SecurityException | IllegalAccessException ignored) { + + } + } + + return null; + } + + // ####################### + // ### Private Methods ### + // ####################### + + private static Field getField(Class cls, String... names) { + for(String name : names) { + try { + Field field = cls.getDeclaredField(name); + field.setAccessible(true); + return field; + } catch(NoSuchFieldException | SecurityException ignored) { + } + } + + return null; + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/util/MineTweakerObfuscation.java b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/util/MineTweakerObfuscation.java new file mode 100644 index 0000000..962eecd --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/util/MineTweakerObfuscation.java @@ -0,0 +1,19 @@ +package minetweaker.mc1112.util; + +/** + * @author Stanneke + */ +public class MineTweakerObfuscation { + + public static final String[] NBTTAGLIST_TAGLIST = {"tagList", "field_74747_a"}; + public static final String[] CRAFTINGMANAGER_RECIPES = {"recipes", "field_77597_b"}; + public static final String[] OREDICTIONARY_IDTOSTACK = {"idToStack"}; + public static final String[] OREDICTIONARY_IDTOSTACKUN = {"idToStackUn"}; + public static final String[] MINECRAFTSERVER_ANVILFILE = {"anvilFile", "field_71308_o"}; + public static final String[] INVENTORYCRAFTING_EVENTHANDLER = {"eventHandler", "field_70465_c"}; + public static final String[] SLOTCRAFTING_PLAYER = {"player", "field_75238_b"}; + public static final String[] LANGUAGEMAP_INSTANCE = {"instance", "field_74817_a"}; + + private MineTweakerObfuscation() { + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/util/MineTweakerPlatformUtils.java b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/util/MineTweakerPlatformUtils.java new file mode 100644 index 0000000..1dfa7c3 --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/util/MineTweakerPlatformUtils.java @@ -0,0 +1,40 @@ +package minetweaker.mc1112.util; + +import net.minecraft.entity.EntityLivingBase; +import net.minecraftforge.fml.client.FMLClientHandler; +import net.minecraftforge.fml.common.FMLCommonHandler; +import net.minecraftforge.fml.relauncher.Side; + +/** + * @author Stan + */ +public class MineTweakerPlatformUtils { + + private MineTweakerPlatformUtils() { + } + + public static Class getLivingEntityClass(String entityClassName) { + try { + Class entityClass = Class.forName(entityClassName); + if(!EntityLivingBase.class.isAssignableFrom(entityClass)) { + throw new RuntimeException("Not an entity class: " + entityClassName); + } + return (Class) entityClass; + } catch(ClassNotFoundException ex) { + throw new RuntimeException("entity class not found: " + entityClassName); + } + } + + public static String getLanguage() { + return FMLCommonHandler.instance().getSide() == Side.SERVER ? null : FMLClientHandler.instance().getCurrentLanguage(); + } + + public static boolean isLanguageActive(String lang) { + String current = getLanguage(); + return current != null && current.equals(lang); + } + + public static boolean isClient() { + return FMLCommonHandler.instance().getSide() == Side.CLIENT; + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/vanilla/MCLootRegistry.java b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/vanilla/MCLootRegistry.java new file mode 100644 index 0000000..cdc3dc2 --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/vanilla/MCLootRegistry.java @@ -0,0 +1,193 @@ +///* +// * To change this license header, choose License Headers in Project Properties. +// * To change this template file, choose Tools | Templates +// * and open the template in the editor. +// */ +// +//package minetweaker.mc1102.vanilla; +// +//import minetweaker.IUndoableAction; +//import minetweaker.MineTweakerAPI; +//import minetweaker.api.item.IIngredient; +//import minetweaker.api.item.WeightedItemStack; +//import minetweaker.api.minecraft.MineTweakerMC; +//import minetweaker.api.vanilla.ILootRegistry; +//import minetweaker.api.vanilla.LootEntry; +//import minetweaker.mc1102.util.MineTweakerHacks; +//import net.minecraft.item.ItemStack; +//import net.minecraft.world.storage.loot.LootEntryItem; +//import net.minecraft.world.storage.loot.functions.LootFunction; +//import net.minecraft.world.storage.loot.functions.LootFunctionManager; +// +//import java.util.*; +// +///** +// * @author Stan +// */ +//public class MCLootRegistry implements ILootRegistry{ +// private static final Map> LOOT = new HashMap>(); +// +// @Override +// public void addChestLoot(String type, WeightedItemStack item){ +// LootEntryItem content = new LootEntryItem(MineTweakerMC.getItemStack(item.getStack()).getItem(), 1, 1, (int) item.getChance()); +// WeightedItemStack sta = new WeightedItemStack(); +// MineTweakerAPI.apply(new AddLootAction(type, content)); +// LootFunctionManager.getSerializerFor() +// } +// +// //addEntry(new LootEntryItem(ITEM, WEIGHT, QUALITY, FUNCTIONS, CONDITIONS, NAME)); +// @Override +// public void addChestLoot(String type, WeightedItemStack item, int min, int max){ +// WeightedRandomChestContent content = new WeightedRandomChestContent(MineTweakerMC.getItemStack(item.getStack()), min, max, (int) item.getChance()); +// MineTweakerAPI.apply(new AddLootAction(type, content)); +// } +// +// @Override +// public void removeChestLoot(String type, IIngredient pattern){ +// MineTweakerAPI.apply(new RemoveLootAction(type, pattern)); +// } +// +// @Override +// public List getLoot(String type){ +// ChestGenHooks recipe = LOOT.get(type); +// List contents = MineTweakerHacks.getPrivateObject(recipe, "contents"); +// +// List results = new ArrayList(); +// for(WeightedRandomChestContent content : contents){ +// results.add(new LootEntry(new WeightedItemStack(MineTweakerMC.getIItemStack(content.theItemId), content.itemWeight), content.theMinimumChanceToGenerateItem, content.theMaximumChanceToGenerateItem)); +// } +// return results; +// } +// +// @Override +// public List getLootTypes(){ +// Set keys = LOOT.keySet(); +// List keyList = new ArrayList(); +// keyList.addAll(keys); +// return keyList; +// } +// +// // ###################### +// // ### Action Classes ### +// // ###################### +// +// /** +// * Ported from ModTweaker. +// * +// * @author JoshieJack +// */ +// private static class AddLootAction implements IUndoableAction{ +// private final String chest; +// private final WeightedRandomChestContent content; +// +// public AddLootAction(String chest, WeightedRandomChestContent content){ +// this.chest = chest; +// this.content = content; +// } +// +// @Override +// public void apply(){ +// ChestGenHooks recipe = LOOT.get(chest); +// List contents = MineTweakerHacks.getPrivateObject(recipe, "contents"); +// +// contents.add(content); +// } +// +// @Override +// public boolean canUndo(){ +// return true; +// } +// +// @Override +// public void undo(){ +// ChestGenHooks recipe = LOOT.get(chest); +// List contents = MineTweakerHacks.getPrivateObject(recipe, "contents"); +// +// contents.remove(content); +// } +// +// public String getRecipeInfo(){ +// return content.theItemId.getDisplayName(); +// } +// +// @Override +// public String describe(){ +// return "Adding chest loot " + content.theItemId.getDisplayName() + " to loot class " + chest; +// } +// +// @Override +// public String describeUndo(){ +// return "Removing chest loot " + content.theItemId.getDisplayName() + " from loot class " + chest; +// } +// +// @Override +// public Object getOverrideKey(){ +// return null; +// } +// } +// +// /** +// * Ported from ModTweaker. +// * +// * @author JoshieJack +// */ +// private static class RemoveLootAction implements IUndoableAction{ +// private final String chest; +// private final IIngredient pattern; +// private final List removed; +// +// public RemoveLootAction(String chest, IIngredient pattern){ +// this.chest = chest; +// this.pattern = pattern; +// removed = new ArrayList(); +// } +// +// @Override +// public void apply(){ +// removed.clear(); +// +// ChestGenHooks recipe = LOOT.get(chest); +// List contents = MineTweakerHacks.getPrivateObject(recipe, "contents"); +// +// for(WeightedRandomChestContent r : contents){ +// if(pattern.matches(MineTweakerMC.getIItemStack(r.theItemId))){ +// removed.add(r); +// } +// } +// +// for(WeightedRandomChestContent r : removed){ +// contents.remove(r); +// } +// } +// +// @Override +// public boolean canUndo(){ +// return true; +// } +// +// @Override +// public void undo(){ +// ChestGenHooks recipe = LOOT.get(chest); +// List contents = MineTweakerHacks.getPrivateObject(recipe, "contents"); +// +// for(WeightedRandomChestContent entry : removed){ +// contents.add(entry); +// } +// } +// +// @Override +// public String describe(){ +// return "Removing chest loot " + pattern + " for loot type " + chest; +// } +// +// @Override +// public String describeUndo(){ +// return "Restoring chest loot " + pattern + " for loot type " + chest + " (" + removed.size() + " entries)"; +// } +// +// @Override +// public Object getOverrideKey(){ +// return null; +// } +// } +//} diff --git a/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/vanilla/MCSeedRegistry.java b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/vanilla/MCSeedRegistry.java new file mode 100644 index 0000000..fbbf4de --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/vanilla/MCSeedRegistry.java @@ -0,0 +1,134 @@ +package minetweaker.mc1112.vanilla; + +import minetweaker.*; +import minetweaker.api.item.*; +import minetweaker.api.minecraft.MineTweakerMC; +import minetweaker.api.vanilla.ISeedRegistry; +import minetweaker.mc1112.util.MineTweakerHacks; +import net.minecraft.item.ItemStack; +import net.minecraft.util.WeightedRandom; + +import java.util.*; +import java.util.stream.Collectors; + +/** + * @author Stan + */ +public class MCSeedRegistry implements ISeedRegistry { + + private static final List SEEDS = MineTweakerHacks.getSeeds(); + + @Override + public void addSeed(WeightedItemStack item) { + MineTweakerAPI.apply(new AddSeedAction(item)); + } + + @Override + public void removeSeed(IIngredient pattern) { + MineTweakerAPI.apply(new RemoveSeedAction(pattern)); + } + + @Override + public List getSeeds() { + List entries = (List) SEEDS; + + return entries.stream().map(entry -> new WeightedItemStack(MineTweakerMC.getIItemStack(MineTweakerHacks.getSeedEntrySeed(entry)), entry.itemWeight)).collect(Collectors.toList()); + } + + // ###################### + // ### Action classes ### + // ###################### + + private static class AddSeedAction implements IUndoableAction { + + private final IItemStack item; + private final WeightedRandom.Item entry; + + public AddSeedAction(WeightedItemStack item) { + this.item = item.getStack(); + entry = MineTweakerHacks.constructSeedEntry(item); + } + + @Override + public void apply() { + SEEDS.add(entry); + } + + @Override + public boolean canUndo() { + return true; + } + + @Override + public void undo() { + SEEDS.remove(entry); + } + + @Override + public String describe() { + return "Adding seed entry " + item; + } + + @Override + public String describeUndo() { + return "Removing seed entry " + item; + } + + @Override + public Object getOverrideKey() { + return null; + } + } + + private static class RemoveSeedAction implements IUndoableAction { + + private final IIngredient pattern; + private final List removed; + + public RemoveSeedAction(IIngredient ingredient) { + this.pattern = ingredient; + removed = new ArrayList<>(); + } + + @Override + public void apply() { + removed.clear(); + + for(Object entry : SEEDS) { + ItemStack itemStack = MineTweakerHacks.getSeedEntrySeed(entry); + if(pattern.matches(MineTweakerMC.getIItemStack(itemStack))) { + removed.add(entry); + } + } + + for(Object entry : removed) { + SEEDS.remove(entry); + } + } + + @Override + public boolean canUndo() { + return true; + } + + @Override + public void undo() { + SEEDS.addAll(removed); + } + + @Override + public String describe() { + return "Removing seeds " + pattern; + } + + @Override + public String describeUndo() { + return "Restoring seeds " + pattern + " (" + removed.size() + " entries)"; + } + + @Override + public Object getOverrideKey() { + return null; + } + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/vanilla/MCVanilla.java b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/vanilla/MCVanilla.java new file mode 100644 index 0000000..4c24321 --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/vanilla/MCVanilla.java @@ -0,0 +1,22 @@ +package minetweaker.mc1112.vanilla; + +import minetweaker.api.vanilla.*; + +/** + * @author Stan + */ +public class MCVanilla implements IVanilla { + + // private final MCLootRegistry lootRegistry = new MCLootRegistry(); + private final MCSeedRegistry seedRegistry = new MCSeedRegistry(); + + @Override + public ILootRegistry getLoot() { + return null; + } + + @Override + public ISeedRegistry getSeeds() { + return seedRegistry; + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/world/MCBiome.java b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/world/MCBiome.java new file mode 100644 index 0000000..04c991d --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/world/MCBiome.java @@ -0,0 +1,21 @@ +package minetweaker.mc1112.world; + +import minetweaker.api.world.IBiome; +import net.minecraft.world.biome.Biome; + +/** + * @author Stan + */ +public class MCBiome implements IBiome { + + private final Biome biome; + + public MCBiome(Biome biome) { + this.biome = biome; + } + + @Override + public String getName() { + return biome.getBiomeName(); + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/world/MCDimension.java b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/world/MCDimension.java new file mode 100644 index 0000000..2427334 --- /dev/null +++ b/MineTweaker3-MC1112-Main/src/main/java/minetweaker/mc1112/world/MCDimension.java @@ -0,0 +1,39 @@ +package minetweaker.mc1112.world; + +import minetweaker.api.block.IBlock; +import minetweaker.api.minecraft.MineTweakerMC; +import minetweaker.api.world.IDimension; +import net.minecraft.util.math.BlockPos; +import net.minecraft.world.World; + +/** + * @author Stan + */ +public class MCDimension implements IDimension { + + private final World world; + + public MCDimension(World world) { + this.world = world; + } + + @Override + public boolean isDay() { + return world.isDaytime(); + } + + @Override + public int getBrightness(int x, int y, int z) { + return world.getLight(new BlockPos(x, y, z)); + } + + @Override + public IDimension getDimension() { + return this; + } + + @Override + public IBlock getBlock(int x, int y, int z) { + return MineTweakerMC.getBlock(world, x, y, z); + } +} diff --git a/MineTweaker3-MC1112-Main/src/main/resources/assets/minetweaker/logo.png b/MineTweaker3-MC1112-Main/src/main/resources/assets/minetweaker/logo.png new file mode 100644 index 0000000000000000000000000000000000000000..674382e31e87dcb701bc76ebb1fba5aad1e13b48 GIT binary patch literal 21583 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%0DJ4FZk2jt}6##lUY5Q%5qw<&z#}$WK+ngW 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

1~+ttL5k5>^+S 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

xbLvl-pDl(E)6Gmh@yE0y$ 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 z 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

    nYM}D>a;fzQi^o? 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 WBy-ScyV~q(leq + * Enables hiding JEI items as well as adding new item stacks. These item stacks + * can then show a custom message or contain NBT data. Can be used to show a + * custom message or lore with certain items, or to provide spawnable items with + * specific NBT tags. + * + * @author Stan Hebben + */ +@ZenClass("mods.jei.JEI") +public class JEI { + + + @ZenMethod + public static void hide(IItemStack stack) { + MineTweakerAPI.apply(new Hide(getItemStack(stack))); + } + + + @ZenMethod + public static void removeAndHide(IIngredient output, @Optional boolean nbtMatch) { + List toRemove = new ArrayList<>(); + List removeIndex = new ArrayList<>(); + for(int i = 0; i < recipes.size(); i++) { + IRecipe recipe = recipes.get(i); + if(!recipe.getRecipeOutput().isEmpty()) { + if(nbtMatch ? output.matchesExact(getIItemStack(recipe.getRecipeOutput())) : output.matches(getIItemStack(recipe.getRecipeOutput()))) { + toRemove.add(recipe); + removeIndex.add(i); + } + } + } + + MineTweakerAPI.apply(new MCRecipeManager.ActionRemoveRecipes(toRemove, removeIndex)); + for(IItemStack stack : output.getItems()) { + MineTweakerAPI.apply(new Hide(getItemStack(stack))); + } + + } + + private static class Hide implements IUndoableAction { + + private ItemStack stack; + + public Hide(ItemStack stack) { + this.stack = stack; + } + + @Override + public void apply() { + if(FMLCommonHandler.instance().getEffectiveSide() == Side.SERVER) + PacketHandler.INSTANCE.sendToAll(new MessageJEIHide(true, stack)); + else + JEIAddonPlugin.itemRegistry.removeIngredientsAtRuntime(ItemStack.class, JEIAddonPlugin.getSubTypes(stack)); + } + + @Override + public boolean canUndo() { + return true; + } + + @Override + public void undo() { + if(FMLCommonHandler.instance().getEffectiveSide() == Side.SERVER) + PacketHandler.INSTANCE.sendToAll(new MessageJEIHide(false, stack)); + else + JEIAddonPlugin.itemRegistry.addIngredientsAtRuntime(ItemStack.class, JEIAddonPlugin.getSubTypes(stack)); + } + + @Override + public String describe() { + return "Hiding item in JEI: " + stack; + } + + @Override + public String describeUndo() { + return "Displaying item in JEI: " + stack; + } + + @Override + public Object getOverrideKey() { + return null; + } + } + +} diff --git a/MineTweaker3-MC1112-Mod-JEI/src/main/java/minetweaker/mods/jei/JEIAddonPlugin.java b/MineTweaker3-MC1112-Mod-JEI/src/main/java/minetweaker/mods/jei/JEIAddonPlugin.java new file mode 100644 index 0000000..57defa2 --- /dev/null +++ b/MineTweaker3-MC1112-Mod-JEI/src/main/java/minetweaker/mods/jei/JEIAddonPlugin.java @@ -0,0 +1,56 @@ +package minetweaker.mods.jei; + +import mezz.jei.api.*; +import mezz.jei.api.ingredients.*; +import mezz.jei.api.recipe.IRecipeCategoryRegistration; +import minetweaker.MineTweakerAPI; +import minetweaker.api.compat.DummyJEIRecipeRegistry; +import net.minecraft.item.ItemStack; + +import java.util.Collections; +import java.util.List; + + +@mezz.jei.api.JEIPlugin +public class JEIAddonPlugin implements IModPlugin { + + public static IJeiHelpers jeiHelpers; + public static IIngredientRegistry itemRegistry; + public static IRecipeRegistry recipeRegistry; + public static IIngredientHelper ingredientHelper; + + @Override + public void registerItemSubtypes(ISubtypeRegistry subtypeRegistry) { + + } + + @Override + public void registerIngredients(IModIngredientRegistration registry) { + + } + + @Override + public void registerCategories(IRecipeCategoryRegistration registry) { + + } + + @Override + public void register(IModRegistry registry) { + jeiHelpers = registry.getJeiHelpers(); + itemRegistry = registry.getIngredientRegistry(); + ingredientHelper = itemRegistry.getIngredientHelper(ItemStack.class); + } + + @Override + public void onRuntimeAvailable(IJeiRuntime iJeiRuntime) { + recipeRegistry = iJeiRuntime.getRecipeRegistry(); + + if(MineTweakerAPI.getIjeiRecipeRegistry() instanceof DummyJEIRecipeRegistry) { + MineTweakerAPI.setIjeiRecipeRegistry(new JEIRecipeRegistry(recipeRegistry, jeiHelpers)); + } + } + + public static List getSubTypes(ItemStack stack) { + return JEIAddonPlugin.ingredientHelper.expandSubtypes(Collections.singletonList(stack)); + } +} diff --git a/MineTweaker3-MC1112-Mod-JEI/src/main/java/minetweaker/mods/jei/JEIMod.java b/MineTweaker3-MC1112-Mod-JEI/src/main/java/minetweaker/mods/jei/JEIMod.java new file mode 100644 index 0000000..001c2bb --- /dev/null +++ b/MineTweaker3-MC1112-Mod-JEI/src/main/java/minetweaker/mods/jei/JEIMod.java @@ -0,0 +1,19 @@ +package minetweaker.mods.jei; + +import minetweaker.MineTweakerAPI; +import minetweaker.MineTweakerImplementationAPI; +import minetweaker.mods.jei.network.PacketHandler; +import net.minecraftforge.fml.common.*; +import net.minecraftforge.fml.common.event.FMLPreInitializationEvent; + +@Mod(modid = "crafttweakerjei", name = "CraftTweaker JEI Support", version = "1.0.2", dependencies = "required-before:crafttweaker;") +public class JEIMod { + + @Mod.EventHandler + public void preInit(FMLPreInitializationEvent ev) { + if(Loader.isModLoaded("jei")) { + MineTweakerAPI.registerClass(JEI.class); + } + PacketHandler.init(); + } +} diff --git a/MineTweaker3-MC1112-Mod-JEI/src/main/java/minetweaker/mods/jei/JEIRecipeRegistry.java b/MineTweaker3-MC1112-Mod-JEI/src/main/java/minetweaker/mods/jei/JEIRecipeRegistry.java new file mode 100644 index 0000000..feb33f3 --- /dev/null +++ b/MineTweaker3-MC1112-Mod-JEI/src/main/java/minetweaker/mods/jei/JEIRecipeRegistry.java @@ -0,0 +1,130 @@ +package minetweaker.mods.jei; + +import mezz.jei.api.*; +import mezz.jei.api.recipe.*; +import mezz.jei.ingredients.IngredientInformation; +import mezz.jei.plugins.vanilla.furnace.*; +import minetweaker.api.compat.IJEIRecipeRegistry; +import minetweaker.api.item.IIngredient; +import minetweaker.mc1112.util.MineTweakerHacks; +import minetweaker.mods.jei.network.MessageJEIHide; +import minetweaker.mods.jei.network.PacketHandler; +import net.minecraft.item.ItemStack; +import net.minecraftforge.fml.common.FMLCommonHandler; +import net.minecraftforge.fml.relauncher.Side; + +import java.util.*; + +public class JEIRecipeRegistry implements IJEIRecipeRegistry { + + private IRecipeRegistry recipeRegistry; + private IJeiHelpers jeiHelpers; + private static Map> TOOLTIP_CACHE; + + public JEIRecipeRegistry(IRecipeRegistry recipeRegistry, IJeiHelpers jeiHelpers) { + this.recipeRegistry = recipeRegistry; + this.jeiHelpers = jeiHelpers; + } + + @Override + public void addRecipe(Object object) { + recipeRegistry.addRecipe(object); + } + + @Override + public void addRecipe(Object object, String category) { + if(recipeRegistry.getRecipeWrapper(object, category) != null) + recipeRegistry.addRecipe(recipeRegistry.getRecipeWrapper(object, category), category); + } + + @Override + public void removeRecipe(Object object) { + recipeRegistry.removeRecipe(object); + } + + @Override + public void removeRecipe(Object output, String category) { + if(recipeRegistry.getRecipeWrapper(output, category) != null) + recipeRegistry.removeRecipe(recipeRegistry.getRecipeWrapper(output, category), category); + } + + @Override + public void addFurnace(List input, Object output) { + List inputs = new ArrayList<>(); + input.forEach(in -> { + inputs.add((ItemStack) in); + }); + recipeRegistry.addRecipe(new SmeltingRecipe(inputs, (ItemStack) output), VanillaRecipeCategoryUid.SMELTING); + } + + + @Override + public void removeFurnace(Object object) { + List stacks = JEIAddonPlugin.getSubTypes((ItemStack) object); + for (ItemStack itemStack : stacks) { + IFocus focus = recipeRegistry.createFocus(IFocus.Mode.INPUT, itemStack); + List categories = recipeRegistry.getRecipeCategories(Collections.singletonList(VanillaRecipeCategoryUid.SMELTING)); + for(IRecipeCategory category : categories) { + if(category.getUid().equals(VanillaRecipeCategoryUid.SMELTING)) { + List wrappers = recipeRegistry.getRecipeWrappers(category, focus); + for(IRecipeWrapper wrapper : wrappers) { + recipeRegistry.removeRecipe(wrapper, VanillaRecipeCategoryUid.SMELTING); + } + } + } + } + } + + public void addFuel(Collection input, int burnTime){ + List inputs = new ArrayList<>(); + input.forEach(in -> { + inputs.add((ItemStack) in); + }); + recipeRegistry.addRecipe(new FuelRecipe(jeiHelpers.getGuiHelper(), inputs, burnTime), VanillaRecipeCategoryUid.FUEL); + } + + public void removeFuel(Object object){ + IFocus focus = recipeRegistry.createFocus(IFocus.Mode.INPUT, (ItemStack) object); + List categories = recipeRegistry.getRecipeCategories(focus); + for(IRecipeCategory category : categories) { + if(category.getUid().equals(VanillaRecipeCategoryUid.FUEL)) { + List wrappers = recipeRegistry.getRecipeWrappers(category, focus); + for(IRecipeWrapper wrapper : wrappers) { + recipeRegistry.removeRecipe(wrapper, VanillaRecipeCategoryUid.SMELTING); + } + } + } + } + + // Unused in 1.11.2 + @Override + public void reloadItemList() {} + + @Override + public void removeItem(Object stack) { + if (FMLCommonHandler.instance().getSide() == Side.SERVER) + PacketHandler.INSTANCE.sendToAll(new MessageJEIHide(true, (ItemStack) stack)); + else + JEIAddonPlugin.itemRegistry.removeIngredientsAtRuntime(ItemStack.class, JEIAddonPlugin.getSubTypes((ItemStack) stack)); + } + + @Override + public void addItem(Object stack) { + if (FMLCommonHandler.instance().getSide() == Side.SERVER) + PacketHandler.INSTANCE.sendToAll(new MessageJEIHide(false, (ItemStack) stack)); + else + JEIAddonPlugin.itemRegistry.addIngredientsAtRuntime(ItemStack.class, JEIAddonPlugin.getSubTypes((ItemStack) stack)); + } + + @Override + public void invalidateTooltips(IIngredient ingredient) { + if (TOOLTIP_CACHE == null) + TOOLTIP_CACHE = MineTweakerHacks.getPrivateStaticObject(IngredientInformation.class, "TOOLTIP_CACHE"); + + if (TOOLTIP_CACHE != null) { + TOOLTIP_CACHE.clear(); + removeItem(ingredient.getInternal()); + addItem(ingredient.getInternal()); + } + } +} diff --git a/MineTweaker3-MC1112-Mod-JEI/src/main/java/minetweaker/mods/jei/network/MessageJEIHide.java b/MineTweaker3-MC1112-Mod-JEI/src/main/java/minetweaker/mods/jei/network/MessageJEIHide.java new file mode 100644 index 0000000..d70f642 --- /dev/null +++ b/MineTweaker3-MC1112-Mod-JEI/src/main/java/minetweaker/mods/jei/network/MessageJEIHide.java @@ -0,0 +1,51 @@ +package minetweaker.mods.jei.network; + +import io.netty.buffer.ByteBuf; +import minetweaker.mods.jei.JEIAddonPlugin; +import net.minecraft.client.Minecraft; +import net.minecraft.item.ItemStack; +import net.minecraftforge.fml.common.network.ByteBufUtils; +import net.minecraftforge.fml.common.network.simpleimpl.*; + +import java.util.*; + +public class MessageJEIHide implements IMessage, IMessageHandler { + + private boolean hide; + private ItemStack subTypes; + + public MessageJEIHide() { + } + + public MessageJEIHide(boolean hide, ItemStack sybTypes) { + this.hide = hide; + this.subTypes = sybTypes; + } + + @Override + public void fromBytes(ByteBuf buf) { + hide = buf.readBoolean(); + subTypes = ByteBufUtils.readItemStack(buf); + } + + @Override + public void toBytes(ByteBuf buf) { + buf.writeBoolean(hide); + ByteBufUtils.writeItemStack(buf, subTypes); + } + + @Override + public IMessage onMessage(MessageJEIHide message, MessageContext ctx) { + Minecraft.getMinecraft().addScheduledTask(() -> handle(message, ctx)); + return null; + } + + private void handle(MessageJEIHide message, MessageContext ctx) { + if(message.hide) { + JEIAddonPlugin.itemRegistry.removeIngredientsAtRuntime(ItemStack.class, JEIAddonPlugin.getSubTypes(message.subTypes)); + } else { + JEIAddonPlugin.itemRegistry.addIngredientsAtRuntime(ItemStack.class, JEIAddonPlugin.getSubTypes(message.subTypes)); + } + } + +} diff --git a/MineTweaker3-MC1112-Mod-JEI/src/main/java/minetweaker/mods/jei/network/PacketHandler.java b/MineTweaker3-MC1112-Mod-JEI/src/main/java/minetweaker/mods/jei/network/PacketHandler.java new file mode 100644 index 0000000..9929d9b --- /dev/null +++ b/MineTweaker3-MC1112-Mod-JEI/src/main/java/minetweaker/mods/jei/network/PacketHandler.java @@ -0,0 +1,15 @@ +package minetweaker.mods.jei.network; + +import net.minecraftforge.fml.common.network.NetworkRegistry; +import net.minecraftforge.fml.common.network.simpleimpl.SimpleNetworkWrapper; +import net.minecraftforge.fml.relauncher.Side; + +public class PacketHandler { + + public static final SimpleNetworkWrapper INSTANCE = NetworkRegistry.INSTANCE.newSimpleChannel("crafttweakerjei"); + + public static void init() { + INSTANCE.registerMessage(MessageJEIHide.class, MessageJEIHide.class, 0, Side.CLIENT); + } + +}