From 45260967107e94ecee605eee44888364d6edebc6 Mon Sep 17 00:00:00 2001 From: Quie_ Date: Sat, 30 Dec 2023 13:42:28 -0500 Subject: [PATCH 01/29] In the push to update the mod to 1.20.4, the gradle.properties, build.gradle, and fabric.mod.json were changed to account for any versioning. Then the command "gradlew migrateMappings --mappings "1.20.4+build.3" was run to fix mixin errors. After that, the Gradle was updated from 8.1.1 to 8.5 due to a need by 1.20.4 Fabric. Finally, the migrateMappings command made a new src folder and copied everything over with the fixed mixins. As such I've named the old src file "oldSrc" until we decide to delete it. --- build.gradle | 4 +- gradle.properties | 10 +- gradle/wrapper/gradle-wrapper.properties | 2 +- .../redstonetools/RedstoneToolsClient.java | 42 +++ .../redstonetools/RedstoneToolsGameRules.java | 23 ++ .../redstonetools/di/FeatureModule.java | 18 ++ .../redstonetools/di/UtilityModule.java | 15 + .../features/AbstractFeature.java | 60 ++++ .../redstonetools/features/Feature.java | 16 ++ .../features/arguments/Argument.java | 80 ++++++ .../serializers/BigIntegerSerializer.java | 33 +++ .../serializers/BlockColorSerializer.java | 15 + .../BlockStateArgumentSerializer.java | 60 ++++ .../arguments/serializers/BoolSerializer.java | 23 ++ .../serializers/BrigadierSerializer.java | 38 +++ .../serializers/CollectionSerializer.java | 176 ++++++++++++ .../ColoredBlockTypeSerializer.java | 15 + .../serializers/DirectionSerializer.java | 15 + .../serializers/DoubleSerializer.java | 31 +++ .../arguments/serializers/EnumSerializer.java | 80 ++++++ .../serializers/FloatSerializer.java | 31 +++ .../serializers/IntLikeSerializer.java | 129 +++++++++ .../serializers/IntegerSerializer.java | 32 +++ .../arguments/serializers/LongSerializer.java | 32 +++ .../serializers/MacroNameSerializer.java | 35 +++ .../serializers/NumberBaseSerializer.java | 75 +++++ .../serializers/NumberSerializer.java | 34 +++ .../serializers/SignalBlockSerializer.java | 15 + .../StringBrigadierSerializer.java | 22 ++ .../serializers/StringSerializer.java | 34 +++ .../arguments/serializers/TypeSerializer.java | 47 ++++ .../features/commands/BaseConvertFeature.java | 32 +++ .../commands/BinaryBlockReadFeature.java | 101 +++++++ .../commands/BlockRaycastFeature.java | 42 +++ .../features/commands/ColorCodeFeature.java | 113 ++++++++ .../features/commands/ColoredFeature.java | 38 +++ .../features/commands/CommandFeature.java | 78 ++++++ .../features/commands/CopyStateFeature.java | 48 ++++ .../features/commands/ItemBindFeature.java | 53 ++++ .../features/commands/MacroFeature.java | 31 +++ .../commands/MinSelectionFeature.java | 126 +++++++++ .../features/commands/PickBlockFeature.java | 45 +++ .../features/commands/QuickTpFeature.java | 60 ++++ .../features/commands/RStackFeature.java | 98 +++++++ .../commands/SignalStrengthBlockFeature.java | 53 ++++ .../commands/update/RegionUpdater.java | 28 ++ .../commands/update/UpdateFeature.java | 28 ++ .../feedback/AbstractFeedbackSender.java | 7 + .../features/feedback/Feedback.java | 178 ++++++++++++ .../features/feedback/FeedbackSender.java | 19 ++ .../features/feedback/FeedbackType.java | 18 ++ .../features/toggleable/AirPlaceFeature.java | 125 +++++++++ .../features/toggleable/AutoDustFeature.java | 11 + .../features/toggleable/BigDustFeature.java | 16 ++ .../toggleable/ToggleableFeature.java | 257 +++++++++++++++++ .../macros/ClientPlayerEntityMixin.java | 9 + .../redstonetools/macros/KeyBindingMixin.java | 12 + .../redstone/redstonetools/macros/Macro.java | 132 +++++++++ .../redstonetools/macros/MacroManager.java | 192 +++++++++++++ .../redstonetools/macros/actions/Action.java | 5 + .../macros/actions/CommandAction.java | 29 ++ .../macros/gui/MaroCommandSuggestor.java | 0 .../macros/gui/screen/CommandEditScreen.java | 108 ++++++++ .../macros/gui/screen/MacroEditScreen.java | 259 ++++++++++++++++++ .../macros/gui/screen/MacroSelectScreen.java | 52 ++++ .../macros/gui/widget/IconButtonWidget.java | 35 +++ .../gui/widget/commandlist/CommandEntry.java | 112 ++++++++ .../commandlist/CommandEntryPlaceHolder.java | 23 ++ .../widget/commandlist/CommandListWidget.java | 127 +++++++++ .../gui/widget/macrolist/MacroEntry.java | 117 ++++++++ .../gui/widget/macrolist/MacroListWidget.java | 77 ++++++ .../accessors/MinecraftClientAccessor.java | 15 + .../accessors/WorldRendererAccessor.java | 18 ++ .../mixin/blocks/RedstoneHitboxMixin.java | 46 ++++ .../mixin/features/AirPlaceClientMixin.java | 85 ++++++ .../mixin/features/AirPlaceServerMixin.java | 27 ++ .../mixin/features/AutoDustMixin.java | 54 ++++ .../mixin/features/CopyStateMixin.java | 29 ++ .../mixin/features/ItemBindMixin.java | 78 ++++++ .../gamerules/DoContainerDropsMixin.java | 20 ++ .../mixin/macros/AddMacroButtonMixin.java | 27 ++ .../macros/InitializeMacroManagerMixin.java | 18 ++ .../mixin/macros/KeyBindingMixinImpl.java | 30 ++ .../ClientPlayerEntityMixinImpl.java | 22 ++ .../autocomplete/CommandSuggestorMixin.java | 71 +++++ .../mixin/update/CheckUpdateMixin.java | 91 ++++++ .../redstonetools/utils/BlockColor.java | 50 ++++ .../redstonetools/utils/BlockInfo.java | 20 ++ .../utils/BlockStateNbtUtil.java | 181 ++++++++++++ .../redstonetools/utils/ColoredBlock.java | 85 ++++++ .../redstonetools/utils/ColoredBlockType.java | 39 +++ .../utils/CommandSourceUtils.java | 12 + .../redstonetools/utils/CommandUtils.java | 59 ++++ .../redstonetools/utils/DependencyLookup.java | 25 ++ .../utils/DirectionArgument.java | 24 ++ .../redstonetools/utils/DirectionUtils.java | 115 ++++++++ .../redstonetools/utils/ItemUtils.java | 68 +++++ .../redstonetools/utils/KeyBindingUtils.java | 19 ++ .../redstonetools/utils/NumberArg.java | 62 +++++ .../redstonetools/utils/NumberBase.java | 101 +++++++ .../redstonetools/utils/PositionUtils.java | 13 + .../redstonetools/utils/RaycastUtils.java | 28 ++ .../redstonetools/utils/RedstoneUtils.java | 12 + .../redstonetools/utils/ReflectionUtils.java | 153 +++++++++++ .../redstonetools/utils/SignalBlock.java | 48 ++++ .../utils/SignalBlockSupplier.java | 131 +++++++++ .../redstonetools/utils/WorldEditUtils.java | 69 +++++ .../assets/redstonetools/gui/cross.png | Bin .../assets/redstonetools/gui/pencil.png | Bin .../resources/assets/redstonetools/icon.png | Bin .../assets/redstonetools/lang/en_au.json | 0 .../assets/redstonetools/lang/en_ca.json | 0 .../assets/redstonetools/lang/en_gb.json | 0 .../assets/redstonetools/lang/en_nz.json | 0 .../assets/redstonetools/lang/en_us.json | 0 .../main/resources/fabric.mod.json | 4 +- .../main/resources/redstonetools.mixins.json | 0 .../redstonetools/di/FeatureModule.java | 1 + .../BlockStateArgumentSerializer.java | 6 +- .../arguments/serializers/EnumSerializer.java | 2 + .../serializers/IntLikeSerializer.java | 1 + .../serializers/MacroNameSerializer.java | 1 + .../commands/BinaryBlockReadFeature.java | 9 +- .../commands/BlockRaycastFeature.java | 5 +- .../features/commands/ColorCodeFeature.java | 12 +- .../features/commands/ColoredFeature.java | 1 + .../features/commands/CommandFeature.java | 4 + .../features/commands/ItemBindFeature.java | 2 +- .../features/commands/MacroFeature.java | 1 + .../commands/MinSelectionFeature.java | 10 +- .../features/commands/QuickTpFeature.java | 6 +- .../features/commands/RStackFeature.java | 9 +- .../commands/SignalStrengthBlockFeature.java | 2 +- .../commands/update/UpdateFeature.java | 4 +- .../toggleable/ToggleableFeature.java | 3 + .../redstonetools/macros/MacroManager.java | 5 + .../macros/actions/CommandAction.java | 1 + .../macros/gui/MacroCommandSuggestor.java | 42 +++ .../macros/gui/screen/CommandEditScreen.java | 26 +- .../macros/gui/screen/MacroEditScreen.java | 8 +- .../macros/gui/screen/MacroSelectScreen.java | 4 +- .../gui/widget/commandlist/CommandEntry.java | 10 +- .../gui/widget/macrolist/MacroEntry.java | 4 +- .../mixin/features/AutoDustMixin.java | 2 +- .../autocomplete/CommandSuggestorMixin.java | 16 +- .../utils/BlockStateNbtUtil.java | 3 +- .../redstonetools/utils/ColoredBlock.java | 3 +- .../redstonetools/utils/ColoredBlockType.java | 2 +- .../redstonetools/utils/ItemUtils.java | 3 - .../redstonetools/utils/RaycastUtils.java | 4 +- .../redstonetools/utils/ReflectionUtils.java | 1 + .../utils/SignalBlockSupplier.java | 2 +- .../redstonetools/utils/WorldEditUtils.java | 3 + 153 files changed, 6236 insertions(+), 67 deletions(-) create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/RedstoneToolsClient.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/RedstoneToolsGameRules.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/di/FeatureModule.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/di/UtilityModule.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/AbstractFeature.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/Feature.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/arguments/Argument.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/BigIntegerSerializer.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/BlockColorSerializer.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/BlockStateArgumentSerializer.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/BoolSerializer.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/BrigadierSerializer.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/CollectionSerializer.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/ColoredBlockTypeSerializer.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/DirectionSerializer.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/DoubleSerializer.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/EnumSerializer.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/FloatSerializer.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/IntLikeSerializer.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/IntegerSerializer.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/LongSerializer.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/MacroNameSerializer.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/NumberBaseSerializer.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/NumberSerializer.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/SignalBlockSerializer.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/StringBrigadierSerializer.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/StringSerializer.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/TypeSerializer.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/commands/BaseConvertFeature.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/commands/BinaryBlockReadFeature.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/commands/BlockRaycastFeature.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/commands/ColorCodeFeature.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/commands/ColoredFeature.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/commands/CommandFeature.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/commands/CopyStateFeature.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/commands/ItemBindFeature.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/commands/MacroFeature.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/commands/MinSelectionFeature.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/commands/PickBlockFeature.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/commands/QuickTpFeature.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/commands/RStackFeature.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/commands/SignalStrengthBlockFeature.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/commands/update/RegionUpdater.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/commands/update/UpdateFeature.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/feedback/AbstractFeedbackSender.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/feedback/Feedback.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/feedback/FeedbackSender.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/feedback/FeedbackType.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/toggleable/AirPlaceFeature.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/toggleable/AutoDustFeature.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/toggleable/BigDustFeature.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/toggleable/ToggleableFeature.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/macros/ClientPlayerEntityMixin.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/macros/KeyBindingMixin.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/macros/Macro.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/macros/MacroManager.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/macros/actions/Action.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/macros/actions/CommandAction.java rename {src => oldSrc}/main/java/tools/redstone/redstonetools/macros/gui/MaroCommandSuggestor.java (100%) create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/macros/gui/screen/CommandEditScreen.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/macros/gui/screen/MacroEditScreen.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/macros/gui/screen/MacroSelectScreen.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/macros/gui/widget/IconButtonWidget.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/macros/gui/widget/commandlist/CommandEntry.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/macros/gui/widget/commandlist/CommandEntryPlaceHolder.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/macros/gui/widget/commandlist/CommandListWidget.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/macros/gui/widget/macrolist/MacroEntry.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/macros/gui/widget/macrolist/MacroListWidget.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/mixin/accessors/MinecraftClientAccessor.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/mixin/accessors/WorldRendererAccessor.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/mixin/blocks/RedstoneHitboxMixin.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/mixin/features/AirPlaceClientMixin.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/mixin/features/AirPlaceServerMixin.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/mixin/features/AutoDustMixin.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/mixin/features/CopyStateMixin.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/mixin/features/ItemBindMixin.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/mixin/gamerules/DoContainerDropsMixin.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/mixin/macros/AddMacroButtonMixin.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/mixin/macros/InitializeMacroManagerMixin.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/mixin/macros/KeyBindingMixinImpl.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/mixin/macros/autocomplete/ClientPlayerEntityMixinImpl.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/mixin/macros/autocomplete/CommandSuggestorMixin.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/mixin/update/CheckUpdateMixin.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/utils/BlockColor.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/utils/BlockInfo.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/utils/BlockStateNbtUtil.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/utils/ColoredBlock.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/utils/ColoredBlockType.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/utils/CommandSourceUtils.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/utils/CommandUtils.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/utils/DependencyLookup.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/utils/DirectionArgument.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/utils/DirectionUtils.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/utils/ItemUtils.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/utils/KeyBindingUtils.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/utils/NumberArg.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/utils/NumberBase.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/utils/PositionUtils.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/utils/RaycastUtils.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/utils/RedstoneUtils.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/utils/ReflectionUtils.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/utils/SignalBlock.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/utils/SignalBlockSupplier.java create mode 100644 oldSrc/main/java/tools/redstone/redstonetools/utils/WorldEditUtils.java rename {src => oldSrc}/main/resources/assets/redstonetools/gui/cross.png (100%) rename {src => oldSrc}/main/resources/assets/redstonetools/gui/pencil.png (100%) rename {src => oldSrc}/main/resources/assets/redstonetools/icon.png (100%) rename {src => oldSrc}/main/resources/assets/redstonetools/lang/en_au.json (100%) rename {src => oldSrc}/main/resources/assets/redstonetools/lang/en_ca.json (100%) rename {src => oldSrc}/main/resources/assets/redstonetools/lang/en_gb.json (100%) rename {src => oldSrc}/main/resources/assets/redstonetools/lang/en_nz.json (100%) rename {src => oldSrc}/main/resources/assets/redstonetools/lang/en_us.json (100%) rename {src => oldSrc}/main/resources/fabric.mod.json (93%) rename {src => oldSrc}/main/resources/redstonetools.mixins.json (100%) create mode 100644 src/main/java/tools/redstone/redstonetools/macros/gui/MacroCommandSuggestor.java diff --git a/build.gradle b/build.gradle index 9cf1f332..b0c7c243 100644 --- a/build.gradle +++ b/build.gradle @@ -1,7 +1,7 @@ //file:noinspection GroovyAssignabilityCheck plugins { - id 'fabric-loom' version '1.2-SNAPSHOT' + id 'fabric-loom' version '1.4-SNAPSHOT' id 'maven-publish' id 'com.github.johnrengelman.shadow' version '8.+' } @@ -50,7 +50,7 @@ dependencies { modImplementation("net.fabricmc.fabric-api:fabric-api:${project.fabric_version}") // Worldedit API - modImplementation("com.sk89q.worldedit:worldedit-fabric-mc1.18.2:7.2.10") + modImplementation("com.sk89q.worldedit:worldedit-fabric-mc1.20.4:7.2.18-SNAPSHOT") } processResources { diff --git a/gradle.properties b/gradle.properties index 4c0cdb5e..f2aaaecb 100644 --- a/gradle.properties +++ b/gradle.properties @@ -4,14 +4,14 @@ org.gradle.parallel=true # Fabric Properties # check these on https://fabricmc.net/develop - minecraft_version=1.18.2 - yarn_mappings=1.18.2+build.4 - loader_version=0.14.6 + minecraft_version=1.20.4 + yarn_mappings=1.20.4+build.3 + loader_version=0.15.3 # Mod Properties - mod_version = 1.18.2-2.0.0 + mod_version = 1.20.4-1.0.0 maven_group = tools.redstone archives_base_name = redstonetools # Dependencies - fabric_version=0.53.0+1.18.2 + fabric_version=0.92.0+1.20.4 diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties index fae08049..a5952066 100644 --- a/gradle/wrapper/gradle-wrapper.properties +++ b/gradle/wrapper/gradle-wrapper.properties @@ -1,5 +1,5 @@ distributionBase=GRADLE_USER_HOME distributionPath=wrapper/dists -distributionUrl=https\://services.gradle.org/distributions/gradle-8.1.1-bin.zip +distributionUrl=https\://services.gradle.org/distributions/gradle-8.5-bin.zip zipStoreBase=GRADLE_USER_HOME zipStorePath=wrapper/dists diff --git a/oldSrc/main/java/tools/redstone/redstonetools/RedstoneToolsClient.java b/oldSrc/main/java/tools/redstone/redstonetools/RedstoneToolsClient.java new file mode 100644 index 00000000..2207c32b --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/RedstoneToolsClient.java @@ -0,0 +1,42 @@ +package tools.redstone.redstonetools; + +import net.fabricmc.api.ClientModInitializer; +import net.fabricmc.loader.api.FabricLoader; +import net.minecraft.client.MinecraftClient; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import rip.hippo.inject.Doctor; +import rip.hippo.inject.Injector; +import tools.redstone.redstonetools.utils.DependencyLookup; +import tools.redstone.redstonetools.utils.ReflectionUtils; + +import java.nio.file.Path; + +public class RedstoneToolsClient implements ClientModInitializer { + + public static final String MOD_ID = "redstonetools"; + public static final String MOD_VERSION = "v" + FabricLoader.getInstance().getModContainer(MOD_ID).orElseThrow().getMetadata().getVersion().getFriendlyString(); + public static final Logger LOGGER = LoggerFactory.getLogger(MOD_ID); + public static final Path CONFIG_DIR = FabricLoader.getInstance().getConfigDir().resolve("redstonetools"); + public static final Injector INJECTOR = Doctor.createInjector(ReflectionUtils.getModules()); + + @Override + public void onInitializeClient() { + LOGGER.info("Initializing Redstone Tools"); + + // Register game rules + RedstoneToolsGameRules.register(); + + // Register features + ReflectionUtils.getFeatures().forEach(feature -> { + LOGGER.trace("Registering feature {}", feature.getClass().getName()); + + if (feature.requiresWorldEdit() && !DependencyLookup.WORLDEDIT_PRESENT) { + LOGGER.warn("Feature {} requires WorldEdit, but WorldEdit is not loaded. Skipping registration.", feature.getName()); + return; + } + feature.register(); + }); + } + +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/RedstoneToolsGameRules.java b/oldSrc/main/java/tools/redstone/redstonetools/RedstoneToolsGameRules.java new file mode 100644 index 00000000..73a9e2f8 --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/RedstoneToolsGameRules.java @@ -0,0 +1,23 @@ +package tools.redstone.redstonetools; + +import net.fabricmc.fabric.api.gamerule.v1.GameRuleFactory; +import net.fabricmc.fabric.api.gamerule.v1.GameRuleRegistry; +import net.minecraft.world.GameRules; +import tools.redstone.redstonetools.utils.DependencyLookup; + + +public class RedstoneToolsGameRules { + private RedstoneToolsGameRules() { + } + + public static GameRules.Key DO_CONTAINER_DROPS; + public static GameRules.Key DO_BLOCK_UPDATES_AFTER_EDIT; + + public static void register() { + DO_CONTAINER_DROPS = GameRuleRegistry.register("doContainerDrops", GameRules.Category.DROPS, GameRuleFactory.createBooleanRule(true)); + + if (DependencyLookup.WORLDEDIT_PRESENT) { + DO_BLOCK_UPDATES_AFTER_EDIT = GameRuleRegistry.register("doBlockUpdatesAfterEdit", GameRules.Category.UPDATES, GameRuleFactory.createBooleanRule(false)); + } + } +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/di/FeatureModule.java b/oldSrc/main/java/tools/redstone/redstonetools/di/FeatureModule.java new file mode 100644 index 00000000..505e2179 --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/di/FeatureModule.java @@ -0,0 +1,18 @@ +package tools.redstone.redstonetools.di; + +import com.google.auto.service.AutoService; +import rip.hippo.inject.DoctorModule; +import rip.hippo.inject.binding.Binder; +import tools.redstone.redstonetools.utils.ReflectionUtils; + +@AutoService(DoctorModule.class) +public class FeatureModule implements DoctorModule { + @SuppressWarnings({"rawtypes", "unchecked"}) // this is probably the only way to make it work + @Override + public void configure(Binder binder) { + for (var feature : ReflectionUtils.getFeatures()) { + Class clazz = feature.getClass(); + binder.bind(clazz).toInstance(feature); + } + } +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/di/UtilityModule.java b/oldSrc/main/java/tools/redstone/redstonetools/di/UtilityModule.java new file mode 100644 index 00000000..3415b5e3 --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/di/UtilityModule.java @@ -0,0 +1,15 @@ +package tools.redstone.redstonetools.di; + +import com.google.auto.service.AutoService; +import rip.hippo.inject.DoctorModule; +import rip.hippo.inject.binding.Binder; +import tools.redstone.redstonetools.features.feedback.AbstractFeedbackSender; +import tools.redstone.redstonetools.features.feedback.FeedbackSender; + +@AutoService(DoctorModule.class) +public class UtilityModule implements DoctorModule { + @Override + public void configure(Binder binder) { + binder.bind(AbstractFeedbackSender.class).to(FeedbackSender.class); + } +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/AbstractFeature.java b/oldSrc/main/java/tools/redstone/redstonetools/features/AbstractFeature.java new file mode 100644 index 00000000..e8e6f1af --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/features/AbstractFeature.java @@ -0,0 +1,60 @@ +package tools.redstone.redstonetools.features; + +import com.mojang.brigadier.CommandDispatcher; +import net.fabricmc.fabric.api.command.v1.CommandRegistrationCallback; +import net.minecraft.server.command.ServerCommandSource; + +public abstract class AbstractFeature { + + private final Feature featureInfo; + private final String id; + + { + featureInfo = getClass().getAnnotation(Feature.class); + + if (featureInfo == null) { + throw new IllegalStateException("Feature " + getClass() + " is not annotated with @Feature"); + } + + String id = featureInfo.id(); + if (id.isEmpty()) { + // derive id from name + // Air Place -> airplace + id = featureInfo.name() + .toLowerCase() + .replace(" ", ""); + } + + this.id = id; + } + + public String getID() { + return id; + } + + public String getName() { + return featureInfo.name(); + } + + public String getDescription() { + return featureInfo.description(); + } + + public String getCommand() { + return featureInfo.command(); + } + + public boolean requiresWorldEdit() { + return featureInfo.worldedit(); + } + + /** + * Register this feature. + */ + public void register() { + CommandRegistrationCallback.EVENT.register(this::registerCommands); + } + + protected abstract void registerCommands(CommandDispatcher dispatcher, boolean dedicated); + +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/Feature.java b/oldSrc/main/java/tools/redstone/redstonetools/features/Feature.java new file mode 100644 index 00000000..14979af7 --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/features/Feature.java @@ -0,0 +1,16 @@ +package tools.redstone.redstonetools.features; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +@Target(ElementType.TYPE) +@Retention(RetentionPolicy.RUNTIME) +public @interface Feature { + String id() default ""; + String name(); + String description(); + String command(); + boolean worldedit() default false; +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/Argument.java b/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/Argument.java new file mode 100644 index 00000000..683536c0 --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/Argument.java @@ -0,0 +1,80 @@ +package tools.redstone.redstonetools.features.arguments; + +import tools.redstone.redstonetools.features.arguments.serializers.TypeSerializer; +import com.mojang.brigadier.context.CommandContext; + +public class Argument { + private String name; + private final TypeSerializer type; + private boolean optional = false; + private volatile T value; + private T defaultValue; + + private Argument(TypeSerializer type) { + this.type = type; + } + + public static Argument ofType(TypeSerializer type) { + return new Argument<>(type); + } + + public Argument withDefault(T defaultValue) { + optional = true; + this.defaultValue = defaultValue; + this.value = defaultValue; // for options, temporary + + return this; + } + + public T getDefaultValue() { + return defaultValue; + } + + public Argument named(String name) { + this.name = name; + + return this; + } + + public Argument ensureNamed(String fieldName) { + if (name == null) { + name = fieldName; + } + + return this; + } + + public String getName() { + return name; + } + + public TypeSerializer getType() { + return type; + } + + public boolean isOptional() { + return optional; + } + + @SuppressWarnings("unchecked") + public void updateValue(CommandContext context) { + try { + value = (T) context.getArgument(name, Object.class); + } catch (IllegalArgumentException e) { + if (!optional) { + throw e; + } + + value = defaultValue; + } + } + + public void setValue(T value) { + this.value = value; + } + + public T getValue() { + return value; + } + +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/BigIntegerSerializer.java b/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/BigIntegerSerializer.java new file mode 100644 index 00000000..36b94bbb --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/BigIntegerSerializer.java @@ -0,0 +1,33 @@ +package tools.redstone.redstonetools.features.arguments.serializers; + +import java.math.BigInteger; +import java.util.Optional; + +public class BigIntegerSerializer extends IntLikeSerializer { + private static final BigIntegerSerializer INSTANCE = new BigIntegerSerializer(null, null); + + public static BigIntegerSerializer bigInteger() { + return INSTANCE; + } + + public static BigIntegerSerializer bigInteger(BigInteger min) { + return new BigIntegerSerializer(min, null); + } + + public static BigIntegerSerializer bigInteger(BigInteger min, BigInteger max) { + return new BigIntegerSerializer(min, max); + } + + private BigIntegerSerializer(BigInteger min, BigInteger max) { + super(BigInteger.class, min, max); + } + + @Override + protected Optional tryParseOptional(String string, int radix) { + try { + return Optional.of(new BigInteger(string, radix)); + } catch (NumberFormatException ignored) { + return Optional.empty(); + } + } +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/BlockColorSerializer.java b/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/BlockColorSerializer.java new file mode 100644 index 00000000..a90c2a85 --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/BlockColorSerializer.java @@ -0,0 +1,15 @@ +package tools.redstone.redstonetools.features.arguments.serializers; + +import tools.redstone.redstonetools.utils.BlockColor; + +public class BlockColorSerializer extends EnumSerializer { + private static final BlockColorSerializer INSTANCE = new BlockColorSerializer(); + + private BlockColorSerializer() { + super(BlockColor.class); + } + + public static BlockColorSerializer blockColor() { + return INSTANCE; + } +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/BlockStateArgumentSerializer.java b/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/BlockStateArgumentSerializer.java new file mode 100644 index 00000000..705bebac --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/BlockStateArgumentSerializer.java @@ -0,0 +1,60 @@ +package tools.redstone.redstonetools.features.arguments.serializers; + +import com.mojang.brigadier.StringReader; +import com.mojang.brigadier.exceptions.CommandSyntaxException; +import net.minecraft.command.argument.BlockStateArgument; +import net.minecraft.command.argument.BlockStateArgumentType; +import net.minecraft.util.registry.Registry; + +public class BlockStateArgumentSerializer extends BrigadierSerializer { + + private static final BlockStateArgumentSerializer INSTANCE = new BlockStateArgumentSerializer(); + + private BlockStateArgumentSerializer() { + super(BlockStateArgument.class, BlockStateArgumentType.blockState()); + } + + public static BlockStateArgumentSerializer blockState() { + return INSTANCE; + } + + @Override + public BlockStateArgument deserialize(String serialized) { + try { + return deserialize(new StringReader(serialized)); + } catch (CommandSyntaxException e) { + throw new IllegalStateException("Syntax Exception: " + e.getMessage()); + } + } + + @Override + public String serialize(BlockStateArgument value) { + var state = value.getBlockState(); + var block = state.getBlock(); + + var builder = new StringBuilder() + .append(Registry.BLOCK.getId(block)); + + if (state.getProperties().size() == 0) { + return builder.toString(); + } + + builder.append('['); + var first = true; + for (var prop : state.getProperties()) { + if (first) { + first = false; + } else { + builder.append(','); + } + + builder.append(prop.getName()) + .append('=') + .append(state.get(prop)); + } + builder.append(']'); + + return builder.toString(); + } + +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/BoolSerializer.java b/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/BoolSerializer.java new file mode 100644 index 00000000..02fb39e5 --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/BoolSerializer.java @@ -0,0 +1,23 @@ +package tools.redstone.redstonetools.features.arguments.serializers; + +import com.mojang.brigadier.arguments.ArgumentType; +import com.mojang.brigadier.arguments.BoolArgumentType; + +public class BoolSerializer extends StringBrigadierSerializer { + + private static final BoolSerializer INSTANCE = new BoolSerializer(BoolArgumentType.bool()); + + public static BoolSerializer bool() { + return INSTANCE; + } + + private BoolSerializer(ArgumentType argumentType) { + super(Boolean.class, argumentType); + } + + @Override + public String serialize(Boolean value) { + return String.valueOf(value); + } + +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/BrigadierSerializer.java b/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/BrigadierSerializer.java new file mode 100644 index 00000000..5a2e5ba9 --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/BrigadierSerializer.java @@ -0,0 +1,38 @@ +package tools.redstone.redstonetools.features.arguments.serializers; + +import com.mojang.brigadier.StringReader; +import com.mojang.brigadier.arguments.ArgumentType; +import com.mojang.brigadier.context.CommandContext; +import com.mojang.brigadier.exceptions.CommandSyntaxException; +import com.mojang.brigadier.suggestion.Suggestions; +import com.mojang.brigadier.suggestion.SuggestionsBuilder; + +import java.util.Collection; +import java.util.concurrent.CompletableFuture; + +public abstract class BrigadierSerializer extends TypeSerializer { + + // the wrapped brigadier argument type + private final ArgumentType argumentType; + + public BrigadierSerializer(Class clazz, ArgumentType argumentType) { + super(clazz); + this.argumentType = argumentType; + } + + @Override + public T deserialize(StringReader reader) throws CommandSyntaxException { + return argumentType.parse(reader); + } + + @Override + public CompletableFuture listSuggestions(CommandContext context, SuggestionsBuilder builder) { + return argumentType.listSuggestions(context, builder); + } + + @Override + public Collection getExamples() { + return argumentType.getExamples(); + } + +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/CollectionSerializer.java b/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/CollectionSerializer.java new file mode 100644 index 00000000..c68c7c29 --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/CollectionSerializer.java @@ -0,0 +1,176 @@ +package tools.redstone.redstonetools.features.arguments.serializers; + +import com.mojang.brigadier.StringReader; +import com.mojang.brigadier.context.CommandContext; +import com.mojang.brigadier.exceptions.CommandSyntaxException; +import com.mojang.brigadier.suggestion.Suggestions; +import com.mojang.brigadier.suggestion.SuggestionsBuilder; + +import java.util.*; +import java.util.concurrent.CompletableFuture; +import java.util.function.Function; + +/** + * Serializes any collection type as a list, + * and handles it specially for configuration. + * + * @param The element type. + * @param The collection type. + */ +public class CollectionSerializer> + extends TypeSerializer> +{ + + public static CollectionSerializer> listOf(TypeSerializer element) { + return new CollectionSerializer<>(List.class, element, ArrayList::new); + } + + public static CollectionSerializer> setOf(TypeSerializer element) { + return new CollectionSerializer<>(Set.class, element, HashSet::new); + } + + final TypeSerializer elementType; + final Function, C> collectionFactory; + + // cache example because + // its relatively expensive + // to compute correctly + final String example; + + @SuppressWarnings("unchecked") + protected CollectionSerializer(Class clazz, + TypeSerializer elementType, + Function, C> collectionFactory) { + super((Class) clazz); + this.elementType = (TypeSerializer) elementType; + this.collectionFactory = collectionFactory; + + // build example + StringBuilder b = new StringBuilder("["); + for (String elemStr : elementType.getExamples()) { + b.append(elemStr); + b.append(", "); + } + + this.example = b.delete(b.length() - 3, b.length()).append("]").toString(); + } + + public TypeSerializer getElementType() { + return elementType; + } + + @Override + public C deserialize(StringReader reader) throws CommandSyntaxException { + List list = new ArrayList<>(); + reader.expect('['); + reader.skipWhitespace(); + if (reader.peek() == ']') { // empty list + reader.skip(); + return collectionFactory.apply(list); + } + + while (reader.canRead()) { + E element = elementType.deserialize(reader); + list.add(element); + reader.skipWhitespace(); + if (reader.peek() == ']') + break; + reader.expect(','); + reader.skipWhitespace(); + } + + reader.skipWhitespace(); + reader.expect(']'); + + return collectionFactory.apply(list); + } + + @Override + public Collection getExamples() { + return List.of("[a, b, c]"); + } + + @Override + public CompletableFuture listSuggestions(CommandContext context, SuggestionsBuilder builder) { + String remaining = builder.getRemaining(); + + if (remaining.isBlank()) { + // suggest opening the list + builder.suggest("["); + } else { + builder.suggest(","); + builder.suggest("]"); + + // suggest element options + // the start index is the index + // of the last comma if open, otherwise + // it will be -1 and no elements will + // be suggested + // TODO: fix because this doesnt work for some reason + StringReader inputParser = new StringReader(remaining); + int startIndex = -1; + try { + inputParser.skip(); // [ + while (inputParser.canRead()) { + // skip element + int oldCursor = inputParser.getCursor(); + try { + elementType.deserialize(inputParser); + } catch (CommandSyntaxException ignored) { } + if (oldCursor == inputParser.getCursor()) + break; + inputParser.skipWhitespace(); + + // skip and register comma + if (inputParser.peek() == ',') { + startIndex = inputParser.getCursor(); + } + + inputParser.skip(); + if (!inputParser.canRead()) + break; + + // end on closer + if (inputParser.peek() == ']') { + startIndex = -1; + break; + } + + inputParser.skipWhitespace(); + } + } catch (Exception e) { + startIndex = -1; + } + + if (startIndex != -1) { + SuggestionsBuilder b2 = new SuggestionsBuilder( + remaining, + remaining.toLowerCase(), + startIndex + 1); + + elementType.listSuggestions(context, b2); + builder.add(b2); + } + } + + return builder.buildFuture(); + } + + @Override + @SuppressWarnings({ "rawtypes", "unchecked" }) + public C deserialize(List in) { + List elementList = in.stream() + .map(elementType::deserialize) + .toList(); + return collectionFactory.apply(elementList); + } + + @Override + public List serialize(C value) { + return value + .stream() + .map(elementType::serialize) + .toList(); + } + +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/ColoredBlockTypeSerializer.java b/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/ColoredBlockTypeSerializer.java new file mode 100644 index 00000000..3b7b6e99 --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/ColoredBlockTypeSerializer.java @@ -0,0 +1,15 @@ +package tools.redstone.redstonetools.features.arguments.serializers; + +import tools.redstone.redstonetools.utils.ColoredBlockType; + +public class ColoredBlockTypeSerializer extends EnumSerializer { + private static final ColoredBlockTypeSerializer INSTANCE = new ColoredBlockTypeSerializer(); + + private ColoredBlockTypeSerializer() { + super(ColoredBlockType.class); + } + + public static ColoredBlockTypeSerializer coloredBlockType() { + return INSTANCE; + } +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/DirectionSerializer.java b/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/DirectionSerializer.java new file mode 100644 index 00000000..9a2f3b36 --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/DirectionSerializer.java @@ -0,0 +1,15 @@ +package tools.redstone.redstonetools.features.arguments.serializers; + +import tools.redstone.redstonetools.utils.DirectionArgument; + +public class DirectionSerializer extends EnumSerializer { + private static final DirectionSerializer INSTANCE = new DirectionSerializer(); + + private DirectionSerializer() { + super(DirectionArgument.class); + } + + public static DirectionSerializer direction() { + return INSTANCE; + } +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/DoubleSerializer.java b/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/DoubleSerializer.java new file mode 100644 index 00000000..86daafa0 --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/DoubleSerializer.java @@ -0,0 +1,31 @@ +package tools.redstone.redstonetools.features.arguments.serializers; + +import com.mojang.brigadier.arguments.ArgumentType; +import com.mojang.brigadier.arguments.DoubleArgumentType; + +public class DoubleSerializer extends StringBrigadierSerializer { + + private static final DoubleSerializer INSTANCE = new DoubleSerializer(DoubleArgumentType.doubleArg()); + + public static DoubleSerializer doubleArg() { + return INSTANCE; + } + + public static DoubleSerializer doubleArg(double min) { + return new DoubleSerializer(DoubleArgumentType.doubleArg(min)); + } + + public static DoubleSerializer doubleArg(double min, double max) { + return new DoubleSerializer(DoubleArgumentType.doubleArg(min, max)); + } + + private DoubleSerializer(ArgumentType argumentType) { + super(Double.class, argumentType); + } + + @Override + public String serialize(Double value) { + return String.valueOf(value); + } + +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/EnumSerializer.java b/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/EnumSerializer.java new file mode 100644 index 00000000..be6d2e92 --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/EnumSerializer.java @@ -0,0 +1,80 @@ +package tools.redstone.redstonetools.features.arguments.serializers; + +import com.mojang.brigadier.StringReader; +import com.mojang.brigadier.context.CommandContext; +import com.mojang.brigadier.exceptions.CommandSyntaxException; +import com.mojang.brigadier.suggestion.Suggestions; +import com.mojang.brigadier.suggestion.SuggestionsBuilder; +import net.minecraft.text.Text; + +import java.util.Collection; +import java.util.EnumSet; +import java.util.concurrent.CompletableFuture; + +public abstract class EnumSerializer> + extends TypeSerializer { + + protected EnumSerializer(Class clazz) { + super(clazz); + } + + // common method for stringification + // of the enum constants, can be overridden + @Override + public String serialize(T value) { + return value.toString(); + } + + @Override + public T deserialize(StringReader reader) throws CommandSyntaxException { + var input = reader.readUnquotedString(); + + try { + return deserialize(input); + } catch (IllegalArgumentException e) { + throw new CommandSyntaxException(null, Text.of(e.getMessage())); + } + } + + @Override + public T deserialize(String input) { + String inputLowerCase = input.toLowerCase(); + + var matches = EnumSet.allOf(clazz) + .stream() + .filter(elem -> serialize(elem).toLowerCase().startsWith(inputLowerCase)) + .toList(); + + var exactMatch = matches.stream().filter(elem -> serialize(elem).toLowerCase().equals(input)).findFirst(); + if (exactMatch.isPresent()) { + return exactMatch.get(); + } + + if (matches.isEmpty()) { + throw new IllegalArgumentException("No such option '" + input + "'"); + } + + if (matches.size() > 1) { + throw new IllegalArgumentException("Ambiguous option '" + input + "'"); + } + + return matches.get(0); + } + + @Override + public Collection getExamples() { + return EnumSet.allOf(clazz).stream() + .map(this::serialize) + .toList(); + } + + @Override + public CompletableFuture listSuggestions(CommandContext context, SuggestionsBuilder builder) { + for (var value : EnumSet.allOf(clazz)) { + builder = builder.suggest(serialize(value)); + } + + return builder.buildFuture(); + } + +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/FloatSerializer.java b/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/FloatSerializer.java new file mode 100644 index 00000000..3511e418 --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/FloatSerializer.java @@ -0,0 +1,31 @@ +package tools.redstone.redstonetools.features.arguments.serializers; + +import com.mojang.brigadier.arguments.ArgumentType; +import com.mojang.brigadier.arguments.FloatArgumentType; + +public class FloatSerializer extends StringBrigadierSerializer { + + private static final FloatSerializer INSTANCE = new FloatSerializer(FloatArgumentType.floatArg()); + + public static FloatSerializer floatArg() { + return INSTANCE; + } + + public static FloatSerializer floatArg(float min) { + return new FloatSerializer(FloatArgumentType.floatArg(min)); + } + + public static FloatSerializer floatArg(float min, float max) { + return new FloatSerializer(FloatArgumentType.floatArg(min, max)); + } + + private FloatSerializer(ArgumentType argumentType) { + super(Float.class, argumentType); + } + + @Override + public String serialize(Float value) { + return String.valueOf(value); + } + +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/IntLikeSerializer.java b/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/IntLikeSerializer.java new file mode 100644 index 00000000..0cfc6974 --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/IntLikeSerializer.java @@ -0,0 +1,129 @@ +package tools.redstone.redstonetools.features.arguments.serializers; + +import com.mojang.brigadier.StringReader; +import com.mojang.brigadier.context.CommandContext; +import com.mojang.brigadier.exceptions.CommandSyntaxException; +import com.mojang.brigadier.suggestion.Suggestions; +import com.mojang.brigadier.suggestion.SuggestionsBuilder; +import net.minecraft.text.Text; +import tools.redstone.redstonetools.utils.NumberBase; + +import java.util.Collection; +import java.util.Collections; +import java.util.Optional; +import java.util.concurrent.CompletableFuture; + +public abstract class IntLikeSerializer> extends TypeSerializer { + private final T min; + private final boolean hasMin; + private final T max; + private final boolean hasMax; + + protected IntLikeSerializer(Class clazz, T min, T max) { + super(clazz); + + this.min = min; + hasMin = min != null; + this.max = max; + hasMax = max != null; + } + + @Override + public T deserialize(StringReader reader) throws CommandSyntaxException { + var input = reader.readUnquotedString(); + + try { + return deserialize(input); + } catch (IllegalArgumentException e) { + throw new CommandSyntaxException(null, Text.of(e.getMessage())); + } + } + + @Override + public T deserialize(String serialized) { + var value = deserializeUnchecked(serialized); + + if (hasMin && value.compareTo(min) < 0) { + throw new IllegalArgumentException(value + " is below the minimum of " + min + "."); + } else if (hasMax && value.compareTo(max) > 0) { + throw new IllegalArgumentException(value + " is above the maximum of " + max + "."); + } + + return value; + } + + private T deserializeUnchecked(String serialized) { + boolean isNegative = false; + if (serialized.length() == 1) { + return tryParse(serialized); + } + + if(serialized.charAt(0) == '-' && serialized.chars().filter(ch -> ch == '-').count() == 1){ + isNegative = true; + serialized = serialized.replace("-",""); + } + + if (serialized.charAt(0) == '0') { + if(serialized.length() > 1) { + var prefixedBase = serialized.substring(0, 2); + var number = serialized.substring(2); + + var numberBase = NumberBase.fromPrefix(prefixedBase).orElse(null); + + if (numberBase != null) { + return isNegative ? tryParse("-" + number, numberBase.toInt()) : tryParse(number, numberBase.toInt()); + } + } else { + return tryParse(serialized,10); + } + } + + var parts = serialized.split("_", 2); + if (parts.length == 2) { + var number = parts[0]; + + int base; + try { + base = Integer.parseInt(parts[1]); + + if (2 > base || base > 36) { + throw new NumberFormatException(); + } + } catch (NumberFormatException ignored) { + throw new IllegalArgumentException("Invalid base '" + parts[1] + "'."); + } + + return isNegative ? tryParse("-"+number, base) : tryParse(number, base); + } + + return isNegative ? tryParse("-"+serialized) : tryParse(serialized); + } + + private T tryParse(String string) { + return tryParse(string, 10); + } + + private T tryParse(String string, int radix) { + return tryParseOptional(string, radix) + .orElseThrow(() -> new IllegalArgumentException(radix == 10 + ? "Invalid number '" + string + "'." + : "Invalid base " + radix + " number '" + string + "'.")); + } + + protected abstract Optional tryParseOptional(String string, int radix); + + @Override + public String serialize(T value) { + return String.valueOf(value); + } + + @Override + public Collection getExamples() { + return Collections.emptyList(); + } + + @Override + public CompletableFuture listSuggestions(CommandContext context, SuggestionsBuilder builder) { + return builder.buildFuture(); + } +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/IntegerSerializer.java b/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/IntegerSerializer.java new file mode 100644 index 00000000..8a53cf08 --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/IntegerSerializer.java @@ -0,0 +1,32 @@ +package tools.redstone.redstonetools.features.arguments.serializers; + +import java.util.Optional; + +public class IntegerSerializer extends IntLikeSerializer { + private static final IntegerSerializer INSTANCE = new IntegerSerializer(Integer.MIN_VALUE, Integer.MAX_VALUE); + + public static IntegerSerializer integer() { + return INSTANCE; + } + + public static IntegerSerializer integer(int min) { + return new IntegerSerializer(min, Integer.MAX_VALUE); + } + + public static IntegerSerializer integer(int min, int max) { + return new IntegerSerializer(min, max); + } + + private IntegerSerializer(int min, int max) { + super(Integer.class, min, max); + } + + @Override + protected Optional tryParseOptional(String string, int radix) { + try { + return Optional.of(Integer.parseInt(string, radix)); + } catch (NumberFormatException ignored) { + return Optional.empty(); + } + } +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/LongSerializer.java b/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/LongSerializer.java new file mode 100644 index 00000000..43516d84 --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/LongSerializer.java @@ -0,0 +1,32 @@ +package tools.redstone.redstonetools.features.arguments.serializers; + +import java.util.Optional; + +public class LongSerializer extends IntLikeSerializer { + private static final LongSerializer INSTANCE = new LongSerializer(Long.MIN_VALUE, Long.MAX_VALUE); + + public static LongSerializer longArg() { + return INSTANCE; + } + + public static LongSerializer longArg(long min) { + return new LongSerializer(min, Long.MAX_VALUE); + } + + public static LongSerializer longArg(long min, long max) { + return new LongSerializer(min, max); + } + + private LongSerializer(long min, long max) { + super(Long.class, min, max); + } + + @Override + protected Optional tryParseOptional(String string, int radix) { + try { + return Optional.of(Long.parseLong(string, radix)); + } catch (NumberFormatException ignored) { + return Optional.empty(); + } + } +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/MacroNameSerializer.java b/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/MacroNameSerializer.java new file mode 100644 index 00000000..2d4c697c --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/MacroNameSerializer.java @@ -0,0 +1,35 @@ +package tools.redstone.redstonetools.features.arguments.serializers; + +import tools.redstone.redstonetools.macros.MacroManager; +import com.mojang.brigadier.context.CommandContext; +import com.mojang.brigadier.suggestion.Suggestions; +import com.mojang.brigadier.suggestion.SuggestionsBuilder; +import java.util.concurrent.CompletableFuture; + +import static tools.redstone.redstonetools.RedstoneToolsClient.INJECTOR; + + +public class MacroNameSerializer extends StringSerializer { + private static final MacroNameSerializer INSTANCE = new MacroNameSerializer(); + + private MacroNameSerializer() { + + super(StringSerializer.greedyString()); + + } + + public static MacroNameSerializer macroName() { + return INSTANCE; + } + + @Override + public CompletableFuture listSuggestions(CommandContext context, SuggestionsBuilder builder) { + + for (var macro : INJECTOR.getInstance(MacroManager.class).getMacros()) { + + builder = builder.suggest(serialize(macro.name)); + } + + return builder.buildFuture(); + } +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/NumberBaseSerializer.java b/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/NumberBaseSerializer.java new file mode 100644 index 00000000..87126ee2 --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/NumberBaseSerializer.java @@ -0,0 +1,75 @@ +package tools.redstone.redstonetools.features.arguments.serializers; + +import com.mojang.brigadier.StringReader; +import com.mojang.brigadier.context.CommandContext; +import com.mojang.brigadier.exceptions.CommandSyntaxException; +import com.mojang.brigadier.suggestion.Suggestions; +import com.mojang.brigadier.suggestion.SuggestionsBuilder; +import net.minecraft.text.Text; +import tools.redstone.redstonetools.utils.NumberBase; + +import java.util.Arrays; +import java.util.Collection; +import java.util.concurrent.CompletableFuture; + +public class NumberBaseSerializer extends TypeSerializer { + private static final IntegerSerializer INT_SERIALIZER = IntegerSerializer.integer(2, 36); + private static final NumberBaseSerializer INSTANCE = new NumberBaseSerializer(); + + public static NumberBaseSerializer numberBase() { + return INSTANCE; + } + + protected NumberBaseSerializer() { + super(Integer.class); + } + + @Override + public Integer deserialize(StringReader reader) throws CommandSyntaxException { + var input = reader.readUnquotedString(); + + try { + return deserialize(input); + } catch (IllegalArgumentException e) { + throw new CommandSyntaxException(null, Text.of(e.getMessage())); + } + } + + @Override + public Integer deserialize(String serialized) { + try { + return NumberBase.fromString(serialized) + .map(NumberBase::toInt) + .orElseGet(() -> INT_SERIALIZER.deserialize(serialized)); + } catch (IllegalArgumentException e) { + throw new IllegalArgumentException("Invalid base '" + serialized + "'.", e); + } + } + + @Override + public String serialize(Integer value) { + return NumberBase.fromInt(value) + .map(NumberBase::toString) + .orElseGet(() -> INT_SERIALIZER.serialize(value)); + } + + public String serialize(NumberBase value) { + return serialize(value.toInt()); + } + + @Override + public Collection getExamples() { + return Arrays.stream(NumberBase.values()) + .map(this::serialize) + .toList(); + } + + @Override + public CompletableFuture listSuggestions(CommandContext context, SuggestionsBuilder builder) { + for (var value : NumberBase.values()) { + builder = builder.suggest(serialize(value)); + } + + return builder.buildFuture(); + } +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/NumberSerializer.java b/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/NumberSerializer.java new file mode 100644 index 00000000..320eb217 --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/NumberSerializer.java @@ -0,0 +1,34 @@ +package tools.redstone.redstonetools.features.arguments.serializers; + +import tools.redstone.redstonetools.utils.NumberArg; + +import java.util.Optional; + +public class NumberSerializer extends IntLikeSerializer { + private static final NumberSerializer INSTANCE = new NumberSerializer(null,null); + + public static NumberSerializer numberArg(){ + return INSTANCE; + } + + public static NumberSerializer numberArg(NumberArg min) { + return new NumberSerializer(min, null); + } + + public static NumberSerializer numberArg(NumberArg min, NumberArg max) { + return new NumberSerializer(min, max); + } + + private NumberSerializer(NumberArg min, NumberArg max){ + super(NumberArg.class,min, max); + } + + @Override + protected Optional tryParseOptional(String string, int radix) { + try { + return Optional.of(new NumberArg(string, radix)); + } catch (NumberFormatException ignored) { + return Optional.empty(); + } + } +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/SignalBlockSerializer.java b/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/SignalBlockSerializer.java new file mode 100644 index 00000000..14c12ad3 --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/SignalBlockSerializer.java @@ -0,0 +1,15 @@ +package tools.redstone.redstonetools.features.arguments.serializers; + +import tools.redstone.redstonetools.utils.SignalBlock; + +public class SignalBlockSerializer extends EnumSerializer { + private static final SignalBlockSerializer INSTANCE = new SignalBlockSerializer(); + + private SignalBlockSerializer() { + super(SignalBlock.class); + } + + public static SignalBlockSerializer signalBlock() { + return INSTANCE; + } +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/StringBrigadierSerializer.java b/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/StringBrigadierSerializer.java new file mode 100644 index 00000000..f5dba14b --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/StringBrigadierSerializer.java @@ -0,0 +1,22 @@ +package tools.redstone.redstonetools.features.arguments.serializers; + +import com.mojang.brigadier.StringReader; +import com.mojang.brigadier.arguments.ArgumentType; +import com.mojang.brigadier.exceptions.CommandSyntaxException; + +public abstract class StringBrigadierSerializer extends BrigadierSerializer { + + public StringBrigadierSerializer(Class clazz, ArgumentType argumentType) { + super(clazz, argumentType); + } + + @Override + public T deserialize(String serialized) { + try { + return deserialize(new StringReader(serialized)); + } catch (CommandSyntaxException e) { + throw new IllegalStateException("Syntax Exception: " + e.getMessage()); + } + } + +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/StringSerializer.java b/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/StringSerializer.java new file mode 100644 index 00000000..a7ddbf29 --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/StringSerializer.java @@ -0,0 +1,34 @@ +package tools.redstone.redstonetools.features.arguments.serializers; + +import com.mojang.brigadier.arguments.ArgumentType; +import com.mojang.brigadier.arguments.StringArgumentType; + +public class StringSerializer extends StringBrigadierSerializer { + + private static final StringSerializer INSTANCE_WORD = new StringSerializer(StringArgumentType.word()); + private static final StringSerializer INSTANCE_STRING = new StringSerializer(StringArgumentType.string()); + private static final StringSerializer INSTANCE_GREEDY_STRING = new StringSerializer(StringArgumentType.greedyString()); + + public static StringSerializer string() { + return INSTANCE_STRING; + } + + public static StringSerializer word() { + return INSTANCE_WORD; + } + + public static StringSerializer greedyString() { + return INSTANCE_GREEDY_STRING; + } + + protected StringSerializer(ArgumentType argumentType) { + super(String.class, argumentType); + } + + @Override + public String serialize(String value) { + // TODO: Check if this is correct, doesn't StringArgumentType.string() require quotes which this doesn't add? + return value; + } + +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/TypeSerializer.java b/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/TypeSerializer.java new file mode 100644 index 00000000..9796c052 --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/TypeSerializer.java @@ -0,0 +1,47 @@ +package tools.redstone.redstonetools.features.arguments.serializers; + +import com.mojang.brigadier.StringReader; +import com.mojang.brigadier.arguments.ArgumentType; +import com.mojang.brigadier.context.CommandContext; +import com.mojang.brigadier.exceptions.CommandSyntaxException; +import com.mojang.brigadier.suggestion.Suggestions; +import com.mojang.brigadier.suggestion.SuggestionsBuilder; + +import java.util.Collection; +import java.util.concurrent.CompletableFuture; + +/** + * Base class for the 'wrapped' argument type. + * + * @param The value type. + * @param The serialized type. + */ +public abstract class TypeSerializer implements ArgumentType { + + protected final Class clazz; + + // TODO: Consider moving this constructor to enum serializer as it's the only class that uses the clazz field + protected TypeSerializer(Class clazz) { + this.clazz = clazz; + } + + public Class getTypeClass() { + return clazz; + } + + /* ArgumentType impl */ + @Override + public final T parse(StringReader reader) throws CommandSyntaxException { + return deserialize(reader); + } + + /* String Serialization */ + public abstract T deserialize(StringReader reader) throws CommandSyntaxException; + public abstract T deserialize(S serialized); + public abstract S serialize(T value); + + /* Usage In Commands */ + public abstract Collection getExamples(); + public abstract CompletableFuture listSuggestions(CommandContext context, SuggestionsBuilder builder); + +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/commands/BaseConvertFeature.java b/oldSrc/main/java/tools/redstone/redstonetools/features/commands/BaseConvertFeature.java new file mode 100644 index 00000000..818d4203 --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/features/commands/BaseConvertFeature.java @@ -0,0 +1,32 @@ +package tools.redstone.redstonetools.features.commands; + +import com.google.auto.service.AutoService; +import net.minecraft.server.command.ServerCommandSource; +import tools.redstone.redstonetools.features.AbstractFeature; +import tools.redstone.redstonetools.features.Feature; +import tools.redstone.redstonetools.features.arguments.Argument; +import tools.redstone.redstonetools.features.feedback.Feedback; +import tools.redstone.redstonetools.utils.NumberArg; + + +import static tools.redstone.redstonetools.features.arguments.serializers.NumberBaseSerializer.numberBase; +import static tools.redstone.redstonetools.features.arguments.serializers.NumberSerializer.numberArg; + +@AutoService(AbstractFeature.class) +@Feature(name = "Base Convert", description = "Converts a number from one base to another.", command = "base") +public class BaseConvertFeature extends CommandFeature { + + public static final Argument inputNum = Argument + .ofType(numberArg()); + public static final Argument toBase = Argument + .ofType(numberBase()) + .withDefault(10); + + @Override + protected Feedback execute(ServerCommandSource source) { + var input = inputNum.getValue().toPrefixedString(); + var output = inputNum.getValue().toPrefixedString(toBase.getValue()); + + return Feedback.success("{} = {}", input, output); + } +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/commands/BinaryBlockReadFeature.java b/oldSrc/main/java/tools/redstone/redstonetools/features/commands/BinaryBlockReadFeature.java new file mode 100644 index 00000000..808f5d10 --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/features/commands/BinaryBlockReadFeature.java @@ -0,0 +1,101 @@ +package tools.redstone.redstonetools.features.commands; + +import com.google.auto.service.AutoService; +import tools.redstone.redstonetools.features.AbstractFeature; +import tools.redstone.redstonetools.features.Feature; +import tools.redstone.redstonetools.features.arguments.Argument; +import tools.redstone.redstonetools.features.feedback.Feedback; +import tools.redstone.redstonetools.utils.WorldEditUtils; +import com.mojang.brigadier.exceptions.CommandSyntaxException; +import com.sk89q.worldedit.math.BlockVector3; +import net.minecraft.block.Blocks; +import net.minecraft.block.RedstoneLampBlock; +import net.minecraft.command.argument.BlockStateArgument; +import net.minecraft.server.command.ServerCommandSource; +import net.minecraft.util.math.BlockPos; + +import java.util.Collections; + +import static tools.redstone.redstonetools.features.arguments.serializers.BlockStateArgumentSerializer.blockState; +import static tools.redstone.redstonetools.features.arguments.serializers.BoolSerializer.bool; +import static tools.redstone.redstonetools.features.arguments.serializers.IntegerSerializer.integer; +import static tools.redstone.redstonetools.features.arguments.serializers.NumberBaseSerializer.numberBase; + +@AutoService(AbstractFeature.class) +@Feature(name = "Binary Block Read", description = "Interprets your WorldEdit selection as a binary number.", command = "/read", worldedit = true) +public class BinaryBlockReadFeature extends CommandFeature { + private static final BlockStateArgument LIT_LAMP_ARG = new BlockStateArgument( + Blocks.REDSTONE_LAMP.getDefaultState().with(RedstoneLampBlock.LIT, true), + Collections.singleton(RedstoneLampBlock.LIT), + null + ); + + public static final Argument offset = Argument + .ofType(integer(1)) + .withDefault(2); + public static final Argument onBlock = Argument + .ofType(blockState()) + .withDefault(LIT_LAMP_ARG); + public static final Argument toBase = Argument + .ofType(numberBase()) + .withDefault(10); + public static final Argument reverseBits = Argument + .ofType(bool()) + .withDefault(false); + + @Override + protected Feedback execute(ServerCommandSource source) throws CommandSyntaxException { + var selectionOrFeedback = WorldEditUtils.getSelection(source.getPlayer()); + + if (selectionOrFeedback.right().isPresent()) { + return selectionOrFeedback.right().get(); + } + + assert selectionOrFeedback.left().isPresent(); + var selection = selectionOrFeedback.left().get(); + + var boundingBox = selection.getBoundingBox(); + var pos1 = boundingBox.getPos1(); + var pos2 = boundingBox.getPos2(); + var direction = pos2.subtract(pos1).normalize(); + + // prevent infinite loop + if (direction.lengthSq() == 0) { + direction = BlockVector3.at(0, 0, 1); + } + + var spacingVector = direction.multiply(offset.getValue()); + + if (direction.getBlockX() + direction.getBlockY() + direction.getBlockZ() > 1) { + return Feedback.invalidUsage("The selection must have 2 axis the same."); + } + + var bits = new StringBuilder(); + for (BlockVector3 point = pos1; boundingBox.contains(point); point = point.add(spacingVector)) { + var pos = new BlockPos(point.getBlockX(), point.getBlockY(), point.getBlockZ()); + var actualState = source.getWorld().getBlockState(pos); + + var matches = actualState.getBlock() == onBlock.getValue().getBlockState().getBlock(); + if (matches) { + for (var property : onBlock.getValue().getProperties()) { + var propertyValue = onBlock.getValue().getBlockState().get(property); + + if (!actualState.get(property).equals(propertyValue)) { + matches = false; + break; + } + } + } + + bits.append(matches ? 1 : 0); + } + + if (reverseBits.getValue()) { + bits.reverse(); + } + + var output = Integer.toString(Integer.parseInt(bits.toString(), 2), toBase.getValue()); + return Feedback.success("{}.", output); + } + +} \ No newline at end of file diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/commands/BlockRaycastFeature.java b/oldSrc/main/java/tools/redstone/redstonetools/features/commands/BlockRaycastFeature.java new file mode 100644 index 00000000..d8c1b842 --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/features/commands/BlockRaycastFeature.java @@ -0,0 +1,42 @@ +package tools.redstone.redstonetools.features.commands; + +import tools.redstone.redstonetools.features.feedback.Feedback; +import tools.redstone.redstonetools.utils.BlockInfo; +import com.mojang.brigadier.exceptions.CommandSyntaxException; +import net.minecraft.client.MinecraftClient; +import net.minecraft.server.command.ServerCommandSource; +import net.minecraft.text.Text; +import net.minecraft.util.hit.BlockHitResult; +import net.minecraft.util.hit.HitResult; + +import javax.annotation.Nullable; + +public abstract class BlockRaycastFeature extends CommandFeature { + protected Feedback execute(ServerCommandSource source) throws CommandSyntaxException { + MinecraftClient client = MinecraftClient.getInstance(); + if (client.player == null || client.world == null) { + throw new CommandSyntaxException(null, Text.of("This command is client-side only.")); + } + + if (client.crosshairTarget == null || client.crosshairTarget.getType() != HitResult.Type.BLOCK) { + if (requiresBlock()) { + return Feedback.invalidUsage("You must be looking at a block to use this command."); + } else { + return execute(source, null); + } + } + + var blockPos = ((BlockHitResult) client.crosshairTarget).getBlockPos(); + var blockState = client.world.getBlockState(blockPos); + var blockEntity = client.world.getBlockEntity(blockPos); + var block = blockState.getBlock(); + + return execute(source, new BlockInfo(block, blockPos, blockState, blockEntity)); + } + + protected boolean requiresBlock() { + return true; + } + + protected abstract Feedback execute(ServerCommandSource source, @Nullable BlockInfo blockInfo) throws CommandSyntaxException; +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/commands/ColorCodeFeature.java b/oldSrc/main/java/tools/redstone/redstonetools/features/commands/ColorCodeFeature.java new file mode 100644 index 00000000..00742feb --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/features/commands/ColorCodeFeature.java @@ -0,0 +1,113 @@ +package tools.redstone.redstonetools.features.commands; + +import com.google.auto.service.AutoService; +import tools.redstone.redstonetools.features.AbstractFeature; +import tools.redstone.redstonetools.features.Feature; +import tools.redstone.redstonetools.features.arguments.Argument; +import tools.redstone.redstonetools.features.feedback.Feedback; +import tools.redstone.redstonetools.utils.BlockColor; +import tools.redstone.redstonetools.utils.ColoredBlock; +import tools.redstone.redstonetools.utils.WorldEditUtils; +import com.mojang.brigadier.exceptions.CommandSyntaxException; +import com.sk89q.worldedit.EditSession; +import com.sk89q.worldedit.WorldEdit; +import com.sk89q.worldedit.fabric.FabricAdapter; +import com.sk89q.worldedit.function.mask.Mask; +import com.sk89q.worldedit.function.mask.Mask2D; +import com.sk89q.worldedit.function.operation.Operations; +import com.sk89q.worldedit.math.BlockVector3; +import com.sk89q.worldedit.world.World; +import com.sk89q.worldedit.world.block.BaseBlock; +import com.sk89q.worldedit.world.block.BlockType; +import net.minecraft.server.command.ServerCommandSource; +import org.jetbrains.annotations.Nullable; +import static tools.redstone.redstonetools.features.arguments.serializers.BlockColorSerializer.blockColor; + +@AutoService(AbstractFeature.class) +@Feature(name = "Color Code", description = "Color codes all color-able blocks in your WorldEdit selection.", command = "/colorcode", worldedit = true) +public class ColorCodeFeature extends CommandFeature { + public static final Argument color = Argument + .ofType(blockColor()); + public static final Argument onlyColor = Argument + .ofType(blockColor()) + .withDefault(null); + + private boolean shouldBeColored(World world, BlockVector3 pos, BlockColor onlyColor) { + var state = world.getBlock(pos); + var blockId = state.getBlockType().getId(); + + var coloredBlock = ColoredBlock.fromBlockId(blockId); + if (coloredBlock == null) return false; + + if (onlyColor == null) return true; + + var blockColor = coloredBlock.color; + return blockColor == onlyColor; + } + + private BaseBlock getColoredBlock(World world, BlockVector3 pos, BlockColor color) { + var state = world.getBlock(pos); + var blockId = state.getBlockType().getId(); + + var coloredBlock = ColoredBlock.fromBlockId(blockId); + if (coloredBlock == null) return state.toBaseBlock(); + + var blockType = BlockType.REGISTRY.get(coloredBlock.withColor(color).toBlockId()); + assert blockType != null; + + return blockType.getDefaultState().toBaseBlock(); + } + + @Override + protected Feedback execute(ServerCommandSource source) throws CommandSyntaxException { + var player = source.getPlayer(); + + var selectionOrFeedback = WorldEditUtils.getSelection(player); + if (selectionOrFeedback.right().isPresent()) { + return selectionOrFeedback.right().get(); + } + + assert selectionOrFeedback.left().isPresent(); + var selection = selectionOrFeedback.left().get(); + + var worldEdit = WorldEdit.getInstance(); + var wePlayer = FabricAdapter.adaptPlayer(player); + var playerSession = worldEdit.getSessionManager().get(wePlayer); + + // for each block in the selection + final World world = FabricAdapter.adapt(player.getWorld()); + try (EditSession session = worldEdit.newEditSession(FabricAdapter.adapt(player.getWorld()))) { + // create mask and pattern and execute block set + int blocksColored = session.replaceBlocks(selection, + new Mask() { + @Override + public boolean test(BlockVector3 vector) { + return shouldBeColored(world, vector, onlyColor.getValue()); + } + + @Nullable + @Override + public Mask2D toMask2D() { + return null; + } + }, + new com.sk89q.worldedit.function.pattern.Pattern() { + @Override + public BaseBlock applyBlock(BlockVector3 position) { + return getColoredBlock(world, position, color.getValue()); + } + } + ); + + Operations.complete(session.commit()); + + // call remember to allow undo + playerSession.remember(session); + + return Feedback.success("Successfully colored {} block(s) {}.", blocksColored, color.getValue()); + } catch (Exception e) { + return Feedback.error("An error occurred while coloring the block(s)."); + } + } + +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/commands/ColoredFeature.java b/oldSrc/main/java/tools/redstone/redstonetools/features/commands/ColoredFeature.java new file mode 100644 index 00000000..d7505c29 --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/features/commands/ColoredFeature.java @@ -0,0 +1,38 @@ +package tools.redstone.redstonetools.features.commands; + +import com.google.auto.service.AutoService; +import tools.redstone.redstonetools.features.AbstractFeature; +import tools.redstone.redstonetools.features.Feature; +import tools.redstone.redstonetools.features.arguments.Argument; +import tools.redstone.redstonetools.features.feedback.Feedback; +import tools.redstone.redstonetools.utils.BlockColor; +import tools.redstone.redstonetools.utils.BlockInfo; +import com.mojang.datafixers.util.Either; +import net.minecraft.item.ItemStack; +import net.minecraft.server.command.ServerCommandSource; +import tools.redstone.redstonetools.utils.ColoredBlockType; + +import javax.annotation.Nullable; + +import static tools.redstone.redstonetools.features.arguments.serializers.ColoredBlockTypeSerializer.coloredBlockType; + +@AutoService(AbstractFeature.class) +@Feature(name = "Colored", description = "Gives the player specified variant of block being looked at, with the same color. Default is White.", command = "colored") +public class ColoredFeature extends PickBlockFeature { + public static final Argument blockType = Argument.ofType(coloredBlockType()); + @Override + protected boolean requiresBlock() { + return false; + } + + @Override + protected Either getItemStack(ServerCommandSource source, @Nullable BlockInfo blockInfo) { + var color = blockInfo == null + ? BlockColor.WHITE + : BlockColor.fromBlock(blockInfo.block); + + var coloredBlock = blockType.getValue().withColor(color); + + return Either.left(new ItemStack(coloredBlock.toBlock())); + } +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/commands/CommandFeature.java b/oldSrc/main/java/tools/redstone/redstonetools/features/commands/CommandFeature.java new file mode 100644 index 00000000..cc5f9412 --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/features/commands/CommandFeature.java @@ -0,0 +1,78 @@ +package tools.redstone.redstonetools.features.commands; + +import net.fabricmc.fabric.api.client.event.lifecycle.v1.ClientTickEvents; +import net.fabricmc.fabric.api.client.keybinding.v1.KeyBindingHelper; +import net.minecraft.client.option.KeyBinding; +import net.minecraft.client.util.InputUtil; +import tools.redstone.redstonetools.features.AbstractFeature; +import tools.redstone.redstonetools.features.feedback.AbstractFeedbackSender; +import tools.redstone.redstonetools.features.feedback.Feedback; +import tools.redstone.redstonetools.utils.CommandUtils; +import tools.redstone.redstonetools.utils.ReflectionUtils; +import com.mojang.brigadier.CommandDispatcher; +import com.mojang.brigadier.exceptions.CommandSyntaxException; +import net.minecraft.server.command.ServerCommandSource; + +import java.util.ArrayList; +import java.util.List; + +import static tools.redstone.redstonetools.RedstoneToolsClient.INJECTOR; + + +public abstract class CommandFeature extends AbstractFeature { + private static final List keyBindings = new ArrayList<>(); + + @Override + public void register() { + super.register(); + + var containsRequiredArguments = ReflectionUtils.getArguments(getClass()).stream() + .anyMatch(a -> !a.isOptional()); + if (containsRequiredArguments) { + return; + } + + var info = ReflectionUtils.getFeatureInfo(getClass()); + var keyBinding = KeyBindingHelper.registerKeyBinding(new KeyBinding( + info.name(), + InputUtil.Type.KEYSYM, + -1, + "Redstone Tools" + )); + + keyBindings.add(keyBinding); + + ClientTickEvents.END_CLIENT_TICK.register(client -> { + while (keyBinding.wasPressed()) { + assert client.player != null; + client.player.sendChatMessage("/" + info.command()); + } + }); + } + + @Override + protected void registerCommands(CommandDispatcher dispatcher, boolean dedicated) { + var info = ReflectionUtils.getFeatureInfo(getClass()); + var arguments = ReflectionUtils.getArguments(getClass()); + + CommandUtils.register( + info.command(), + arguments, + context -> { + for (var argument : arguments) { + argument.updateValue(context); + } + + var feedback = execute(context.getSource()); + + INJECTOR.getInstance(AbstractFeedbackSender.class) + .sendFeedback(context.getSource(), feedback); + + return feedback.getType().getCode(); + }, + dispatcher, + dedicated); + } + + protected abstract Feedback execute(ServerCommandSource source) throws CommandSyntaxException; +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/commands/CopyStateFeature.java b/oldSrc/main/java/tools/redstone/redstonetools/features/commands/CopyStateFeature.java new file mode 100644 index 00000000..3e0a7cc3 --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/features/commands/CopyStateFeature.java @@ -0,0 +1,48 @@ +package tools.redstone.redstonetools.features.commands; + +import com.google.auto.service.AutoService; +import com.mojang.datafixers.util.Either; +import net.minecraft.block.BlockState; +import net.minecraft.client.MinecraftClient; +import net.minecraft.item.ItemStack; +import net.minecraft.server.command.ServerCommandSource; +import tools.redstone.redstonetools.features.AbstractFeature; +import tools.redstone.redstonetools.features.Feature; +import tools.redstone.redstonetools.features.feedback.Feedback; +import tools.redstone.redstonetools.mixin.accessors.MinecraftClientAccessor; +import tools.redstone.redstonetools.utils.BlockInfo; +import tools.redstone.redstonetools.utils.BlockStateNbtUtil; + + +import static tools.redstone.redstonetools.utils.ItemUtils.addExtraNBTText; + + +@AutoService(AbstractFeature.class) +@Feature(name = "Copy State", description = "Gives you a copy of the block you're looking at with its BlockState.", command = "copystate") +public class CopyStateFeature extends PickBlockFeature { + @Override + protected Either getItemStack(ServerCommandSource source, BlockInfo blockInfo) { + MinecraftClient client = MinecraftClient.getInstance(); + + ItemStack itemStack = blockInfo.block.getPickStack(client.world, blockInfo.pos, blockInfo.state); + + if (blockInfo.state.hasBlockEntity()) { + ((MinecraftClientAccessor) client).invokeAddBlockEntityNbt(itemStack, blockInfo.entity); + } + + int i = addBlockStateNbt(itemStack, blockInfo.state); + if (i == -1) { + return Either.right(Feedback.invalidUsage("This block doesn't have any BlockState!")); + } + + return Either.left(itemStack); + } + + private int addBlockStateNbt(ItemStack itemStack, BlockState blockState) { + addExtraNBTText(itemStack, "BlockState"); + BlockStateNbtUtil.putPlacement(itemStack, blockState); + return 1; + } + + +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/commands/ItemBindFeature.java b/oldSrc/main/java/tools/redstone/redstonetools/features/commands/ItemBindFeature.java new file mode 100644 index 00000000..4403353b --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/features/commands/ItemBindFeature.java @@ -0,0 +1,53 @@ +package tools.redstone.redstonetools.features.commands; + + +import com.google.auto.service.AutoService; +import com.mojang.brigadier.exceptions.CommandSyntaxException; +import net.minecraft.client.MinecraftClient; +import net.minecraft.item.ItemStack; +import net.minecraft.item.Items; +import net.minecraft.nbt.NbtString; +import net.minecraft.server.command.ServerCommandSource; +import net.minecraft.server.network.ServerPlayerEntity; +import tools.redstone.redstonetools.features.AbstractFeature; +import tools.redstone.redstonetools.features.Feature; +import tools.redstone.redstonetools.features.feedback.Feedback; +import tools.redstone.redstonetools.utils.ItemUtils; + +@AutoService(AbstractFeature.class) +@Feature(command = "itembind", description = "Allows you to bind command to a specific item", name = "Item Bind") +public class ItemBindFeature extends CommandFeature{ + public static boolean waitingForCommand = false; + private static ServerPlayerEntity player; + + + @Override + protected Feedback execute(ServerCommandSource source) throws CommandSyntaxException { + + player = source.getPlayer(); + waitingForCommand = true; + + return Feedback.success("Please run any command and hold the item you want the command be bound to"); + } + + public static Feedback addCommand(String command) { + if (!waitingForCommand || MinecraftClient.getInstance().getServer() == null) return null; + + if (player == null || MinecraftClient.getInstance().getServer().getPlayerManager().getPlayer(player.getUuid()) != player) { + waitingForCommand = false; + return null; + } + + ItemStack mainHandStack = player.getMainHandStack(); + if (mainHandStack == null || mainHandStack.getItem() == Items.AIR) { + return Feedback.error("You need to be holding an item!"); + } + + mainHandStack.getOrCreateNbt().put("command", NbtString.of(command)); + ItemUtils.addExtraNBTText(mainHandStack,"Command"); + + waitingForCommand = false; + + return Feedback.success("Successfully bound command: '{}' to this item ({})!", command, mainHandStack.getItem()); + } +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/commands/MacroFeature.java b/oldSrc/main/java/tools/redstone/redstonetools/features/commands/MacroFeature.java new file mode 100644 index 00000000..6afa69ba --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/features/commands/MacroFeature.java @@ -0,0 +1,31 @@ +package tools.redstone.redstonetools.features.commands; + +import com.google.auto.service.AutoService; +import tools.redstone.redstonetools.features.AbstractFeature; +import tools.redstone.redstonetools.features.Feature; +import tools.redstone.redstonetools.features.arguments.Argument; +import tools.redstone.redstonetools.features.feedback.Feedback; +import tools.redstone.redstonetools.macros.MacroManager; +import com.mojang.brigadier.exceptions.CommandSyntaxException; +import net.minecraft.server.command.ServerCommandSource; +import static tools.redstone.redstonetools.RedstoneToolsClient.INJECTOR; +import static tools.redstone.redstonetools.features.arguments.serializers.MacroNameSerializer.macroName; + +@AutoService(AbstractFeature.class) +@Feature(command = "macro", description = "Allows you to execute a macro", name = "Macro") +public class MacroFeature extends CommandFeature { + public static final Argument macro = Argument.ofType(macroName()); + + @Override + protected Feedback execute(ServerCommandSource source) throws CommandSyntaxException { + var macroObj = INJECTOR.getInstance(MacroManager.class).getMacro(macro.getValue()); + + + if (macroObj == null) { + return Feedback.invalidUsage("Macro \"{}\" does not exist.", macro.getValue()); + } + + macroObj.run(); + return Feedback.none(); + } +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/commands/MinSelectionFeature.java b/oldSrc/main/java/tools/redstone/redstonetools/features/commands/MinSelectionFeature.java new file mode 100644 index 00000000..388da842 --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/features/commands/MinSelectionFeature.java @@ -0,0 +1,126 @@ +package tools.redstone.redstonetools.features.commands; + +import com.google.auto.service.AutoService; +import tools.redstone.redstonetools.features.AbstractFeature; +import tools.redstone.redstonetools.features.Feature; +import tools.redstone.redstonetools.features.feedback.Feedback; +import tools.redstone.redstonetools.utils.WorldEditUtils; +import com.mojang.brigadier.exceptions.CommandSyntaxException; +import com.sk89q.worldedit.WorldEdit; +import com.sk89q.worldedit.fabric.FabricAdapter; +import com.sk89q.worldedit.math.BlockVector3; +import com.sk89q.worldedit.regions.CuboidRegion; +import com.sk89q.worldedit.regions.Region; +import com.sk89q.worldedit.regions.RegionOperationException; +import com.sk89q.worldedit.world.World; +import com.sk89q.worldedit.world.block.BlockTypes; +import net.minecraft.server.command.ServerCommandSource; +import net.minecraft.text.Text; + +import java.util.ArrayList; +import java.util.List; + +@AutoService(AbstractFeature.class) +@Feature(command = "/minsel", description = "Removes all air-only layers from a selection", name = "Minimize Selection", worldedit = true) +public class MinSelectionFeature extends CommandFeature { + + @Override + protected Feedback execute(ServerCommandSource source) throws CommandSyntaxException { + var selectionOrFeedback = WorldEditUtils.getSelection(source.getPlayer()); + if (selectionOrFeedback.right().isPresent()) { + return selectionOrFeedback.right().get(); + } + + assert selectionOrFeedback.left().isPresent(); + var selection = selectionOrFeedback.left().get(); + var selectionWorld = selection.getWorld(); + + var actor = FabricAdapter.adaptPlayer(source.getPlayer()); + + var localSession = WorldEdit.getInstance() + .getSessionManager() + .get(actor); + + var selector = localSession.getRegionSelector(selectionWorld); + + boolean isEmpty = true; + for (BlockVector3 point : selection) { + if (!selectionWorld.getBlock(point).equals(BlockTypes.AIR.getDefaultState())) + isEmpty = false; + } + + if (isEmpty) { + return Feedback.invalidUsage("Cannot minimize empty selections."); + } + + + minimiseSelection(selectionWorld, selection); + + selector.learnChanges(); + selector.explainRegionAdjust(actor, localSession); + + return Feedback.success("Minimized selection."); + } + + private void minimiseSelection(World selectionWorld, Region selection) + throws CommandSyntaxException { + List changes = new ArrayList<>(); + var faces = getFaces(selection); + var finished = true; + + for (CuboidRegion face : faces) { + var isOnlyAir = true; + + for (BlockVector3 point : face) { + if (selectionWorld.getBlock(point).getBlockType().getDefaultState() != BlockTypes.AIR + .getDefaultState()) { + isOnlyAir = false; + break; + } + } + + if (!isOnlyAir) + continue; + + var difference = selection.getCenter().subtract(face.getCenter()); + difference = difference.normalize(); + + changes.add(difference.toBlockPoint()); + + finished = false; + + } + + try { + selection.contract(changes.toArray(new BlockVector3[changes.size()])); + } catch (RegionOperationException e) { + throw new net.minecraft.command.CommandException(Text.of("There was an error modifying the region.")); + } + + if (!finished) + minimiseSelection(selectionWorld, selection); + + } + + private List getFaces(Region selection) { + var faces = new ArrayList(); + + var pos1 = selection.getBoundingBox().getPos1(); + var pos2 = selection.getBoundingBox().getPos2(); + + var min = selection.getMinimumPoint(); + var max = selection.getMaximumPoint(); + + faces.add(new CuboidRegion(pos1.withX(min.getX()), pos2.withX(min.getX()))); + faces.add(new CuboidRegion(pos1.withX(max.getX()), pos2.withX(max.getX()))); + + faces.add(new CuboidRegion(pos1.withZ(min.getZ()), pos2.withZ(min.getZ()))); + faces.add(new CuboidRegion(pos1.withZ(max.getZ()), pos2.withZ(max.getZ()))); + + faces.add(new CuboidRegion(pos1.withY(min.getY()), pos2.withY(min.getY()))); + faces.add(new CuboidRegion(pos1.withY(max.getY()), pos2.withY(max.getY()))); + + return faces; + } + +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/commands/PickBlockFeature.java b/oldSrc/main/java/tools/redstone/redstonetools/features/commands/PickBlockFeature.java new file mode 100644 index 00000000..756563e3 --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/features/commands/PickBlockFeature.java @@ -0,0 +1,45 @@ +package tools.redstone.redstonetools.features.commands; + +import tools.redstone.redstonetools.features.feedback.Feedback; +import tools.redstone.redstonetools.utils.BlockInfo; +import com.mojang.brigadier.exceptions.CommandSyntaxException; +import com.mojang.datafixers.util.Either; +import net.minecraft.client.MinecraftClient; +import net.minecraft.entity.player.PlayerInventory; +import net.minecraft.item.ItemStack; +import net.minecraft.server.command.ServerCommandSource; +import net.minecraft.text.Text; +import net.minecraft.util.Hand; + +import javax.annotation.Nullable; + +public abstract class PickBlockFeature extends BlockRaycastFeature { + @Override + protected final Feedback execute(ServerCommandSource source, @Nullable BlockInfo blockInfo) throws CommandSyntaxException { + MinecraftClient client = MinecraftClient.getInstance(); + if (client.player == null) { + return Feedback.error("Failed to get player."); + } + + var stackOrFeedback = getItemStack(source, blockInfo); + if (stackOrFeedback.right().isPresent()) { + return stackOrFeedback.right().get(); + } + + assert stackOrFeedback.left().isPresent(); + var stack = stackOrFeedback.left().get(); + + PlayerInventory playerInventory = client.player.getInventory(); + playerInventory.addPickBlock(stack); + + if (client.interactionManager == null) { + throw new CommandSyntaxException(null, Text.of("Failed to get interaction manager.")); + } + + client.interactionManager.clickCreativeStack(client.player.getStackInHand(Hand.MAIN_HAND), 36 + playerInventory.selectedSlot); + + return Feedback.none(); + } + + protected abstract Either getItemStack(ServerCommandSource source, @Nullable BlockInfo blockInfo) throws CommandSyntaxException; +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/commands/QuickTpFeature.java b/oldSrc/main/java/tools/redstone/redstonetools/features/commands/QuickTpFeature.java new file mode 100644 index 00000000..dc3a6593 --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/features/commands/QuickTpFeature.java @@ -0,0 +1,60 @@ +package tools.redstone.redstonetools.features.commands; + +import com.google.auto.service.AutoService; +import tools.redstone.redstonetools.features.AbstractFeature; +import tools.redstone.redstonetools.features.Feature; +import tools.redstone.redstonetools.features.arguments.Argument; +import tools.redstone.redstonetools.features.feedback.Feedback; +import tools.redstone.redstonetools.utils.PositionUtils; +import tools.redstone.redstonetools.utils.RaycastUtils; +import com.mojang.brigadier.exceptions.CommandSyntaxException; +import net.minecraft.entity.player.PlayerEntity; +import net.minecraft.server.command.ServerCommandSource; +import net.minecraft.util.hit.BlockHitResult; +import net.minecraft.util.hit.HitResult; +import net.minecraft.util.math.Vec3d; +import static tools.redstone.redstonetools.features.arguments.serializers.BoolSerializer.bool; +import static tools.redstone.redstonetools.features.arguments.serializers.FloatSerializer.floatArg; + +@AutoService(AbstractFeature.class) +@Feature(name = "Quick TP", description = "Teleports you in the direction you are looking.", command = "quicktp") +public class QuickTpFeature extends CommandFeature { + public static final Argument distance = Argument + .ofType(floatArg(1.0f)) + .withDefault(50.0f); + public static final Argument includeFluids = Argument + .ofType(bool()) + .withDefault(false); + + @Override + protected Feedback execute(ServerCommandSource source) throws CommandSyntaxException { + var player = source.getPlayer(); + + var targetPosition = getTargetPosition(player); + + player.teleport(targetPosition.x, targetPosition.y, targetPosition.z); + + return Feedback.none(); + } + + private Vec3d getTargetPosition(PlayerEntity player) { + // 8 chunks default, 16 blocks per chunk + var renderDistanceBlocks = PlayerEntity.getRenderDistanceMultiplier() * 8 * 16; + var hit = player.raycast(Math.min(distance.getValue(), renderDistanceBlocks), 0, includeFluids.getValue()); + + return clampHitPosition(hit).subtract(0, 1.12, 0); + } + + private Vec3d clampHitPosition(HitResult hit) { + if (hit.getType() != HitResult.Type.BLOCK) { + return hit.getPos().subtract(0, 0.5, 0); + } + + var blockHit = (BlockHitResult) hit; + + var neighbor = RaycastUtils.getBlockHitNeighbor(blockHit); + var neighborPos = neighbor.getBlockPos(); + + return PositionUtils.getBottomPositionOfBlock(neighborPos); + } +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/commands/RStackFeature.java b/oldSrc/main/java/tools/redstone/redstonetools/features/commands/RStackFeature.java new file mode 100644 index 00000000..d06452a5 --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/features/commands/RStackFeature.java @@ -0,0 +1,98 @@ +package tools.redstone.redstonetools.features.commands; + +import com.google.auto.service.AutoService; +import tools.redstone.redstonetools.features.AbstractFeature; +import tools.redstone.redstonetools.features.Feature; +import tools.redstone.redstonetools.features.arguments.Argument; +import tools.redstone.redstonetools.features.feedback.Feedback; +import tools.redstone.redstonetools.utils.DirectionArgument; +import com.mojang.brigadier.exceptions.CommandSyntaxException; +import com.sk89q.worldedit.IncompleteRegionException; +import com.sk89q.worldedit.WorldEdit; +import com.sk89q.worldedit.WorldEditException; +import com.sk89q.worldedit.fabric.FabricAdapter; +import com.sk89q.worldedit.function.mask.Mask; +import com.sk89q.worldedit.function.mask.Mask2D; +import com.sk89q.worldedit.function.operation.ForwardExtentCopy; +import com.sk89q.worldedit.function.operation.Operations; +import com.sk89q.worldedit.math.BlockVector3; +import com.sk89q.worldedit.regions.Region; +import net.minecraft.server.command.ServerCommandSource; +import org.jetbrains.annotations.Nullable; + +import static tools.redstone.redstonetools.features.arguments.serializers.DirectionSerializer.direction; +import static tools.redstone.redstonetools.features.arguments.serializers.IntegerSerializer.integer; +import static tools.redstone.redstonetools.utils.DirectionUtils.directionToBlock; +import static tools.redstone.redstonetools.utils.DirectionUtils.matchDirection; + +@AutoService(AbstractFeature.class) +@Feature(name = "RStack", description = "Stacks with custom distance", command = "/rstack", worldedit = true) +public class RStackFeature extends CommandFeature { + public static final Argument count = Argument + .ofType(integer()) + .withDefault(1); + + public static final Argument direction = Argument + .ofType(direction()) + .withDefault(DirectionArgument.ME); + + public static final Argument offset = Argument + .ofType(integer(1)) + .withDefault(2); + + @Override + protected Feedback execute(ServerCommandSource source) throws CommandSyntaxException { + var actor = FabricAdapter.adaptPlayer(source.getPlayer()); + + var localSession = WorldEdit.getInstance() + .getSessionManager() + .get(actor); + + final var selectionWorld = localSession.getSelectionWorld(); + assert selectionWorld != null; + + final Region selection; + try { + selection = localSession.getSelection(selectionWorld); + } catch (IncompleteRegionException ex) { + return Feedback.error("Please make a selection with WorldEdit first."); + } + + final Mask airFilter = new Mask() { + @Override + public boolean test(BlockVector3 vector) { + return !"minecraft:air".equals(selectionWorld.getBlock(vector).getBlockType().getId()); + } + + @Nullable + @Override + public Mask2D toMask2D() { + return null; + } + }; + + var playerFacing = actor.getLocation().getDirectionEnum(); + var stackDirection = matchDirection(direction.getValue(), playerFacing); + + var stackVector = directionToBlock(stackDirection); + + + try (var editSession = localSession.createEditSession(actor)) { + for (var i = 1; i <= count.getValue(); i++) { + var copy = new ForwardExtentCopy( + editSession, + selection, + editSession, + selection.getMinimumPoint().add(stackVector.multiply(i * offset.getValue())) + ); + copy.setSourceMask(airFilter); + Operations.complete(copy); + } + localSession.remember(editSession); + } catch (WorldEditException e) { + throw new RuntimeException(e); + } + + return Feedback.success("Stacked {} time(s).", count.getValue()); + } +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/commands/SignalStrengthBlockFeature.java b/oldSrc/main/java/tools/redstone/redstonetools/features/commands/SignalStrengthBlockFeature.java new file mode 100644 index 00000000..066bbcba --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/features/commands/SignalStrengthBlockFeature.java @@ -0,0 +1,53 @@ +package tools.redstone.redstonetools.features.commands; + +import com.google.auto.service.AutoService; +import com.mojang.brigadier.exceptions.CommandSyntaxException; +import com.mojang.brigadier.exceptions.SimpleCommandExceptionType; +import net.minecraft.item.ItemStack; +import net.minecraft.server.command.ServerCommandSource; +import net.minecraft.text.Text; +import tools.redstone.redstonetools.features.AbstractFeature; +import tools.redstone.redstonetools.features.Feature; +import tools.redstone.redstonetools.features.arguments.Argument; +import tools.redstone.redstonetools.features.arguments.serializers.SignalBlockSerializer; +import tools.redstone.redstonetools.features.feedback.Feedback; +import tools.redstone.redstonetools.utils.SignalBlock; + +import java.util.Random; + +import static tools.redstone.redstonetools.features.arguments.serializers.IntegerSerializer.integer; + +@AutoService(AbstractFeature.class) +@Feature(name = "Signal Strength Block", description = "Creates a block with the specified signal strength.", command = "ssb") +public class SignalStrengthBlockFeature extends CommandFeature { + + public static final Argument signalStrength = Argument + .ofType(integer(0)); + + public static final Argument block = Argument + .ofType(SignalBlockSerializer.signalBlock()) + .withDefault(SignalBlock.AUTO); + + @Override + protected Feedback execute(ServerCommandSource source) throws CommandSyntaxException { + try { + ItemStack itemStack = block.getValue().getItemStack(signalStrength.getValue()); + source.getPlayer().giveItemStack(itemStack); + } catch (IllegalArgumentException | IllegalStateException e) { + return Feedback.error(e.getMessage()); + } + + //funny + if(signalStrength.getValue() == 0) { + String[] funny = { + "Why would you want this??", "Wtf are you going to use this for?", "What for?", + "... Ok, if you're sure.", "I'm 99% sure you could just use any other block.", + "This seems unnecessary.", "Is that a typo?", "Do you just like the glint?", + "Wow, what a fancy but otherwise useless barrel.", "For decoration?"}; + return Feedback.success(funny[new Random().nextInt(funny.length)]); + } + + return Feedback.none(); + } + +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/commands/update/RegionUpdater.java b/oldSrc/main/java/tools/redstone/redstonetools/features/commands/update/RegionUpdater.java new file mode 100644 index 00000000..3f23d3d3 --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/features/commands/update/RegionUpdater.java @@ -0,0 +1,28 @@ +package tools.redstone.redstonetools.features.commands.update; + +import tools.redstone.redstonetools.features.feedback.Feedback; +import com.sk89q.worldedit.math.BlockVector3; +import net.minecraft.util.math.BlockPos; +import net.minecraft.world.World; + +public class RegionUpdater { + + + public static Feedback updateRegion(World world, BlockVector3 minPos, BlockVector3 maxPos) { + long blockCount = 0; + + for (int x = minPos.getX() - 1; x <= maxPos.getX() + 1; x++) { + for (int y = minPos.getY() - 1; y <= maxPos.getY() + 1; y++) { + for (int z = minPos.getZ() - 1; z <= maxPos.getZ() + 1; z++) { + BlockPos pos = new BlockPos(x, y, z); + + world.updateNeighbors(new BlockPos(x, y, z), world.getBlockState(pos).getBlock()); + blockCount++; + + } + } + } + return Feedback.success("Successfully forced block updates for {} block(s).", blockCount); + } + +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/commands/update/UpdateFeature.java b/oldSrc/main/java/tools/redstone/redstonetools/features/commands/update/UpdateFeature.java new file mode 100644 index 00000000..f7e1078e --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/features/commands/update/UpdateFeature.java @@ -0,0 +1,28 @@ +package tools.redstone.redstonetools.features.commands.update; + +import com.google.auto.service.AutoService; +import com.mojang.brigadier.exceptions.CommandSyntaxException; +import net.minecraft.server.command.ServerCommandSource; +import tools.redstone.redstonetools.features.AbstractFeature; +import tools.redstone.redstonetools.features.Feature; +import tools.redstone.redstonetools.features.commands.CommandFeature; +import tools.redstone.redstonetools.features.feedback.Feedback; +import tools.redstone.redstonetools.utils.WorldEditUtils; + +@AutoService(AbstractFeature.class) +@Feature(name = "Update", description = "Forces block updates in the selected area.", command = "/update") +public class UpdateFeature extends CommandFeature { + @Override + protected Feedback execute(ServerCommandSource source) throws CommandSyntaxException { + var selectionOrFeedback = WorldEditUtils.getSelection(source.getPlayer()); + if (selectionOrFeedback.right().isPresent()) { + return selectionOrFeedback.right().get(); + } + + assert selectionOrFeedback.left().isPresent(); + var selection = selectionOrFeedback.left().get(); + + + return RegionUpdater.updateRegion(source.getWorld(), selection.getMinimumPoint(), selection.getMaximumPoint()); + } +} \ No newline at end of file diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/feedback/AbstractFeedbackSender.java b/oldSrc/main/java/tools/redstone/redstonetools/features/feedback/AbstractFeedbackSender.java new file mode 100644 index 00000000..b61374b4 --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/features/feedback/AbstractFeedbackSender.java @@ -0,0 +1,7 @@ +package tools.redstone.redstonetools.features.feedback; + +import net.minecraft.server.command.ServerCommandSource; + +public abstract class AbstractFeedbackSender { + public abstract void sendFeedback(ServerCommandSource source, Feedback feedback); +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/feedback/Feedback.java b/oldSrc/main/java/tools/redstone/redstonetools/features/feedback/Feedback.java new file mode 100644 index 00000000..c3d6df18 --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/features/feedback/Feedback.java @@ -0,0 +1,178 @@ +package tools.redstone.redstonetools.features.feedback; + +import com.mojang.brigadier.context.CommandContext; +import net.minecraft.server.command.ServerCommandSource; +import net.minecraft.util.Formatting; +import tools.redstone.redstonetools.RedstoneToolsClient; + +import javax.annotation.Nullable; + +public abstract class Feedback { + private final @Nullable String message; + private final @Nullable Object[] values; + + protected Feedback(@Nullable String message, @Nullable Object... values) { + this.message = message; + this.values = values; + } + + private String formatMessage(String message) { + return String.format("%s[%sRST%s]%s ", Formatting.GRAY, Formatting.RED, Formatting.GRAY, Formatting.RESET) + message; + } + + public final String getMessage() { + if (message != null) { + String sentMessage = message; + for (Object value : values) { + sentMessage = sentMessage.replaceFirst("\\{\\}", Formatting.RED + value.toString() + getFormatting()); + } + + return formatMessage(sentMessage); + } else { + return formatMessage(getDefaultMessage()); + } + } + + /** Returns the status code. */ + public int send(ServerCommandSource source) { + RedstoneToolsClient.INJECTOR + .getInstance(FeedbackSender.class) + .sendFeedback(source, this); + + return getType().getCode(); + } + + /** Returns the status code. */ + public int send(CommandContext context) { + return send(context.getSource()); + } + + public abstract Formatting getFormatting(); + public abstract String getDefaultMessage(); + public abstract FeedbackType getType(); + + public static None none() { + return new None(); + } + + public static class None extends Feedback { + public None() { + super(null); + } + + @Override + public Formatting getFormatting() { + return Formatting.WHITE; + } + + @Override + public String getDefaultMessage() { + return ""; + } + + @Override + public FeedbackType getType() { + return FeedbackType.NONE; + } + } + + public static Success success(@Nullable String message, @Nullable Object... values) { + return new Success(message, values); + } + + public static class Success extends Feedback { + public Success(@Nullable String message, @Nullable Object... values) { + super(message, values); + } + + @Override + public Formatting getFormatting() { + return Formatting.WHITE; + } + + @Override + public String getDefaultMessage() { + return "Success"; + } + + @Override + public FeedbackType getType() { + return FeedbackType.SUCCESS; + } + } + + public static Warning warning(@Nullable String message, @Nullable Object... values) { + return new Warning(message, values); + } + + public static class Warning extends Feedback { + public Warning(@Nullable String message, @Nullable Object... values) { + super(message, values); + } + + @Override + public Formatting getFormatting() { + return Formatting.YELLOW; + } + + @Override + public String getDefaultMessage() { + return "Warning"; + } + + @Override + public FeedbackType getType() { + return FeedbackType.WARNING; + } + } + + public static Error error(@Nullable String message, @Nullable Object... values) { + return new Error(message, values); + } + + public static class Error extends Feedback { + public Error(@Nullable String message, @Nullable Object... values) { + super(message, values); + } + + @Override + public Formatting getFormatting() { + return Formatting.RED; + } + + @Override + public String getDefaultMessage() { + return "Error"; + } + + @Override + public FeedbackType getType() { + return FeedbackType.ERROR; + } + } + + public static InvalidUsage invalidUsage(@Nullable String message, @Nullable Object... values) { + return new InvalidUsage(message, values); + } + + public static class InvalidUsage extends Feedback { + public InvalidUsage(@Nullable String message, @Nullable Object... values) { + super(message, values); + } + + @Override + public Formatting getFormatting() { + return Formatting.RED; + } + + @Override + public String getDefaultMessage() { + return "Invalid usage"; + } + + @Override + public FeedbackType getType() { + return FeedbackType.ERROR; + } + } +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/feedback/FeedbackSender.java b/oldSrc/main/java/tools/redstone/redstonetools/features/feedback/FeedbackSender.java new file mode 100644 index 00000000..efd5a156 --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/features/feedback/FeedbackSender.java @@ -0,0 +1,19 @@ +package tools.redstone.redstonetools.features.feedback; + +import net.minecraft.server.command.ServerCommandSource; +import net.minecraft.text.LiteralText; + +import javax.inject.Singleton; + +@Singleton +public class FeedbackSender extends AbstractFeedbackSender { + @Override + public void sendFeedback(ServerCommandSource source, Feedback feedback) { + if (feedback.getType() == FeedbackType.NONE) { + return; + } + + source.sendFeedback(new LiteralText(feedback.getMessage()) + .formatted(feedback.getFormatting()), false); + } +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/feedback/FeedbackType.java b/oldSrc/main/java/tools/redstone/redstonetools/features/feedback/FeedbackType.java new file mode 100644 index 00000000..81f81e9b --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/features/feedback/FeedbackType.java @@ -0,0 +1,18 @@ +package tools.redstone.redstonetools.features.feedback; + +public enum FeedbackType { + SUCCESS(1), + NONE(0), + WARNING(0), + ERROR(-1); + + private final int code; + + FeedbackType(int code) { + this.code = code; + } + + public int getCode() { + return code; + } +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/toggleable/AirPlaceFeature.java b/oldSrc/main/java/tools/redstone/redstonetools/features/toggleable/AirPlaceFeature.java new file mode 100644 index 00000000..db0eba6a --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/features/toggleable/AirPlaceFeature.java @@ -0,0 +1,125 @@ +package tools.redstone.redstonetools.features.toggleable; + +import com.google.auto.service.AutoService; +import net.fabricmc.fabric.api.client.rendering.v1.WorldRenderEvents; +import net.minecraft.block.BlockState; +import net.minecraft.block.Blocks; +import net.minecraft.client.MinecraftClient; +import net.minecraft.client.network.ClientPlayerEntity; +import net.minecraft.client.render.Camera; +import net.minecraft.client.render.RenderLayer; +import net.minecraft.client.render.VertexConsumer; +import net.minecraft.entity.EquipmentSlot; +import net.minecraft.entity.player.PlayerEntity; +import net.minecraft.item.ItemStack; +import net.minecraft.item.Items; +import net.minecraft.util.hit.BlockHitResult; +import net.minecraft.util.hit.HitResult; +import net.minecraft.util.math.BlockPos; +import net.minecraft.util.math.Vec3d; +import tools.redstone.redstonetools.features.AbstractFeature; +import tools.redstone.redstonetools.features.Feature; +import tools.redstone.redstonetools.features.arguments.Argument; +import tools.redstone.redstonetools.features.arguments.serializers.BoolSerializer; +import tools.redstone.redstonetools.mixin.accessors.WorldRendererAccessor; +import tools.redstone.redstonetools.utils.ItemUtils; +import tools.redstone.redstonetools.utils.RaycastUtils; + +import static tools.redstone.redstonetools.features.arguments.serializers.FloatSerializer.floatArg; + +@AutoService(AbstractFeature.class) +@Feature(name = "Air Place", description = "Allows you to place blocks in the air.", command = "airplace") +public class AirPlaceFeature extends ToggleableFeature { + + public static boolean canAirPlace(PlayerEntity player) { + ItemStack itemStack = ItemUtils.getMainItem(player); + + // empty slot + if (itemStack == null || itemStack.getItem() == Items.AIR) + return false; + + // rocket boost for elytra + if (itemStack.getItem() == Items.FIREWORK_ROCKET && + player.getEquippedStack(EquipmentSlot.CHEST).getItem() == Items.ELYTRA && + player.isFallFlying()) + return false; + + return true; + } + + public static HitResult findAirPlacePosition(MinecraftClient client) { + if (client.player == null) + return null; + ClientPlayerEntity player = client.player; + + float reach = AirPlaceFeature.reach.getValue(); + return player.raycast(reach, 0, false); + } + + public static BlockHitResult findAirPlaceBlockHit(PlayerEntity playerEntity) { + var hit = RaycastUtils.rayCastFromEye(playerEntity, reach.getValue()); + return new BlockHitResult(hit.getPos(), hit.getSide(), hit.getBlockPos(), false); + } + + public static final Argument reach = Argument + .ofType(floatArg(3.0f)) + .withDefault(5.0f); + + public static final Argument showOutline = Argument + .ofType(BoolSerializer.bool()) + .withDefault(true); + + private static final BlockState FULL_BLOCK_STATE = Blocks.BEDROCK.getDefaultState(); + + { + // register ghost block renderer + WorldRenderEvents.BEFORE_BLOCK_OUTLINE.register((context, blockOutlineContext) -> { + if (!isEnabled()) + return true; + if (showOutline.getValue() != Boolean.TRUE) + return true; + + MinecraftClient client = MinecraftClient.getInstance(); + if (client.player == null || client.interactionManager == null) + return true; + if (blockOutlineContext.getType() != HitResult.Type.MISS) + return true; + + if (!canAirPlace(client.player)) + return true; + + HitResult hitResult = findAirPlacePosition(client); + if (hitResult == null) + return true; + BlockPos blockPos = new BlockPos(hitResult.getPos()); + + BlockState blockState = ItemUtils.getUseState(client.player, + ItemUtils.getMainItem(client.player), + reach.getValue()); + if (blockState == null) + return true; + + /* render block outline */ + Camera camera = client.gameRenderer.getCamera(); + Vec3d camPos = camera.getPos(); + + try { + VertexConsumer consumer = context.consumers().getBuffer(RenderLayer.getLines()); + + ((WorldRendererAccessor)context.worldRenderer()).invokeDrawBlockOutline( + context.matrixStack(), + consumer, + client.player, + camPos.x, camPos.y, camPos.z, + blockPos, + blockState + ); + } catch (Throwable t) { + throw new IllegalStateException(t); + } + + return true; + }); + } + +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/toggleable/AutoDustFeature.java b/oldSrc/main/java/tools/redstone/redstonetools/features/toggleable/AutoDustFeature.java new file mode 100644 index 00000000..9a9e1c7a --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/features/toggleable/AutoDustFeature.java @@ -0,0 +1,11 @@ +package tools.redstone.redstonetools.features.toggleable; + +import com.google.auto.service.AutoService; +import tools.redstone.redstonetools.features.AbstractFeature; +import tools.redstone.redstonetools.features.Feature; + +@AutoService(AbstractFeature.class) +@Feature(name = "Auto Dust", description = "Automatically places redstone on top of colored blocks.", command = "autodust") +public class AutoDustFeature extends ToggleableFeature { + +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/toggleable/BigDustFeature.java b/oldSrc/main/java/tools/redstone/redstonetools/features/toggleable/BigDustFeature.java new file mode 100644 index 00000000..6f6490c8 --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/features/toggleable/BigDustFeature.java @@ -0,0 +1,16 @@ +package tools.redstone.redstonetools.features.toggleable; + +import com.google.auto.service.AutoService; +import tools.redstone.redstonetools.features.AbstractFeature; +import tools.redstone.redstonetools.features.Feature; +import tools.redstone.redstonetools.features.arguments.Argument; +import tools.redstone.redstonetools.features.arguments.serializers.IntegerSerializer; + +@AutoService(AbstractFeature.class) +@Feature(name = "Big Dust", description = "Change the size of redstone's hitbox.", command = "bigdust") +public class BigDustFeature extends ToggleableFeature { + + public static final Argument heightInPixels = Argument.ofType(IntegerSerializer.integer(1, 16)) + .withDefault(1); + +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/toggleable/ToggleableFeature.java b/oldSrc/main/java/tools/redstone/redstonetools/features/toggleable/ToggleableFeature.java new file mode 100644 index 00000000..2ace5531 --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/features/toggleable/ToggleableFeature.java @@ -0,0 +1,257 @@ +package tools.redstone.redstonetools.features.toggleable; + +import net.fabricmc.fabric.api.client.event.lifecycle.v1.ClientTickEvents; +import net.fabricmc.fabric.api.client.keybinding.v1.KeyBindingHelper; +import net.minecraft.client.option.KeyBinding; +import net.minecraft.client.util.InputUtil; +import tools.redstone.redstonetools.features.AbstractFeature; +import tools.redstone.redstonetools.features.Feature; +import tools.redstone.redstonetools.features.feedback.Feedback; +import tools.redstone.redstonetools.features.feedback.FeedbackSender; +import tools.redstone.redstonetools.utils.ReflectionUtils; +import com.google.gson.Gson; +import com.google.gson.GsonBuilder; +import com.google.gson.JsonObject; +import com.mojang.brigadier.CommandDispatcher; +import com.mojang.brigadier.context.CommandContext; +import com.mojang.brigadier.exceptions.CommandSyntaxException; +import net.fabricmc.fabric.api.client.event.lifecycle.v1.ClientLifecycleEvents; +import net.minecraft.server.command.ServerCommandSource; +import tools.redstone.redstonetools.RedstoneToolsClient; +import tools.redstone.redstonetools.features.AbstractFeature; +import tools.redstone.redstonetools.features.arguments.Argument; +import tools.redstone.redstonetools.features.feedback.Feedback; +import tools.redstone.redstonetools.utils.ReflectionUtils; + +import java.io.BufferedReader; +import java.io.InputStreamReader; +import java.io.OutputStream; +import java.nio.charset.StandardCharsets; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.List; +import java.util.concurrent.Executor; +import java.util.concurrent.Executors; + +import java.util.ArrayList; +import java.util.List; + +import static tools.redstone.redstonetools.RedstoneToolsClient.INJECTOR; + +import static net.minecraft.server.command.CommandManager.argument; +import static net.minecraft.server.command.CommandManager.literal; + +public abstract class ToggleableFeature extends AbstractFeature { + + private static final List keyBindings = new ArrayList<>(); + + @Override + public void register() { + super.register(); + + // load user settings + // and register save hook + loadConfig(); + ClientLifecycleEvents.CLIENT_STOPPING.register(client -> { + saveConfig(); + }); + + var containsRequiredArguments = ReflectionUtils.getArguments(getClass()).stream() + .anyMatch(a -> !a.isOptional()); + if (containsRequiredArguments) { + return; + } + + var info = ReflectionUtils.getFeatureInfo(getClass()); + var keyBinding = KeyBindingHelper.registerKeyBinding(new KeyBinding( + info.name(), + InputUtil.Type.KEYSYM, + -1, + "Redstone Tools" + )); + + keyBindings.add(keyBinding); + + ClientTickEvents.END_CLIENT_TICK.register(client -> { + while (keyBinding.wasPressed()) { + assert client.player != null; + client.player.sendChatMessage("/" + info.command()); + } + }); + } + + private static final Executor IO_EXECUTOR = Executors.newSingleThreadExecutor(); + + private static final Gson GSON = new GsonBuilder() + .setPrettyPrinting() + .create(); + + private volatile boolean enabled; // volatile for thread safety + + private final List> arguments = ReflectionUtils.getArguments(getClass()); + + private final Path configFile = RedstoneToolsClient.CONFIG_DIR + .resolve("features").resolve(getID() + ".json"); + + @SuppressWarnings({ "rawtypes", "unchecked" }) + + @Override + protected void registerCommands(CommandDispatcher dispatcher, boolean dedicated) { + var baseCommand = literal(getCommand()) + .executes(this::toggle); + + // add option configurations + for (Argument argument : arguments) { + String name = argument.getName(); + baseCommand.then(literal(name) + .executes(context -> { + Object value = argument.getValue(); + return Feedback.success("Option {} of feature {} is set to: {}", name, getName(), argument.getType().serialize(value)).send(context); + }) + .then(argument("value", argument.getType()).executes(context -> { + Object value = context.getArgument("value", argument.getType().getTypeClass()); + + argument.setValue(value); + + if (!enabled) { + enable(context); + } + + IO_EXECUTOR.execute(this::saveConfig); + + return Feedback.success("Set {} to {} for feature {}", name, value, getName()).send(context); + })) + ); + } + + dispatcher.register(baseCommand); + } + + public boolean isEnabled() { + return enabled; + } + + public int toggle(CommandContext context) throws CommandSyntaxException { + return toggle(context.getSource()); + } + + public int toggle(ServerCommandSource source) throws CommandSyntaxException { + return !enabled ? enable(source) : disable(source); + } + + public void setEnabled(boolean status) { + if (status == enabled) + return; // no work to do + + if (status) { + enable(); + } else { + disable(); + } + } + + public void enable() { + enabled = true; + onEnable(); + } + + public int enable(ServerCommandSource source) throws CommandSyntaxException { + enable(); + Feedback.success("Enabled feature {}", getName()).send(source); + return 0; + } + + public int enable(CommandContext context) throws CommandSyntaxException { + return enable(context.getSource()); + } + + public void disable() { + enabled = false; + onDisable(); + } + + public int disable(ServerCommandSource source) throws CommandSyntaxException { + disable(); + Feedback.success("Disabled feature {}", getName()).send(source); + return 0; + } + + public int disable(CommandContext context) throws CommandSyntaxException { + return disable(context.getSource()); + } + + protected void onEnable() { } + protected void onDisable() { } + + // todo: right now the configuration methods are assuming every + // type is serialized to a string, this should be fixed in the future + // but for now it works because every type right now serializes to a string + // + it will probably be refactored soon + + /** Reloads the configuration from the disk. */ + @SuppressWarnings({ "rawtypes", "unchecked" }) + public void loadConfig() { + try { + boolean enabled = false; + if (Files.exists(configFile)) { + JsonObject object = GSON.fromJson(new BufferedReader( + new InputStreamReader(Files.newInputStream(configFile), StandardCharsets.UTF_8)), + JsonObject.class); + + enabled = Boolean.parseBoolean(object.get("enabled").getAsString()); + + // read options + for (Argument argument : arguments) { + if (!object.has(argument.getName())) + continue; + + String valueString = object.get(argument.getName()).getAsString(); + Object value = argument.getType().deserialize(valueString); + + argument.setValue(value); + } + } + + setEnabled(enabled); + + RedstoneToolsClient.LOGGER.info("Loaded configuration for feature " + getID() + " file(" + configFile + ")"); + } catch (Exception e) { + RedstoneToolsClient.LOGGER.error("Failed to load configuration for feature " + getID() + " file(" + configFile + ")"); + e.printStackTrace(); + } + } + + /** Saves the configuration to the disk. */ + @SuppressWarnings({ "rawtypes", "unchecked" }) + public void saveConfig() { + try { + if (!Files.exists(configFile)) { + if (!Files.exists(configFile.getParent())) + Files.createDirectories(configFile.getParent()); + Files.createFile(configFile); + } + + // serialize configuration + JsonObject jsonObject = new JsonObject(); + jsonObject.addProperty("enabled", Boolean.toString(enabled)); + for (Argument argument : arguments) { + Object value = argument.getValue(); + String valueSerialized = (String) argument.getType().serialize(value); + + jsonObject.addProperty(argument.getName(), valueSerialized); + } + + // write json document + String json = GSON.toJson(jsonObject); + OutputStream outputStream = Files.newOutputStream(configFile); + outputStream.write(json.getBytes(StandardCharsets.UTF_8)); + outputStream.close(); + + RedstoneToolsClient.LOGGER.info("Saved configuration for feature " + getID() + " file(" + configFile + ")"); + } catch (Exception e) { + RedstoneToolsClient.LOGGER.error("Failed to save configuration for feature " + getID() + " file(" + configFile + ")"); + e.printStackTrace(); + } + } + +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/macros/ClientPlayerEntityMixin.java b/oldSrc/main/java/tools/redstone/redstonetools/macros/ClientPlayerEntityMixin.java new file mode 100644 index 00000000..ddb2e4d7 --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/macros/ClientPlayerEntityMixin.java @@ -0,0 +1,9 @@ +package tools.redstone.redstonetools.macros; + +import net.minecraft.client.network.ClientPlayNetworkHandler; + +public interface ClientPlayerEntityMixin { + + void setNetworkHandler(ClientPlayNetworkHandler networkHandler); + +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/macros/KeyBindingMixin.java b/oldSrc/main/java/tools/redstone/redstonetools/macros/KeyBindingMixin.java new file mode 100644 index 00000000..3e0f1cda --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/macros/KeyBindingMixin.java @@ -0,0 +1,12 @@ +package tools.redstone.redstonetools.macros; + +import net.minecraft.client.option.KeyBinding; +import net.minecraft.client.util.InputUtil.Key; + +public interface KeyBindingMixin { + + void removeKeybinding(KeyBinding keyBinding); + + KeyBinding getBindingFromKey(Key key); + +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/macros/Macro.java b/oldSrc/main/java/tools/redstone/redstonetools/macros/Macro.java new file mode 100644 index 00000000..2e30e36e --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/macros/Macro.java @@ -0,0 +1,132 @@ +package tools.redstone.redstonetools.macros; + +import net.fabricmc.fabric.api.client.keybinding.KeyBindingRegistry; +import tools.redstone.redstonetools.macros.actions.Action; +import net.fabricmc.fabric.api.client.event.lifecycle.v1.ClientTickEvents; +import net.minecraft.client.MinecraftClient; +import net.minecraft.client.option.KeyBinding; +import net.minecraft.client.util.InputUtil; +import net.minecraft.client.util.InputUtil.Key; +import tools.redstone.redstonetools.utils.KeyBindingUtils; + +import java.util.ArrayList; +import java.util.List; + +public class Macro { + + public static Macro buildEmpty() { + return new Macro("",true,InputUtil.UNKNOWN_KEY,new ArrayList<>()); + } + + private KeyBinding keyBinding; + public String name; + private Key key; + public boolean enabled; + public List actions; + + private final Macro original; + + public Macro(String name, boolean enabled, Key key, List actions) { + this(name,enabled,key,actions,null); + keyBinding = new KeyBinding("macro." + System.nanoTime(),-1,"macros"); + registerKeyBinding(); + changeKeyBindingKeyCode(); + } + + public Macro(String name, boolean enabled, Key key, List actions, Macro original) { + this.name = name; + this.enabled = enabled; + this.key = key; + this.actions = actions; + this.original = original; + } + + public void registerKeyBinding() { + if (keyBinding == null) return; + + ClientTickEvents.END_CLIENT_TICK.register(client -> { + if (keyBinding == null || key == InputUtil.UNKNOWN_KEY) return; + + if (keyBinding.wasPressed()) { + run(); + } + }); + } + + public void run() { + if (!enabled) { + return; + } + + for (Action action : actions) { + action.run(); + } + } + + public void applyChangesToOriginal() { + assert isCopy(); + + original.name = name; + original.enabled = enabled; + original.setKey(key); + original.actions = new ArrayList<>(actions); + } + + public boolean isCopy(){ + return original != null; + } + + public boolean isCopyOf(Macro macro) { + return original == macro; + } + + public void setKey(Key key) { + this.key = key; + changeKeyBindingKeyCode(); + } + + public void changeKeyBindingKeyCode() { + + if (this.keyBinding != null) { + MinecraftClient.getInstance().options.setKeyCode(keyBinding,key); + KeyBinding.updateKeysByCode(); + } + + } + + public Key getKey(){ + return key; + } + + public Macro createCopy() { + return new Macro(name,enabled,key,new ArrayList<>(actions),this); + } + + public void unregisterKeyBinding(){ + KeyBindingUtils.removeKeyBinding(keyBinding); + } + + public boolean needsSaving() { + return !isCopy() || !original.equals(this); + } + + public boolean isEmpty() { + return name.isEmpty() && key == InputUtil.UNKNOWN_KEY && actions.isEmpty(); + } + + @Override + public boolean equals(Object obj) { + if (obj instanceof Macro macro) { + + if (actions.size() != macro.actions.size()) return false; + for (int i = 0; i < actions.size(); i++) { + if (!actions.get(i).equals(macro.actions.get(i))) return false; + } + + return macro.name.equals(name) && macro.key.equals(key) && macro.enabled == enabled; + } + + return super.equals(obj); + } + +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/macros/MacroManager.java b/oldSrc/main/java/tools/redstone/redstonetools/macros/MacroManager.java new file mode 100644 index 00000000..95b1f0cf --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/macros/MacroManager.java @@ -0,0 +1,192 @@ +package tools.redstone.redstonetools.macros; + +import net.minecraft.client.MinecraftClient; +import net.minecraft.client.util.InputUtil; +import tools.redstone.redstonetools.macros.actions.Action; +import tools.redstone.redstonetools.macros.actions.CommandAction; + +import javax.inject.Singleton; +import javax.json.Json; +import javax.json.JsonArray; +import javax.json.JsonObject; +import java.io.FileReader; +import java.io.FileWriter; +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.Path; +import java.util.ArrayList; +import java.util.List; + +@Singleton +public class MacroManager { + private final Path macrosFilePath; + private final List macros; + + public MacroManager() { + macrosFilePath = MinecraftClient.getInstance().runDirectory.toPath() + .resolve("config") + .resolve("redstonetools") + .resolve("macros.json"); + + + JsonArray macrosJson = null; + try { + Files.createDirectories(macrosFilePath.getParent()); + if (Files.exists(macrosFilePath)) { + var reader = Json.createReader(new FileReader(macrosFilePath.toFile())); + macrosJson = reader.readArray(); + reader.close(); + } + } catch (Exception e) { + e.printStackTrace(); + } + + if (macrosJson == null) { + macros = new ArrayList<>(); + macros.addAll(getDefaultMacros()); + } else { + macros = getMacrosFromJson(macrosJson); + } + } + + public List getMacros() { + return macros; + } + + public Macro getMacro(String name) { + for (Macro macro : macros) { + if (macro.name.equals(name)) { + return macro; + } + } + + return null; + } + + public void addMacro(Macro macro) { + macros.add(macro); + + saveChanges(); + } + + public void removeMacro(Macro macro) { + macros.remove(macro); + + saveChanges(); + } + + public void saveChanges() { + // Write %appdata%/.minecraft/config/redstonetools/macros.json + try { + Files.createDirectories(macrosFilePath.getParent()); + } catch (IOException e) { + e.printStackTrace(); + } + + var macrosJson = Json.createArrayBuilder(); + for (Macro macro : macros) { + macrosJson.add(getMacroJson(macro)); + } + + try (var writer = Json.createWriter(new FileWriter(macrosFilePath.toFile()))) { + writer.writeArray(macrosJson.build()); + } catch (Exception e) { + e.printStackTrace(); + } + } + + private JsonObject getMacroJson(Macro macro) { + var actionsJson = Json.createArrayBuilder(); + for (Action action : macro.actions) { + actionsJson.add(getActionJson(action)); + } + + return Json.createObjectBuilder() + .add("name", macro.name) + .add("enabled", macro.enabled) + .add("key", macro.getKey().getTranslationKey()) + .add("actions", actionsJson) + .build(); + } + + private JsonObject getActionJson(Action action) { + if (action instanceof CommandAction commandAction) { + return Json.createObjectBuilder() + .add("type", "command") + .add("command", commandAction.command) + .build(); + } + + throw new RuntimeException("Unknown action type: " + action.getClass().getName()); + } + + private List getDefaultMacros() { + return List.of( + createCommandMacro("redstoner", new String[] { + "/gamerule doTileDrops false", + "/gamerule doTraderSpawning false", + "/gamerule doWeatherCycle false", + "/gamerule doDaylightCycle false", + "/gamerule doMobSpawning false", + "/gamerule doContainerDrops false", + "/time set noon", + "/weather clear" + }) + ); + } + + private Macro createCommandMacro(String name, String[] commands) { + var actions = new Action[commands.length]; + for (int i = 0; i < commands.length; i++) { + actions[i] = new CommandAction(commands[i]); + } + + return new Macro(name, true, InputUtil.UNKNOWN_KEY, List.of(actions)); + } + + private List getMacrosFromJson(JsonArray macrosJson) { + List macros = new ArrayList<>(); + + for (int i = 0; i < macrosJson.size(); i++) { + macros.add(getMacroFromJson(macrosJson.getJsonObject(i))); + } + + return macros; + } + + private Macro getMacroFromJson(JsonObject macroJson) { + var name = macroJson.getString("name"); + var enabled = macroJson.getBoolean("enabled"); + var key = macroJson.getString("key"); + var actions = getActionsFromJson(macroJson.getJsonArray("actions")); + + return new Macro(name, enabled, InputUtil.fromTranslationKey(key), actions); + } + + private List getActionsFromJson(JsonArray actionsJson) { + List actions = new ArrayList<>(); + + for (int i = 0; i < actionsJson.size(); i++) { + actions.add(getActionFromJson(actionsJson.getJsonObject(i))); + } + + return actions; + } + + private Action getActionFromJson(JsonObject actionJson) { + var type = actionJson.getString("type"); + + if ("command".equals(type)) { + return new CommandAction(actionJson.getString("command")); + } + + throw new RuntimeException("Unknown action type: " + type); + } + + public void updateMacroKeys() { + for (Macro macro : macros) { + macro.changeKeyBindingKeyCode(); + } + } + +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/macros/actions/Action.java b/oldSrc/main/java/tools/redstone/redstonetools/macros/actions/Action.java new file mode 100644 index 00000000..5cca93f1 --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/macros/actions/Action.java @@ -0,0 +1,5 @@ +package tools.redstone.redstonetools.macros.actions; + +public abstract class Action { + public abstract void run(); +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/macros/actions/CommandAction.java b/oldSrc/main/java/tools/redstone/redstonetools/macros/actions/CommandAction.java new file mode 100644 index 00000000..6c680e74 --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/macros/actions/CommandAction.java @@ -0,0 +1,29 @@ +package tools.redstone.redstonetools.macros.actions; + +import net.minecraft.client.MinecraftClient; + +public class CommandAction extends Action { + public String command; + + public CommandAction(String command) { + this.command = command; + } + + @Override + public void run() { + var player = MinecraftClient.getInstance().player; + assert player != null; + + player.sendChatMessage(command.startsWith("/") ? command : "/" + command); + } + + @Override + public boolean equals(Object obj) { + if (obj instanceof CommandAction commandAction) { + return command.equals(commandAction.command); + } + + return super.equals(obj); + } + +} diff --git a/src/main/java/tools/redstone/redstonetools/macros/gui/MaroCommandSuggestor.java b/oldSrc/main/java/tools/redstone/redstonetools/macros/gui/MaroCommandSuggestor.java similarity index 100% rename from src/main/java/tools/redstone/redstonetools/macros/gui/MaroCommandSuggestor.java rename to oldSrc/main/java/tools/redstone/redstonetools/macros/gui/MaroCommandSuggestor.java diff --git a/oldSrc/main/java/tools/redstone/redstonetools/macros/gui/screen/CommandEditScreen.java b/oldSrc/main/java/tools/redstone/redstonetools/macros/gui/screen/CommandEditScreen.java new file mode 100644 index 00000000..4e64fd5f --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/macros/gui/screen/CommandEditScreen.java @@ -0,0 +1,108 @@ +package tools.redstone.redstonetools.macros.gui.screen; + +import tools.redstone.redstonetools.macros.gui.MaroCommandSuggestor; +import net.minecraft.client.MinecraftClient; +import net.minecraft.client.gui.screen.Screen; +import net.minecraft.client.gui.screen.option.GameOptionsScreen; +import net.minecraft.client.gui.widget.TextFieldWidget; +import net.minecraft.client.option.GameOptions; +import net.minecraft.client.util.InputUtil; +import net.minecraft.client.util.math.MatrixStack; +import net.minecraft.text.Text; + + +public class CommandEditScreen extends GameOptionsScreen { + + private final TextFieldWidget commandField; + private final MaroCommandSuggestor commandMaroCommandSuggestor; + private boolean changed = false; + + public CommandEditScreen(Screen parent, GameOptions gameOptions, TextFieldWidget commandField) { + super(parent, gameOptions, Text.of("")); + this.commandField = commandField; + client = MinecraftClient.getInstance(); + this.commandMaroCommandSuggestor = new MaroCommandSuggestor(client, parent, commandField,client.textRenderer,true,false, commandField.y -20,5,-805306368); + + commandField.setChangedListener((s) -> changed = true); + commandMaroCommandSuggestor.setWindowActive(true); + commandMaroCommandSuggestor.refresh(); + } + + @Override + public void render(MatrixStack matrices, int mouseX, int mouseY, float delta) { + parent.render(matrices, mouseX, mouseY, delta); + + this.fillGradient(matrices, 0, 0, this.width, this.height, -1072689136, -804253680); + + commandField.render(matrices, mouseX, mouseY, delta); + + commandMaroCommandSuggestor.render(matrices, mouseX, mouseY); + if (changed) { + commandMaroCommandSuggestor.refresh(); + changed = false; + } + + super.render(matrices, mouseX, mouseY, delta); + + } + + @Override + public void tick() { + super.tick(); + commandField.tick(); + } + + @Override + public void resize(MinecraftClient client, int width, int height) { + parent.resize(client,width,height); + } + + @Override + public void close() { + super.close(); + commandField.setTextFieldFocused(false); + commandField.setChangedListener(null); + commandMaroCommandSuggestor.setWindowActive(false); + commandMaroCommandSuggestor.refresh(); + commandMaroCommandSuggestor.close(); + } + + @Override + public boolean mouseClicked(double mouseX, double mouseY, int button) { + if (!commandField.mouseClicked(mouseX, mouseY, button)) { + if (!commandMaroCommandSuggestor.mouseClicked(mouseX, mouseY, button)) { + close(); + } else { + commandField.setTextFieldFocused(true); + } + return false; + } + return super.mouseClicked(mouseX, mouseY, button); + } + + @Override + public boolean mouseScrolled(double mouseX, double mouseY, double amount) { + return commandMaroCommandSuggestor.mouseScrolled(amount); + } + + @Override + public boolean charTyped(char chr, int modifiers) { + return commandField.charTyped(chr,modifiers); + } + + @Override + public boolean keyPressed(int keyCode, int scanCode, int modifiers) { + if (keyCode == InputUtil.GLFW_KEY_ESCAPE || keyCode == InputUtil.GLFW_KEY_ENTER || keyCode == InputUtil.GLFW_KEY_KP_ENTER) { + close(); + return true; + } + commandMaroCommandSuggestor.keyPressed(keyCode, scanCode, modifiers); + + return commandField.keyPressed(keyCode, scanCode, modifiers); + } + + @Override + public boolean keyReleased(int keyCode, int scanCode, int modifiers) { + return commandField.keyReleased(keyCode, scanCode, modifiers); + } +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/macros/gui/screen/MacroEditScreen.java b/oldSrc/main/java/tools/redstone/redstonetools/macros/gui/screen/MacroEditScreen.java new file mode 100644 index 00000000..8ad466c9 --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/macros/gui/screen/MacroEditScreen.java @@ -0,0 +1,259 @@ +package tools.redstone.redstonetools.macros.gui.screen; + +import net.minecraft.client.gui.screen.ConfirmScreen; +import net.minecraft.client.gui.widget.ClickableWidget; +import net.minecraft.util.math.MathHelper; +import tools.redstone.redstonetools.macros.Macro; +import tools.redstone.redstonetools.macros.MacroManager; +import tools.redstone.redstonetools.macros.actions.Action; +import tools.redstone.redstonetools.macros.actions.CommandAction; +import tools.redstone.redstonetools.macros.gui.widget.commandlist.CommandEntry; +import tools.redstone.redstonetools.macros.gui.widget.commandlist.CommandListWidget; +import tools.redstone.redstonetools.macros.gui.widget.macrolist.MacroListWidget; +import net.minecraft.client.MinecraftClient; +import net.minecraft.client.gui.screen.Screen; +import net.minecraft.client.gui.screen.ScreenTexts; +import net.minecraft.client.gui.screen.option.GameOptionsScreen; +import net.minecraft.client.gui.widget.ButtonWidget; +import net.minecraft.client.gui.widget.TextFieldWidget; +import net.minecraft.client.option.GameOptions; +import net.minecraft.client.util.InputUtil; +import net.minecraft.client.util.InputUtil.Key; +import net.minecraft.client.util.InputUtil.Type; +import net.minecraft.client.util.math.MatrixStack; +import net.minecraft.text.LiteralText; +import net.minecraft.text.Text; +import net.minecraft.util.Formatting; +import tools.redstone.redstonetools.utils.KeyBindingUtils; + +import java.util.List; + +import static tools.redstone.redstonetools.RedstoneToolsClient.INJECTOR; + + +public class MacroEditScreen extends GameOptionsScreen { + private final MacroListWidget macroListWidget; + private final Macro macro; + + private CommandListWidget commandList; + private TextFieldWidget nameField; + private ButtonWidget doneButton; + private ButtonWidget keyBindButton; + + private boolean overlapped = false; + private boolean detectingKeycodeKey = false; + + public MacroEditScreen(Screen parent, GameOptions gameOptions, Text title, MacroListWidget macroListWidget) { + super(parent, gameOptions, title); + this.macroListWidget = macroListWidget; + this.macro = Macro.buildEmpty(); + } + + public MacroEditScreen(Screen parent, GameOptions gameOptions, Text title, MacroListWidget macroListWidget, Macro macro) { + super(parent, gameOptions, title); + this.macroListWidget = macroListWidget; + this.macro = macro.createCopy(); + } + + + @Override + public void init() { + super.init(); + overlapped = false; + nameField = new TextFieldWidget(this.textRenderer, this.width / 2 - 100, 22, 200, 20, Text.of("")); + nameField.setText(macro.name.trim()); + + doneButton = this.addDrawableChild(new ButtonWidget(this.width / 2 - 100, this.height / 4 + 144 + 5, 98, 20, Text.of("Done"), (button) -> { + String name = nameField.getText().trim(); + if (name.isEmpty()) return; + + updateMacroActions(); + + if (!macro.isCopy()) macroListWidget.addMacro(macro); + else macro.applyChangesToOriginal(); + + INJECTOR.getInstance(MacroManager.class).saveChanges(); + + client.setScreen(parent); + })); + doneButton.active = canClickDone(); + + nameField.setChangedListener(s -> { + macro.name = s.trim(); + doneButton.active = canClickDone(); + }); + addSelectableChild(nameField); + + + this.addDrawableChild(new ButtonWidget(this.width / 2 + 2, this.height / 4 + 144 + 5, 98, 20, ScreenTexts.CANCEL, (button) -> { + close(); + })); + + Key keyCode = macro.getKey(); + Text text = keyCode.getLocalizedText(); + if (keyCode == InputUtil.UNKNOWN_KEY) text = Text.of(""); + if ( KeyBindingUtils.isKeyAlreadyBound(keyCode) ) { text = new LiteralText(text.getString()).formatted(Formatting.RED); } + + keyBindButton = new ButtonWidget(this.width / 2 + 26, 55, 75, 20, text, (button) -> { + detectingKeycodeKey = true; + keyBindButton.setMessage((new LiteralText("> ")).append(keyBindButton.getMessage().shallowCopy().formatted(Formatting.YELLOW)).append(" <").formatted(Formatting.YELLOW)); + }); + if (detectingKeycodeKey) keyBindButton.onPress(); + + this.addDrawableChild(keyBindButton); + + int widgetWidth = 339; + List entries = null; + double scrollAmount = 0; + if (commandList != null) { + entries = commandList.children(); + scrollAmount = commandList.getScrollAmount(); + } + + commandList = new CommandListWidget(client, this, widgetWidth, height, 85, this.height / 4 + 144 + 5 - 10, 24); + commandList.setLeftPos(width / 2 - widgetWidth / 2); + + + if (entries != null) { + commandList.children().clear(); + for (CommandEntry entry : entries) { + entry.setOwner(commandList); + commandList.children().add(entry); + } + } else { + for (Action action : macro.actions) { + if (action instanceof CommandAction commandAction) { + commandList.addCommand(commandAction.command); + } + } + } + commandList.setScrollAmount(scrollAmount); + + this.addSelectableChild(commandList); + } + + private boolean canClickDone() { + return !nameField.getText().trim().isEmpty() && macroListWidget.canAdd(macro); + } + + @Override + public void render(MatrixStack matrices, int mouseX, int mouseY, float delta) { + if (overlapped) { + mouseX = -1; + mouseY = -1; + } + + this.renderBackgroundTexture(0); + commandList.render(matrices, mouseX, mouseY, delta); + super.render(matrices, mouseX, mouseY, delta); + + drawCenteredText(matrices, this.textRenderer, this.title, this.width / 2, 8, 16777215); + + drawCenteredText(matrices, this.textRenderer, "Key Bind", width / 2 - (99 - textRenderer.getWidth("Key Bind") / 2), 55 + textRenderer.fontHeight / 2, 16777215); + nameField.render(matrices, mouseX, mouseY, delta); + + if (nameField.getText().isEmpty() && !nameField.isFocused()) { + nameField.setSuggestion("Name"); + } else { + nameField.setSuggestion(""); + } + } + + @Override + public void tick() { + nameField.tick(); + commandList.tick(); + + super.tick(); + } + + @Override + public void resize(MinecraftClient client, int width, int height) { + super.resize(client, width, height); + if (overlapped) client.setScreen(new CommandEditScreen(this,gameOptions,commandList.getFocused().command)); + } + + + @Override + public void close(){ + if (!macro.isCopy() && macro.isEmpty()) { + super.close(); + return; + } + + updateMacroActions(); + if (macro.needsSaving()) { + client.setScreen(new ConfirmScreen(accept -> { + if (accept) client.setScreen(parent); + else client.setScreen(this); + }, Text.of("Unsaved changes"), Text.of("Are you sure you want to discard changes?"))); + } else { + super.close(); + } + } + + private void updateMacroActions() { + macro.actions.clear(); + + for (String command : commandList.getCommandList()) { + macro.actions.add(new CommandAction(command)); + } + } + + public void editCommandField(TextFieldWidget commandField) { + client.setScreen(new CommandEditScreen(this,gameOptions, commandField)); + overlapped = true; + } + + @Override + public boolean keyPressed(int keyCode, int scanCode, int modifiers) { + Key key = InputUtil.fromKeyCode(keyCode, scanCode); + if (keyCode == InputUtil.GLFW_KEY_ESCAPE) key = InputUtil.UNKNOWN_KEY; + + if (updateKeybinding(key)) return false; + if (commandList.keyPressed(keyCode, scanCode, modifiers)) return false; + if (keyCode == InputUtil.GLFW_KEY_TAB || keyCode == InputUtil.GLFW_KEY_SPACE) return false; + + return super.keyPressed(keyCode, scanCode, modifiers); + } + + @Override + public boolean keyReleased(int keyCode, int scanCode, int modifiers) { + if (commandList.keyReleased(keyCode, scanCode, modifiers)) return false; + + return super.keyReleased(keyCode, scanCode, modifiers); + } + + @Override + public boolean charTyped(char chr, int modifiers) { + if (commandList.charTyped(chr, modifiers)) return false; + + return super.charTyped(chr, modifiers); + } + + @Override + public boolean mouseClicked(double mouseX, double mouseY, int button) { + if (!commandList.isMouseOver(mouseX, mouseY)) commandList.mouseClicked(mouseX, mouseY, button); + if (updateKeybinding(Type.MOUSE.createFromCode(button))) return false; + + + return super.mouseClicked(mouseX, mouseY, button); + } + + private boolean updateKeybinding(Key key) { + if (detectingKeycodeKey) { + detectingKeycodeKey = false; + Text text = key.getLocalizedText(); + if (key == InputUtil.UNKNOWN_KEY) text = Text.of(""); + if ( KeyBindingUtils.isKeyAlreadyBound(key) ) { text = new LiteralText(text.getString()).formatted(Formatting.RED); } + + keyBindButton.setMessage(text); + macro.setKey(key); + return true; + } + + return false; + } + + +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/macros/gui/screen/MacroSelectScreen.java b/oldSrc/main/java/tools/redstone/redstonetools/macros/gui/screen/MacroSelectScreen.java new file mode 100644 index 00000000..cab88a08 --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/macros/gui/screen/MacroSelectScreen.java @@ -0,0 +1,52 @@ +package tools.redstone.redstonetools.macros.gui.screen; + +import tools.redstone.redstonetools.macros.gui.widget.macrolist.MacroEntry; +import tools.redstone.redstonetools.macros.gui.widget.macrolist.MacroListWidget; +import net.minecraft.client.gui.screen.Screen; +import net.minecraft.client.gui.screen.ScreenTexts; +import net.minecraft.client.gui.screen.option.GameOptionsScreen; +import net.minecraft.client.gui.widget.ButtonWidget; +import net.minecraft.client.option.GameOptions; +import net.minecraft.client.util.math.MatrixStack; +import net.minecraft.text.Text; + +public class MacroSelectScreen extends GameOptionsScreen { + + + private MacroListWidget macroList; + + public MacroSelectScreen(Screen parent, GameOptions gameOptions, Text title) { + super(parent, gameOptions, title); + } + + @Override + public void init() { + super.init(); + + this.macroList = new MacroListWidget(this,client); + this.addSelectableChild(this.macroList); + + this.addDrawableChild(new ButtonWidget(this.width / 2 +1, this.height - 29, 150, 20, Text.of("Create New..."), (button) -> { + this.client.setScreen(new MacroEditScreen(this,gameOptions,Text.of("New Macro"), macroList)); + })); + + this.addDrawableChild(new ButtonWidget(this.width / 2 - 151, this.height - 29, 150, 20, ScreenTexts.DONE, (button) -> { + this.client.setScreen(this.parent); + })); + } + + @Override + public void render(MatrixStack matrices, int mouseX, int mouseY, float delta) { + this.renderBackgroundTexture(0); + macroList.render(matrices, mouseX, mouseY, delta); + + drawCenteredText(matrices, this.textRenderer, this.title, this.width / 2, 8, 16777215); + super.render(matrices, mouseX, mouseY, delta); + + } + + public void openEditScreen(MacroEntry entry) { + client.setScreen(new MacroEditScreen(this,gameOptions,Text.of("Edit Macro"), macroList, entry.macro)); + } + +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/macros/gui/widget/IconButtonWidget.java b/oldSrc/main/java/tools/redstone/redstonetools/macros/gui/widget/IconButtonWidget.java new file mode 100644 index 00000000..e6e08235 --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/macros/gui/widget/IconButtonWidget.java @@ -0,0 +1,35 @@ +package tools.redstone.redstonetools.macros.gui.widget; + +import com.mojang.blaze3d.platform.GlStateManager; +import com.mojang.blaze3d.systems.RenderSystem; +import net.minecraft.client.gui.widget.ButtonWidget; +import net.minecraft.client.util.math.MatrixStack; +import net.minecraft.text.Text; +import net.minecraft.util.Identifier; + +public class IconButtonWidget extends ButtonWidget { + + public static Identifier CROSS_ICON = new Identifier("redstonetools","gui/cross.png"); + public static Identifier PENCIL_ICON = new Identifier("redstonetools","gui/pencil.png"); + + private final Identifier texture; + public IconButtonWidget(Identifier texture ,int x, int y, int width, int height, Text message, PressAction onPress) { + super(x, y, width, height, message, onPress); + this.texture = texture; + } + + public void renderButton(MatrixStack matrices, int mouseX, int mouseY, float delta) { + super.renderButton(matrices, mouseX, mouseY, delta); + + + RenderSystem.setShaderTexture(0, texture); + RenderSystem.enableDepthTest(); + + RenderSystem.setShaderColor(1.0F, 1.0F, 1.0F, this.alpha); + RenderSystem.enableBlend(); + RenderSystem.defaultBlendFunc(); + RenderSystem.blendFunc(GlStateManager.SrcFactor.SRC_ALPHA, GlStateManager.DstFactor.ONE_MINUS_SRC_ALPHA); + drawTexture(matrices, this.x, this.y, 0,0, 20, this.height, 20, 20); + } + +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/macros/gui/widget/commandlist/CommandEntry.java b/oldSrc/main/java/tools/redstone/redstonetools/macros/gui/widget/commandlist/CommandEntry.java new file mode 100644 index 00000000..afb75e28 --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/macros/gui/widget/commandlist/CommandEntry.java @@ -0,0 +1,112 @@ +package tools.redstone.redstonetools.macros.gui.widget.commandlist; + +import tools.redstone.redstonetools.macros.gui.MaroCommandSuggestor; +import tools.redstone.redstonetools.macros.gui.widget.IconButtonWidget; +import net.minecraft.client.MinecraftClient; +import net.minecraft.client.gui.widget.ButtonWidget; +import net.minecraft.client.gui.widget.EntryListWidget; +import net.minecraft.client.gui.widget.TextFieldWidget; +import net.minecraft.client.util.math.MatrixStack; +import net.minecraft.text.Text; + +public class CommandEntry extends EntryListWidget.Entry { + + + protected CommandListWidget owner; + + public final TextFieldWidget command; + protected final ButtonWidget deleteButton; + + + public CommandEntry(MinecraftClient client, CommandListWidget owner, String text) { + this.owner = owner; + + command = new TextFieldWidget(client.textRenderer, 0, 0, 300, 20, Text.of("")); + command.setMaxLength(255); + command.setText(text); + + deleteButton = new IconButtonWidget(IconButtonWidget.CROSS_ICON,0, 0, 20, 20, Text.of(""), (button) -> { + this.owner.removeCommand(this); + }); + + MaroCommandSuggestor commandMaroCommandSuggestor = new MaroCommandSuggestor(client, owner.getParent(), command,client.textRenderer,true,false, 0,0,0); + commandMaroCommandSuggestor.setWindowActive(false); + commandMaroCommandSuggestor.refresh(); + commandMaroCommandSuggestor.close(); + } + + + @Override + public void render(MatrixStack matrices, int index, int y, int x, int entryWidth, int entryHeight, int mouseX, int mouseY, boolean hovered, float tickDelta) { + command.x = owner.getParent().width/2-owner.getWidth()/2+5; + command.y = y; + command.render(matrices,mouseX,mouseY,tickDelta); + + + deleteButton.x = command.x + command.getWidth()+5; + deleteButton.y = y; + deleteButton.render(matrices,mouseX,mouseY,tickDelta); + + if (edit) { + edit = false; + owner.getParent().editCommandField(command); + } + } + + public void tick() { + command.tick(); + } + private boolean edit = false; + + public void setFocused(boolean focused){ + command.setTextFieldFocused(focused); + if (focused){ + owner.centerScrollOn(this); + edit = true; + } + owner.focusOn(this); + } + + protected String getText() { + return command.getText(); + } + + public void setOwner(CommandListWidget owner) { + this.owner = owner; + } + + @Override + public boolean mouseClicked(double mouseX, double mouseY, int button) { + if (command.mouseClicked(mouseX,mouseY,button)) { + owner.centerScrollOn(this); + edit = true; + return true; + } + deleteButton.mouseClicked(mouseX,mouseY,button); + + return super.mouseClicked(mouseX, mouseY, button); + } + + @Override + public boolean charTyped(char chr, int modifiers) { + if (command.isFocused()) return command.charTyped(chr,modifiers); + + return super.charTyped(chr, modifiers); + } + + @Override + public boolean keyPressed(int keyCode, int scanCode, int modifiers) { + if (command.isFocused()) { + return command.keyPressed(keyCode, scanCode, modifiers); + } + + return super.keyPressed(keyCode, scanCode, modifiers); + } + + @Override + public boolean keyReleased(int keyCode, int scanCode, int modifiers) { + if (command.isFocused()) return command.keyReleased(keyCode, scanCode, modifiers); + + return super.keyReleased(keyCode, scanCode, modifiers); + } +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/macros/gui/widget/commandlist/CommandEntryPlaceHolder.java b/oldSrc/main/java/tools/redstone/redstonetools/macros/gui/widget/commandlist/CommandEntryPlaceHolder.java new file mode 100644 index 00000000..ac8103de --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/macros/gui/widget/commandlist/CommandEntryPlaceHolder.java @@ -0,0 +1,23 @@ +package tools.redstone.redstonetools.macros.gui.widget.commandlist; + +import net.minecraft.client.MinecraftClient; +import net.minecraft.client.util.math.MatrixStack; + +public class CommandEntryPlaceHolder extends CommandEntry{ + public CommandEntryPlaceHolder(MinecraftClient client, CommandListWidget owner, String text) { + super(client, owner, text); + super.deleteButton.visible = false; + } + + @Override + public void render(MatrixStack matrices, int index, int y, int x, int entryWidth, int entryHeight, int mouseX, int mouseY, boolean hovered, float tickDelta) { + command.setSuggestion("Add new command"); + if (!super.command.getText().isEmpty()) { + super.owner.addCommandFromPlaceHolder(command.getText(),this); + command.setText(""); + } + + super.render(matrices, index, y, x, entryWidth, entryHeight, mouseX, mouseY, hovered, tickDelta); + } + +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/macros/gui/widget/commandlist/CommandListWidget.java b/oldSrc/main/java/tools/redstone/redstonetools/macros/gui/widget/commandlist/CommandListWidget.java new file mode 100644 index 00000000..a62653b3 --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/macros/gui/widget/commandlist/CommandListWidget.java @@ -0,0 +1,127 @@ +package tools.redstone.redstonetools.macros.gui.widget.commandlist; + +import tools.redstone.redstonetools.macros.gui.screen.MacroEditScreen; +import net.minecraft.client.MinecraftClient; +import net.minecraft.client.gui.screen.narration.NarrationMessageBuilder; +import net.minecraft.client.gui.widget.EntryListWidget; + +import java.util.ArrayList; +import java.util.List; + +public class CommandListWidget extends EntryListWidget { + + private final MacroEditScreen parent; + + public CommandListWidget(MinecraftClient client, MacroEditScreen parent, int width, int height, int top, int bottom, int itemHeight) { + super(client, width, height, top, bottom, itemHeight); + this.parent = parent; + addEntry(new CommandEntryPlaceHolder(client,this,"")); + } + + public void tick() { + for (CommandEntry entry : children()) { + entry.tick(); + } + } + + + + public CommandEntry addCommand(String command) { + CommandEntry entry = new CommandEntry(client,this,command); + List entries = children(); + + entries.add(entries.size()-1,entry); + + return entry; + } + + protected void addCommandFromPlaceHolder(String command,CommandEntryPlaceHolder placeHolder) { + CommandEntry entry = addCommand(command); + placeHolder.setFocused(false); + + entry.command.x = placeHolder.command.x; + entry.command.y = placeHolder.command.y; + entry.setFocused(true); + } + + public void centerScrollOn(CommandEntry entry) { + super.centerScrollOn(entry); + } + + + + protected void removeCommand(CommandEntry command) { + removeEntry(command); + setScrollAmount(getScrollAmount()); + } + + protected int getScrollbarPositionX() { + return parent.width/2+this.width/2-4; + } + + public List getCommandList() { + List list = new ArrayList<>(); + + for (int i = 0; i < children().size(); i++){ + CommandEntry command = getEntry(i); + if (command instanceof CommandEntryPlaceHolder) continue; + + list.add(command.getText()); + } + + return list; + } + + @Override + public boolean charTyped(char chr, int modifiers) { + for (CommandEntry entry : children()) { + entry.charTyped(chr,modifiers); + } + + return super.charTyped(chr, modifiers); + } + + @Override + public boolean keyPressed(int keyCode, int scanCode, int modifiers) { + for (CommandEntry entry : children()) { + entry.keyPressed(keyCode, scanCode, modifiers); + } + + return super.keyPressed(keyCode, scanCode, modifiers); + } + + @Override + public boolean keyReleased(int keyCode, int scanCode, int modifiers) { + for (CommandEntry entry : children()) { + entry.keyReleased(keyCode, scanCode, modifiers); + } + + return super.keyReleased(keyCode, scanCode, modifiers); + } + + @Override + public boolean mouseClicked(double mouseX, double mouseY, int button) { + CommandEntry clickedEntry = getEntryAtPosition(mouseX,mouseY); + for (CommandEntry entry : children()) { + if (entry != clickedEntry) entry.setFocused(false); + } + + return super.mouseClicked(mouseX, mouseY, button); + } + + protected MacroEditScreen getParent() { + return parent; + } + + @Override + public int getRowWidth() { + return width; + } + + public int getWidth() { + return this.width; + } + + @Override + public void appendNarrations(NarrationMessageBuilder builder) {} +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/macros/gui/widget/macrolist/MacroEntry.java b/oldSrc/main/java/tools/redstone/redstonetools/macros/gui/widget/macrolist/MacroEntry.java new file mode 100644 index 00000000..443de635 --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/macros/gui/widget/macrolist/MacroEntry.java @@ -0,0 +1,117 @@ +package tools.redstone.redstonetools.macros.gui.widget.macrolist; + +import tools.redstone.redstonetools.macros.Macro; +import tools.redstone.redstonetools.macros.gui.widget.IconButtonWidget; +import net.minecraft.client.gui.screen.ConfirmScreen; +import net.minecraft.client.gui.widget.*; +import net.minecraft.client.sound.PositionedSoundInstance; +import net.minecraft.client.util.math.MatrixStack; +import net.minecraft.sound.SoundEvents; +import net.minecraft.text.Text; +import net.minecraft.text.TranslatableText; + +public class MacroEntry extends AlwaysSelectedEntryListWidget.Entry{ + + private final MacroListWidget owner; + + private final CheckboxWidget buttonWidget; + private final ButtonWidget deleteButton; + private final ButtonWidget editButton; + public final Macro macro; + + + public MacroEntry(Macro macro, MacroListWidget owner) { + this.macro = macro; + this.owner = owner; + + buttonWidget = new CheckboxWidget(0, 0, 20, 20, null, macro.enabled, false); + deleteButton = new IconButtonWidget(IconButtonWidget.CROSS_ICON,0, 0, 20, 20 ,Text.of(""), (button) -> { + deleteIfConfirmed(); + }); + editButton = new IconButtonWidget(IconButtonWidget.PENCIL_ICON,0, 0, 20, 20, Text.of(""), (button) -> { + owner.parent.openEditScreen(this); + }); + } + + + public void render(MatrixStack matrices, int index, int y, int x, int entryWidth, int entryHeight, int mouseX, int mouseY, boolean hovered, float tickDelta) { + renderWidget(buttonWidget,matrices,mouseX,mouseY,tickDelta,x-30,y-2); + renderWidget(editButton,matrices,mouseX,mouseY,tickDelta,x+entryWidth,y-2); + renderWidget(deleteButton,matrices,mouseX,mouseY,tickDelta,x+entryWidth+22,y-2); + + String text = macro.name; + + if (owner.client.textRenderer.getWidth(text) > owner.getRowWidth()-2) { + while (owner.client.textRenderer.getWidth(text + "...") > owner.getRowWidth()-2) { + text = text.substring(0,text.length()-1); + } + + text += "..."; + } + + + owner.client.textRenderer.drawWithShadow(matrices, text, x, y+3,macro.enabled?16777215:8355711, true); + } + + private void renderWidget(PressableWidget widget, MatrixStack matrices, int mouseX, int mouseY, float tickDelta, int x, int y) { + widget.x = x; + widget.y = y; + widget.render(matrices,mouseX,mouseY,tickDelta); + } + + public boolean mouseClicked(double mouseX, double mouseY, int button) { + if (button == 0) { + this.onPressed(); + return true; + } else { + return false; + } + } + + public void mouseClickedInRow(double mouseX, double mouseY, int button) { + if (button != 0) return; + + if (clickWidget(buttonWidget, mouseX, mouseY)) macro.enabled = buttonWidget.isChecked(); + clickWidget(editButton,mouseX,mouseY); + clickWidget(deleteButton,mouseX,mouseY); + + + } + + + private boolean clickWidget(ClickableWidget widget, double mouseX, double mouseY) { + if (widget.isMouseOver(mouseX,mouseY)) { + owner.client.getSoundManager().play(PositionedSoundInstance.master(SoundEvents.UI_BUTTON_CLICK, 1.0F)); + widget.onClick(mouseX,mouseY); + + return true; + } + return false; + } + + private void onPressed() { + owner.setSelected(this); + } + + public Text getNarration() { + return new TranslatableText("narrator.select"); + } + + + public void delete() { + owner.removeEntry(this); + macro.unregisterKeyBinding(); + MacroListWidget.macroManager.removeMacro(this.macro); + MacroListWidget.macroManager.updateMacroKeys(); + } + + public void deleteIfConfirmed() { + owner.client.setScreen(new ConfirmScreen((confirmed) -> { + if (confirmed) { + this.delete(); + } + + owner.client.setScreen(owner.parent); + }, Text.of("Delete macro"), Text.of("Are you sure you want to delete '" + macro.name + "'?"))); + } +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/macros/gui/widget/macrolist/MacroListWidget.java b/oldSrc/main/java/tools/redstone/redstonetools/macros/gui/widget/macrolist/MacroListWidget.java new file mode 100644 index 00000000..333f2bf4 --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/macros/gui/widget/macrolist/MacroListWidget.java @@ -0,0 +1,77 @@ +package tools.redstone.redstonetools.macros.gui.widget.macrolist; + +import tools.redstone.redstonetools.macros.Macro; +import tools.redstone.redstonetools.macros.MacroManager; +import tools.redstone.redstonetools.macros.gui.screen.MacroSelectScreen; +import net.minecraft.client.MinecraftClient; +import net.minecraft.client.gui.widget.AlwaysSelectedEntryListWidget; +import net.minecraft.client.util.math.MatrixStack; + +import static tools.redstone.redstonetools.RedstoneToolsClient.INJECTOR; + +public class MacroListWidget extends AlwaysSelectedEntryListWidget { + + protected static final MacroManager macroManager = INJECTOR.getInstance(MacroManager.class); + + protected final MacroSelectScreen parent; + protected final MinecraftClient client; + + + public MacroListWidget(MacroSelectScreen parent, MinecraftClient client) { + super(client, parent.width, parent.height, 20, parent.height - 42, 20); + this.parent = parent; + this.client = client; + + for (Macro macro : macroManager.getMacros()) { + addEntry(new MacroEntry(macro,this)); + } + + + if (this.getSelectedOrNull() != null) { + this.centerScrollOn(this.getEntry(0)); + } + } + + public void addMacro(Macro macro) { + macroManager.addMacro(macro); + addEntry(new MacroEntry(macro, this)); + } + + public boolean canAdd(Macro macro) { + Macro macroFromName = macroManager.getMacro(macro.name); + + return macroFromName == null || macro.isCopyOf(macroFromName); + } + + protected int getScrollbarPositionX() { + return super.getScrollbarPositionX() + 20; + } + + + protected void renderBackground(MatrixStack matrices) { + parent.renderBackground(matrices); + } + + protected boolean isFocused() { + return parent.getFocused() == this; + } + + @Override + public boolean mouseClicked(double mouseX, double mouseY, int button) { + MacroEntry entry = super.getEntryAtPosition(width/2,mouseY); + if (entry != null) entry.mouseClickedInRow(mouseX,mouseY,button); + + return super.mouseClicked(mouseX, mouseY, button); + } + + @Override + public int getRowWidth() { + return 120; + } + + @Override + public boolean removeEntry(MacroEntry entry){ + return super.removeEntry(entry); + } + +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/mixin/accessors/MinecraftClientAccessor.java b/oldSrc/main/java/tools/redstone/redstonetools/mixin/accessors/MinecraftClientAccessor.java new file mode 100644 index 00000000..6996cf54 --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/mixin/accessors/MinecraftClientAccessor.java @@ -0,0 +1,15 @@ +package tools.redstone.redstonetools.mixin.accessors; + +import net.minecraft.block.entity.BlockEntity; +import net.minecraft.client.MinecraftClient; +import net.minecraft.item.ItemStack; +import org.spongepowered.asm.mixin.Mixin; +import org.spongepowered.asm.mixin.gen.Invoker; + +@Mixin(MinecraftClient.class) +public interface MinecraftClientAccessor { + + @Invoker + ItemStack invokeAddBlockEntityNbt(ItemStack stack, BlockEntity blockEntity); + +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/mixin/accessors/WorldRendererAccessor.java b/oldSrc/main/java/tools/redstone/redstonetools/mixin/accessors/WorldRendererAccessor.java new file mode 100644 index 00000000..88ff872a --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/mixin/accessors/WorldRendererAccessor.java @@ -0,0 +1,18 @@ +package tools.redstone.redstonetools.mixin.accessors; + +import net.minecraft.block.BlockState; +import net.minecraft.client.render.VertexConsumer; +import net.minecraft.client.render.WorldRenderer; +import net.minecraft.client.util.math.MatrixStack; +import net.minecraft.entity.Entity; +import net.minecraft.util.math.BlockPos; +import org.spongepowered.asm.mixin.Mixin; +import org.spongepowered.asm.mixin.gen.Invoker; + +@Mixin(WorldRenderer.class) +public interface WorldRendererAccessor { + + @Invoker + void invokeDrawBlockOutline(MatrixStack matrices, VertexConsumer vertexConsumer, Entity entity, double d, double e, double f, BlockPos pos, BlockState state); + +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/mixin/blocks/RedstoneHitboxMixin.java b/oldSrc/main/java/tools/redstone/redstonetools/mixin/blocks/RedstoneHitboxMixin.java new file mode 100644 index 00000000..663852fc --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/mixin/blocks/RedstoneHitboxMixin.java @@ -0,0 +1,46 @@ +package tools.redstone.redstonetools.mixin.blocks; + +import net.minecraft.block.Block; +import net.minecraft.block.BlockState; +import net.minecraft.block.RedstoneWireBlock; +import net.minecraft.block.ShapeContext; +import net.minecraft.util.math.BlockPos; +import net.minecraft.util.shape.VoxelShape; +import net.minecraft.world.BlockView; +import org.spongepowered.asm.mixin.*; +import org.spongepowered.asm.mixin.injection.At; +import org.spongepowered.asm.mixin.injection.Inject; +import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable; +import tools.redstone.redstonetools.RedstoneToolsClient; +import tools.redstone.redstonetools.features.toggleable.BigDustFeature; + +import java.util.HashMap; +import java.util.Map; + +@Pseudo +@Mixin(RedstoneWireBlock.class) +public class RedstoneHitboxMixin { + + private static BigDustFeature bigDustFeature; + + // use array for better performance + private static final VoxelShape[] SHAPES = new VoxelShape[16]; + + @Inject(method="getOutlineShape", at = @At("HEAD"), cancellable = true) + public void getOutlineShape(BlockState state, BlockView world, BlockPos pos, ShapeContext context, CallbackInfoReturnable cir) { + if (bigDustFeature == null) { + bigDustFeature = RedstoneToolsClient.INJECTOR.getInstance(BigDustFeature.class); + } + + if (bigDustFeature.isEnabled()) { + cir.setReturnValue(SHAPES[BigDustFeature.heightInPixels.getValue() - 1]); + } + } + + static { + for (int i = 1; i <= 16; i++) { + SHAPES[i - 1] = Block.createCuboidShape(0.0, 0.0, 0.0, 16.0, i, 16.0); + } + } + +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/mixin/features/AirPlaceClientMixin.java b/oldSrc/main/java/tools/redstone/redstonetools/mixin/features/AirPlaceClientMixin.java new file mode 100644 index 00000000..9236718d --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/mixin/features/AirPlaceClientMixin.java @@ -0,0 +1,85 @@ +package tools.redstone.redstonetools.mixin.features; + +import net.minecraft.client.MinecraftClient; +import net.minecraft.client.network.ClientPlayerEntity; +import net.minecraft.client.network.ClientPlayerInteractionManager; +import net.minecraft.util.hit.BlockHitResult; +import net.minecraft.util.hit.HitResult; +import net.minecraft.util.math.BlockPos; +import net.minecraft.util.math.Direction; +import org.spongepowered.asm.mixin.Mixin; +import org.spongepowered.asm.mixin.Shadow; +import org.spongepowered.asm.mixin.injection.At; +import org.spongepowered.asm.mixin.injection.Inject; +import org.spongepowered.asm.mixin.injection.callback.CallbackInfo; +import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable; +import org.spongepowered.asm.mixin.injection.callback.LocalCapture; +import tools.redstone.redstonetools.RedstoneToolsClient; +import tools.redstone.redstonetools.features.toggleable.AirPlaceFeature; +import tools.redstone.redstonetools.utils.RaycastUtils; + +@Mixin(MinecraftClient.class) +public class AirPlaceClientMixin { + private final AirPlaceFeature airPlaceFeature = RedstoneToolsClient.INJECTOR.getInstance(AirPlaceFeature.class); + + @Shadow + public HitResult crosshairTarget; + + @Inject(method = "doItemUse", at = @At(value = "HEAD"), locals = LocalCapture.CAPTURE_FAILHARD) + public void doItemUse(CallbackInfo callbackInfo) { + if (!isAirPlaceAllowed()) { + return; + } + + crosshairTarget = AirPlaceFeature.findAirPlaceBlockHit(getPlayer()); + } + + @Inject(method = "doAttack", at = @At(value = "HEAD"), locals = LocalCapture.CAPTURE_FAILHARD) + public void doAttack(CallbackInfoReturnable cir) { + if (!isAirPlaceAllowed()) { + return; + } + + // Call interactionManager directly because the block is air, with which the player cannot interact + var hit = AirPlaceFeature.findAirPlaceBlockHit(getPlayer()); + getInteractionManager().attackBlock(hit.getBlockPos(), hit.getSide()); + } + + private boolean isAirPlaceAllowed() { + // If air place is disabled + if (!airPlaceFeature.isEnabled()) { + return false; + } + + // If the hit result is already set + if (crosshairTarget != null && crosshairTarget.getType() != HitResult.Type.MISS) { + return false; + } + + // If the player or interactionManager not initialized + if (getPlayer() == null || getInteractionManager() == null) { + return false; + } + + // If air place isn't possible with the current + // player equipment and state + if (!AirPlaceFeature.canAirPlace(getPlayer())) { + return false; + } + + return true; + } + + private MinecraftClient getMinecraftClient() { + return (MinecraftClient) (Object) this; + } + + private ClientPlayerEntity getPlayer() { + return getMinecraftClient().player; + } + + private ClientPlayerInteractionManager getInteractionManager() { + return getMinecraftClient().interactionManager; + } + +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/mixin/features/AirPlaceServerMixin.java b/oldSrc/main/java/tools/redstone/redstonetools/mixin/features/AirPlaceServerMixin.java new file mode 100644 index 00000000..5b12380e --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/mixin/features/AirPlaceServerMixin.java @@ -0,0 +1,27 @@ +package tools.redstone.redstonetools.mixin.features; + +import net.minecraft.server.network.ServerPlayNetworkHandler; +import org.spongepowered.asm.mixin.Mixin; +import org.spongepowered.asm.mixin.injection.Constant; +import org.spongepowered.asm.mixin.injection.ModifyConstant; +import tools.redstone.redstonetools.RedstoneToolsClient; +import tools.redstone.redstonetools.features.toggleable.AirPlaceFeature; + +@Mixin(ServerPlayNetworkHandler.class) +public class AirPlaceServerMixin { + + private final AirPlaceFeature airPlaceFeature = RedstoneToolsClient.INJECTOR.getInstance(AirPlaceFeature.class); + + @ModifyConstant(method = "onPlayerInteractBlock", constant = @Constant(doubleValue = 64.0) ) + private double modifyConstant(double originalValue) { + + if (airPlaceFeature.isEnabled()) { + float reach5 = AirPlaceFeature.reach.getValue() + 5; + return reach5 * reach5; + } else { + return originalValue; + } + + } + +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/mixin/features/AutoDustMixin.java b/oldSrc/main/java/tools/redstone/redstonetools/mixin/features/AutoDustMixin.java new file mode 100644 index 00000000..f1131970 --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/mixin/features/AutoDustMixin.java @@ -0,0 +1,54 @@ +package tools.redstone.redstonetools.mixin.features; + +import net.minecraft.block.Block; +import net.minecraft.block.BlockState; +import net.minecraft.block.Blocks; +import net.minecraft.entity.LivingEntity; +import net.minecraft.entity.player.PlayerEntity; +import net.minecraft.item.ItemPlacementContext; +import net.minecraft.item.ItemStack; +import net.minecraft.item.Items; +import net.minecraft.util.Hand; +import net.minecraft.util.hit.BlockHitResult; +import net.minecraft.util.math.BlockPos; +import net.minecraft.util.math.Direction; +import net.minecraft.util.math.Vec3d; +import net.minecraft.world.World; +import org.spongepowered.asm.mixin.Mixin; +import org.spongepowered.asm.mixin.injection.At; +import org.spongepowered.asm.mixin.injection.Inject; +import org.spongepowered.asm.mixin.injection.callback.CallbackInfo; +import tools.redstone.redstonetools.RedstoneToolsClient; +import tools.redstone.redstonetools.features.toggleable.AutoDustFeature; +import tools.redstone.redstonetools.utils.ColoredBlock; + +@Mixin(Block.class) +public abstract class AutoDustMixin { + private AutoDustFeature autoDustFeature; + + private AutoDustFeature getAutoDustFeature() { + if (autoDustFeature == null) { + autoDustFeature = RedstoneToolsClient.INJECTOR.getInstance(AutoDustFeature.class); + } + + return autoDustFeature; + } + + @Inject(method = "onPlaced", at = @At("TAIL")) + private void onPlaced(World world, BlockPos pos, BlockState state, LivingEntity placer, ItemStack itemStack, CallbackInfo ci) { + if (!getAutoDustFeature().isEnabled()) { + return; + } + + var dustPos = pos.up(); + var block = world.getBlockState(pos).getBlock(); + var blockAbove = world.getBlockState(dustPos).getBlock(); + + if (!blockAbove.equals(Blocks.AIR) || ColoredBlock.fromBlock(block) == null) { + return; + } + + ItemPlacementContext context = new ItemPlacementContext((PlayerEntity) placer, Hand.MAIN_HAND,new ItemStack(Items.REDSTONE),new BlockHitResult(new Vec3d(dustPos.getX(),dustPos.getY(),dustPos.getZ()), Direction.UP, dustPos,false)); + placer.getWorld().setBlockState(dustPos, Blocks.REDSTONE_WIRE.getPlacementState(context)); + } +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/mixin/features/CopyStateMixin.java b/oldSrc/main/java/tools/redstone/redstonetools/mixin/features/CopyStateMixin.java new file mode 100644 index 00000000..1478b497 --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/mixin/features/CopyStateMixin.java @@ -0,0 +1,29 @@ +package tools.redstone.redstonetools.mixin.features; + +import net.minecraft.block.Block; +import net.minecraft.block.BlockState; +import net.minecraft.item.BlockItem; +import net.minecraft.item.ItemPlacementContext; +import org.spongepowered.asm.mixin.Mixin; +import org.spongepowered.asm.mixin.Shadow; +import org.spongepowered.asm.mixin.injection.At; +import org.spongepowered.asm.mixin.injection.Inject; +import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable; +import tools.redstone.redstonetools.utils.BlockStateNbtUtil; + + +@Mixin(BlockItem.class) +public abstract class CopyStateMixin { + + @Shadow protected abstract boolean canPlace(ItemPlacementContext context, BlockState state); + @Shadow public abstract Block getBlock(); + + @Inject(method = "getPlacementState", at = @At("TAIL"), cancellable = true) + public void getPlacementState(ItemPlacementContext context, CallbackInfoReturnable cir) { + BlockState state = BlockStateNbtUtil.getPlacementStateOrNull(context.getStack()); + if (state != null && this.canPlace(context, state)) { + cir.setReturnValue(state); + } + } + +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/mixin/features/ItemBindMixin.java b/oldSrc/main/java/tools/redstone/redstonetools/mixin/features/ItemBindMixin.java new file mode 100644 index 00000000..ee194cba --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/mixin/features/ItemBindMixin.java @@ -0,0 +1,78 @@ +package tools.redstone.redstonetools.mixin.features; + +import net.minecraft.client.MinecraftClient; +import net.minecraft.client.network.ClientPlayerEntity; +import net.minecraft.entity.Entity; +import net.minecraft.entity.player.PlayerEntity; +import net.minecraft.item.ItemStack; +import net.minecraft.item.ItemUsageContext; +import net.minecraft.nbt.NbtCompound; +import net.minecraft.nbt.NbtString; +import net.minecraft.util.ActionResult; +import net.minecraft.util.Hand; +import net.minecraft.util.TypedActionResult; +import net.minecraft.world.World; +import org.jetbrains.annotations.Nullable; +import org.spongepowered.asm.mixin.Mixin; +import org.spongepowered.asm.mixin.Shadow; +import org.spongepowered.asm.mixin.injection.At; +import org.spongepowered.asm.mixin.injection.Inject; +import org.spongepowered.asm.mixin.injection.callback.CallbackInfo; +import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable; +import tools.redstone.redstonetools.features.commands.ItemBindFeature; +import tools.redstone.redstonetools.features.feedback.Feedback; +import tools.redstone.redstonetools.features.feedback.FeedbackSender; + +import static tools.redstone.redstonetools.RedstoneToolsClient.INJECTOR; + + +public abstract class ItemBindMixin { + + @Mixin(ItemStack.class) + private abstract static class ItemStackMixin { + + @Shadow + public abstract @Nullable NbtCompound getNbt(); + + @Inject(method = "use", at = @At("HEAD"), cancellable = true) + public void checkCommandNBT(World world, PlayerEntity user, Hand hand, CallbackInfoReturnable> cir) { + if (tryToExecuteNBTCommand(hand, world)) { + cir.setReturnValue(TypedActionResult.pass((ItemStack) ((Object) this))); + } + } + + @Inject(method = "useOnBlock", at = @At("HEAD"), cancellable = true) + public void checkCommandNBT(ItemUsageContext context, CallbackInfoReturnable cir) { + if (tryToExecuteNBTCommand(context.getHand(), context.getWorld())) { + cir.setReturnValue(ActionResult.PASS); + } + } + + private boolean tryToExecuteNBTCommand(Hand hand, World world) { + if (hand == Hand.OFF_HAND || world.isClient) return false; + NbtCompound nbt = getNbt(); + if (nbt == null || !nbt.contains("command")) return false; + NbtString command = (NbtString) nbt.get("command"); + MinecraftClient.getInstance().player.sendChatMessage(command.asString()); + + return true; + } + } + + @Mixin(ClientPlayerEntity.class) + private abstract static class PlayerMixin { + + @Inject(method = "sendChatMessage", at = @At("HEAD"), cancellable = true) + public void injectCommand(String message, CallbackInfo ci) { + if (!message.startsWith("/") || !ItemBindFeature.waitingForCommand) return; + + Feedback addCommandFeedback = ItemBindFeature.addCommand(message); + if (addCommandFeedback != null) { + INJECTOR.getInstance(FeedbackSender.class).sendFeedback(((Entity) ((Object)this)).getCommandSource(),addCommandFeedback); + ci.cancel(); + } + } + } + + +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/mixin/gamerules/DoContainerDropsMixin.java b/oldSrc/main/java/tools/redstone/redstonetools/mixin/gamerules/DoContainerDropsMixin.java new file mode 100644 index 00000000..48280e65 --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/mixin/gamerules/DoContainerDropsMixin.java @@ -0,0 +1,20 @@ +package tools.redstone.redstonetools.mixin.gamerules; + +import net.minecraft.inventory.Inventory; +import net.minecraft.util.ItemScatterer; +import net.minecraft.util.math.BlockPos; +import net.minecraft.world.World; +import org.spongepowered.asm.mixin.Mixin; +import org.spongepowered.asm.mixin.injection.At; +import org.spongepowered.asm.mixin.injection.Inject; +import org.spongepowered.asm.mixin.injection.callback.CallbackInfo; + +import static tools.redstone.redstonetools.RedstoneToolsGameRules.DO_CONTAINER_DROPS; + +@Mixin(ItemScatterer.class) +public class DoContainerDropsMixin { + @Inject(method = "spawn(Lnet/minecraft/world/World;Lnet/minecraft/util/math/BlockPos;Lnet/minecraft/inventory/Inventory;)V", at = @At("HEAD"), cancellable = true) + private static void spawn(World world, BlockPos pos, Inventory inventory, CallbackInfo ci) { + if (!world.getGameRules().getBoolean(DO_CONTAINER_DROPS)) ci.cancel(); + } +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/mixin/macros/AddMacroButtonMixin.java b/oldSrc/main/java/tools/redstone/redstonetools/mixin/macros/AddMacroButtonMixin.java new file mode 100644 index 00000000..df394185 --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/mixin/macros/AddMacroButtonMixin.java @@ -0,0 +1,27 @@ +package tools.redstone.redstonetools.mixin.macros; + +import net.minecraft.client.gui.screen.Screen; +import net.minecraft.client.gui.screen.option.ControlsOptionsScreen; +import net.minecraft.client.gui.screen.option.GameOptionsScreen; +import net.minecraft.client.gui.widget.ButtonWidget; +import net.minecraft.client.option.GameOptions; +import net.minecraft.text.Text; +import org.spongepowered.asm.mixin.Mixin; +import org.spongepowered.asm.mixin.injection.At; +import org.spongepowered.asm.mixin.injection.Inject; +import org.spongepowered.asm.mixin.injection.callback.CallbackInfo; +import tools.redstone.redstonetools.macros.gui.screen.MacroSelectScreen; + +@Mixin(ControlsOptionsScreen.class) +public class AddMacroButtonMixin extends GameOptionsScreen { + public AddMacroButtonMixin(Screen parent, GameOptions gameOptions, Text title) { + super(parent, gameOptions, title); + } + + @Inject(method = "init", at = @At("TAIL")) + public void init(CallbackInfo ci) { + this.addDrawableChild(new ButtonWidget(this.width / 2 + 5, this.height / 6 + 36, 150, 20, Text.of("Macros..."), (button) -> { + this.client.setScreen(new MacroSelectScreen(this,super.gameOptions,Text.of("Macros"))); + })); + } +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/mixin/macros/InitializeMacroManagerMixin.java b/oldSrc/main/java/tools/redstone/redstonetools/mixin/macros/InitializeMacroManagerMixin.java new file mode 100644 index 00000000..ea9ae3ab --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/mixin/macros/InitializeMacroManagerMixin.java @@ -0,0 +1,18 @@ +package tools.redstone.redstonetools.mixin.macros; + +import net.minecraft.client.MinecraftClient; +import net.minecraft.client.RunArgs; +import org.spongepowered.asm.mixin.Mixin; +import org.spongepowered.asm.mixin.injection.At; +import org.spongepowered.asm.mixin.injection.Inject; +import org.spongepowered.asm.mixin.injection.callback.CallbackInfo; +import tools.redstone.redstonetools.RedstoneToolsClient; +import tools.redstone.redstonetools.macros.MacroManager; + +@Mixin(MinecraftClient.class) +public class InitializeMacroManagerMixin { + @Inject(method = "", at = @At("TAIL")) + public void registerMacros(RunArgs args, CallbackInfo ci){ + RedstoneToolsClient.INJECTOR.getInstance(MacroManager.class);// should register macro keybinds + } +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/mixin/macros/KeyBindingMixinImpl.java b/oldSrc/main/java/tools/redstone/redstonetools/mixin/macros/KeyBindingMixinImpl.java new file mode 100644 index 00000000..8ac71b89 --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/mixin/macros/KeyBindingMixinImpl.java @@ -0,0 +1,30 @@ +package tools.redstone.redstonetools.mixin.macros; + +import net.minecraft.client.option.KeyBinding; +import net.minecraft.client.util.InputUtil; +import org.spongepowered.asm.mixin.Final; +import org.spongepowered.asm.mixin.Mixin; +import org.spongepowered.asm.mixin.Shadow; +import tools.redstone.redstonetools.macros.KeyBindingMixin; + +import java.util.Map; + +@Mixin(KeyBinding.class) +public class KeyBindingMixinImpl implements KeyBindingMixin { + + @Shadow @Final private static Map KEYS_BY_ID; + + @Shadow @Final private static Map KEY_TO_BINDINGS; + + @Override + public void removeKeybinding(KeyBinding keyBinding) { + KEYS_BY_ID.entrySet().removeIf(entry -> entry.getValue().equals(this)); + KEY_TO_BINDINGS.entrySet().removeIf(entry -> entry.getValue().equals(this)); + } + + @Override + public KeyBinding getBindingFromKey(InputUtil.Key key) { + return KEY_TO_BINDINGS.get(key); + } + +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/mixin/macros/autocomplete/ClientPlayerEntityMixinImpl.java b/oldSrc/main/java/tools/redstone/redstonetools/mixin/macros/autocomplete/ClientPlayerEntityMixinImpl.java new file mode 100644 index 00000000..bab50f77 --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/mixin/macros/autocomplete/ClientPlayerEntityMixinImpl.java @@ -0,0 +1,22 @@ +package tools.redstone.redstonetools.mixin.macros.autocomplete; + +import net.minecraft.client.network.ClientPlayNetworkHandler; +import net.minecraft.client.network.ClientPlayerEntity; +import org.spongepowered.asm.mixin.Final; +import org.spongepowered.asm.mixin.Mixin; +import org.spongepowered.asm.mixin.Mutable; +import org.spongepowered.asm.mixin.Shadow; +import tools.redstone.redstonetools.macros.ClientPlayerEntityMixin; + +@Mixin(ClientPlayerEntity.class) +public class ClientPlayerEntityMixinImpl implements ClientPlayerEntityMixin { + + @Mutable + @Shadow @Final public ClientPlayNetworkHandler networkHandler; + + + public void setNetworkHandler(ClientPlayNetworkHandler networkHandler) { + this.networkHandler = networkHandler; + } + +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/mixin/macros/autocomplete/CommandSuggestorMixin.java b/oldSrc/main/java/tools/redstone/redstonetools/mixin/macros/autocomplete/CommandSuggestorMixin.java new file mode 100644 index 00000000..c88c08b4 --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/mixin/macros/autocomplete/CommandSuggestorMixin.java @@ -0,0 +1,71 @@ +package tools.redstone.redstonetools.mixin.macros.autocomplete; + +import com.mojang.brigadier.suggestion.Suggestions; +import net.minecraft.client.gui.screen.CommandSuggestor; +import net.minecraft.client.gui.widget.TextFieldWidget; +import net.minecraft.client.util.math.MatrixStack; +import org.jetbrains.annotations.Nullable; +import org.spongepowered.asm.mixin.Final; +import org.spongepowered.asm.mixin.Mixin; +import org.spongepowered.asm.mixin.Shadow; +import org.spongepowered.asm.mixin.injection.At; +import org.spongepowered.asm.mixin.injection.Inject; +import org.spongepowered.asm.mixin.injection.ModifyVariable; +import org.spongepowered.asm.mixin.injection.callback.CallbackInfo; +import tools.redstone.redstonetools.macros.gui.MaroCommandSuggestor; + +import java.util.concurrent.CompletableFuture; + + +@Mixin(CommandSuggestor.class) +public class CommandSuggestorMixin{ + + @Shadow @Final + TextFieldWidget textField; + @Shadow private @Nullable CompletableFuture pendingSuggestions; + @Shadow @Final + int maxSuggestionSize; + + + @ModifyVariable(method = "showSuggestions", at = @At("STORE"), ordinal = 1) + public int suggestionWindXPos(int j){ + if (MaroCommandSuggestor.instance(this)) { + Suggestions suggestions = this.pendingSuggestions.join(); + return this.textField.getCharacterX(suggestions.getRange().getStart())+4; + } + return j; + } + + @ModifyVariable(method = "showSuggestions", at = @At("STORE"), ordinal = 2) + public int suggestionWindYPos(int k){ + if (MaroCommandSuggestor.instance(this)) { + Suggestions suggestions = this.pendingSuggestions.join(); + + int y = MaroCommandSuggestor.getY(this)-2; + return y +20 - Math.min(suggestions.getList().size(), this.maxSuggestionSize) * 12; + } + return k; + } + + + private int i = 0; + + @Inject(method = "render", at = @At("HEAD")) + public void render(MatrixStack matrices, int mouseX, int mouseY, CallbackInfo ci){ + i = 0; + } + + @ModifyVariable(method = "render", at = @At("STORE"), ordinal = 3) + public int messageYPos(int j) { + if (MaroCommandSuggestor.instance(this)) { + int y = MaroCommandSuggestor.getY(this); + i++; + return y - 12*(i-1)+43; + } + return j; + } + + + + +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/mixin/update/CheckUpdateMixin.java b/oldSrc/main/java/tools/redstone/redstonetools/mixin/update/CheckUpdateMixin.java new file mode 100644 index 00000000..d2642ae4 --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/mixin/update/CheckUpdateMixin.java @@ -0,0 +1,91 @@ +package tools.redstone.redstonetools.mixin.update; + +import com.google.gson.Gson; +import com.google.gson.JsonObject; +import net.minecraft.client.gui.screen.Screen; +import net.minecraft.client.gui.screen.TitleScreen; +import net.minecraft.client.gui.widget.PressableTextWidget; +import net.minecraft.text.*; +import net.minecraft.util.Util; +import org.spongepowered.asm.mixin.Mixin; +import org.spongepowered.asm.mixin.injection.At; +import org.spongepowered.asm.mixin.injection.Inject; +import org.spongepowered.asm.mixin.injection.callback.CallbackInfo; +import tools.redstone.redstonetools.RedstoneToolsClient; + +import java.net.URI; +import java.net.http.HttpClient; +import java.net.http.HttpRequest; +import java.net.http.HttpResponse; + +import static tools.redstone.redstonetools.RedstoneToolsClient.LOGGER; +import static tools.redstone.redstonetools.RedstoneToolsClient.MOD_VERSION; + +@Mixin(TitleScreen.class) +public class CheckUpdateMixin extends Screen { + private static boolean updateChecked = false; + + private static MutableText updateStatus = (MutableText) Text.of("Redstone Tools Version: " + MOD_VERSION + "(Bug found, report on Github)"); + private static URI uri; + public CheckUpdateMixin() { + super(Text.of("UpdateText(Bug found, report on Github)")); + } + + @Inject(method = "init", at = @At("TAIL")) + public void checkUpdate(CallbackInfo ci) { + if (updateChecked) + return; + + try { + LOGGER.info("Checking for updates..."); + + HttpClient client = HttpClient.newBuilder() + .build(); + HttpRequest request = HttpRequest.newBuilder() + .uri(URI.create("https://api.github.com/repositories/597142955/releases/latest")) + .GET() + .build(); + + HttpResponse response = client.send(request, HttpResponse.BodyHandlers.ofString()); + String responseBody = response.body(); + + if (response.statusCode() < 200 || 299 < response.statusCode()) { + LOGGER.error("Got status code " + response.statusCode() + " while trying to check for updates"); + return; + } + + Gson gson = new Gson(); + JsonObject release = gson.fromJson(responseBody, JsonObject.class); + uri = new URI(release.get("html_url").getAsString()); + String newVersion = release.get("tag_name").getAsString(); + + LOGGER.info("Found latest version: " + newVersion); + if (newVersion.contains("alpha") || newVersion.contains("beta")) { + LOGGER.info("Not showing an update popup for alpha or beta release, current version: " + MOD_VERSION + ", new version: " + newVersion); + return; + } + + Style underline = Style.EMPTY; + if (RedstoneToolsClient.MOD_VERSION.equals(newVersion)) { + LOGGER.info("Already up to date, current version: " + MOD_VERSION); + updateStatus = (MutableText) Text.of("Redstone Tools " + MOD_VERSION); + } else { + LOGGER.info("Found newer version, current version: " + RedstoneToolsClient.MOD_VERSION + ", new version: " + newVersion); + updateStatus = (MutableText) Text.of("Redstone Tools " + MOD_VERSION + " ("); + updateStatus.append(Text.of("Click to Update").getWithStyle(underline.withUnderline(true)).get(0)); + updateStatus.append(")"); + } + + } catch (Exception e) { + LOGGER.warn("Failed to check for RedstoneTools updates"); + e.printStackTrace(); + } finally { + updateChecked = true; + } + } + + @Inject(method="init", at = @At("HEAD")) + public void updateTextInjection(CallbackInfo ci){ + this.addDrawableChild(new PressableTextWidget(4,4, textRenderer.getWidth(updateStatus), textRenderer.fontHeight,updateStatus,button -> {Util.getOperatingSystem().open(uri);},textRenderer)); + } +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/utils/BlockColor.java b/oldSrc/main/java/tools/redstone/redstonetools/utils/BlockColor.java new file mode 100644 index 00000000..62dee464 --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/utils/BlockColor.java @@ -0,0 +1,50 @@ +package tools.redstone.redstonetools.utils; + +import net.minecraft.block.Block; + +import java.util.Arrays; + +public enum BlockColor { + WHITE("white"), + ORANGE("orange"), + MAGENTA("magenta"), + LIGHT_BLUE("light_blue"), + YELLOW("yellow"), + LIME("lime"), + PINK("pink"), + GRAY("gray"), + LIGHT_GRAY("light_gray"), + CYAN("cyan"), + PURPLE("purple"), + BLUE("blue"), + BROWN("brown"), + GREEN("green"), + RED("red"), + BLACK("black"); + + private final String name; + + BlockColor(String name) { + this.name = name; + } + + public static BlockColor fromString(String name) { + return Arrays.stream(BlockColor.values()) + .filter(color -> color.name.equals(name)) + .findFirst() + .orElseThrow(); + } + + public static BlockColor fromBlock(Block block) { + var coloredBlock = ColoredBlock.fromBlock(block); + + return coloredBlock == null + ? BlockColor.WHITE + : coloredBlock.color; + } + + @Override + public String toString() { + return name; + } +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/utils/BlockInfo.java b/oldSrc/main/java/tools/redstone/redstonetools/utils/BlockInfo.java new file mode 100644 index 00000000..3c1997f6 --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/utils/BlockInfo.java @@ -0,0 +1,20 @@ +package tools.redstone.redstonetools.utils; + +import net.minecraft.block.Block; +import net.minecraft.block.BlockState; +import net.minecraft.block.entity.BlockEntity; +import net.minecraft.util.math.BlockPos; + +public class BlockInfo { + public final Block block; + public final BlockPos pos; + public final BlockState state; + public final BlockEntity entity; + + public BlockInfo(Block block, BlockPos pos, BlockState state, BlockEntity entity) { + this.block = block; + this.pos = pos; + this.state = state; + this.entity = entity; + } +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/utils/BlockStateNbtUtil.java b/oldSrc/main/java/tools/redstone/redstonetools/utils/BlockStateNbtUtil.java new file mode 100644 index 00000000..fcef4e28 --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/utils/BlockStateNbtUtil.java @@ -0,0 +1,181 @@ +package tools.redstone.redstonetools.utils; + +import net.minecraft.block.Block; +import net.minecraft.block.BlockState; +import net.minecraft.item.BlockItem; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NbtCompound; +import net.minecraft.nbt.NbtElement; +import net.minecraft.nbt.NbtList; +import net.minecraft.server.world.ServerWorld; +import net.minecraft.state.property.Property; +import net.minecraft.util.Identifier; +import net.minecraft.util.registry.Registry; + +import java.util.Objects; + +/** + * Utilities for block state (de)serialization into NBT tags. + */ +public final class BlockStateNbtUtil { + + private BlockStateNbtUtil() { + } + + /** + * Serializes the given block state into an NBT compound. + * + * @param state The state. + * @return The NBT tag or null if the block state is null. + */ + @SuppressWarnings({ "unchecked", "rawtypes" }) + public static NbtCompound toNBT(BlockState state) { + if (state == null) { + return null; + } + + NbtCompound root = new NbtCompound(); + root.putString("Id", Registry.BLOCK.getId(state.getBlock()).toString()); + + // serialize properties + if (!state.getProperties().isEmpty()) { + NbtList properties = new NbtList(); + for (Property property : state.getProperties()) { + // todo: maybe compress this? to optimize for memory + NbtCompound propertyTag = new NbtCompound(); + propertyTag.putString("K", property.getName()); + propertyTag.putString("V", property.name(state.get(property))); + properties.add(propertyTag); + } + + root.put("Properties", properties); + } + + return root; + } + + /** + * Attempts to deserialize a block state from the given NBT tag. + * + * @param compound The NBT tag. + * @return The block state or null if the tag is null/empty. + */ + @SuppressWarnings({ "unchecked", "rawtypes" }) + public static BlockState fromNBT(NbtCompound compound) { + if (compound == null || compound.isEmpty()) { + return null; + } + + // find the block + // we use new Identifier(...) here to allow it to throw exceptions + // instead of getting a cryptic NPE + Identifier identifier = new Identifier(compound.getString("Id")); + Block block = Registry.BLOCK.get(identifier); + + // deserialize properties + BlockState state = block.getDefaultState(); + NbtList propertiesTag = compound.getList("Properties", NbtElement.COMPOUND_TYPE); + if (propertiesTag != null) { + for (NbtElement element : propertiesTag) { + // this cast is checked, as we require the COMPOUND type + // when getting the list + NbtCompound propertyTag = (NbtCompound) element; + + Property property = block.getStateManager().getProperty(propertyTag.getString("K")); + if (property == null) + continue; + + state = state.with(property, (Comparable) property.parse(propertyTag.getString("V")).get()); + } + } + + return state; + } + + /** + * Attempts to deserialize a block state from the given NBT tag, + * or returns the given default if the tag is null/empty. + * + * @param compound The NBT tag. + * @param def The default. + * @return The block state or {@code def} if the tag is null/empty. + */ + public static BlockState fromNBT(NbtCompound compound, BlockState def) { + BlockState state = fromNBT(compound); + return state == null ? def : state; + } + + /** + * The key for the exact placement state in an items NBT. + */ + public static final String EXACT_STATE_KEY = "ExactBlockState"; + + /** + * Modifies the given item stack to add the exact block state + * placement data. The item stack should place the exact given + * block state when attempted. + * + * @param stack The input stack. + * @param state The block state to assign. + */ + public static void putPlacement(ItemStack stack, BlockState state) { + Objects.requireNonNull(stack); + stack.getOrCreateNbt().put(EXACT_STATE_KEY, toNBT(state)); + } + + /** + * Creates an item stack which should place the exact given + * block state when attempted. + * + * The created item stack has a count of 1 by default. + * + * @param state The placement state. + * @return The item stack. + */ + public static ItemStack createPlacementStack(BlockState state) { + ItemStack stack = new ItemStack(state.getBlock()); + putPlacement(stack, state); + return stack; + } + + /** + * Tries to get the exact placement state for the given + * item stack. If it is unable to determine the exact + * block state it will return null. + * + * @param stack The item stack. + * @return The block state or null. + */ + public static BlockState getPlacementStateOrNull(ItemStack stack) { + NbtCompound nbt = stack.getNbt(); + if (nbt == null || !nbt.contains(EXACT_STATE_KEY)) { + return null; + } + + return fromNBT(nbt.getCompound(EXACT_STATE_KEY)); + } + + /** + * Tries to get the exact placement state for the given + * item stack. If it is unable to determine the exact + * block state it will return the blocks default state + * if the item is a {@link BlockItem}, or null otherwise. + * + * @param stack The item stack. + * @return The block state or null. + */ + public static BlockState getPlacementState(ItemStack stack) { + NbtCompound nbt = stack.getNbt(); + if (nbt == null || !nbt.contains(EXACT_STATE_KEY)) { + if (stack.getItem() instanceof BlockItem blockItem) + return blockItem.getBlock().getDefaultState(); + return null; + } + + BlockState def = stack.getItem() instanceof BlockItem blockItem ? + blockItem.getBlock().getDefaultState() : + null; + return fromNBT(nbt.getCompound(EXACT_STATE_KEY), def); + } + +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/utils/ColoredBlock.java b/oldSrc/main/java/tools/redstone/redstonetools/utils/ColoredBlock.java new file mode 100644 index 00000000..266ab358 --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/utils/ColoredBlock.java @@ -0,0 +1,85 @@ +package tools.redstone.redstonetools.utils; + +import net.minecraft.block.Block; +import net.minecraft.util.Identifier; +import net.minecraft.util.registry.Registry; +import org.jetbrains.annotations.NotNull; + +import java.util.HashMap; +import java.util.regex.Pattern; + +public class ColoredBlock { + private static final Pattern COLORED_BLOCK_REGEX = Pattern.compile( + "^minecraft:(\\w+?)_(wool|stained_glass|concrete_powder|concrete|glazed_terracotta|terracotta)$" + ); + + private static final HashMap COLORLESS_BLOCKS = new HashMap<>() {{ + put("minecraft:glass", new ColoredBlock("minecraft:%s_stained_glass", BlockColor.WHITE)); + put("minecraft:terracotta", new ColoredBlock("minecraft:%s_terracotta", BlockColor.WHITE)); + }}; + + private static final HashMap COLORED_BLOCK_CACHE = new HashMap<>() {{ + putAll(COLORLESS_BLOCKS); + }}; + + private final String blockIdFormat; + public final BlockColor color; + + public ColoredBlock(String blockIdFormat, BlockColor color) { + this.blockIdFormat = blockIdFormat; + this.color = color; + } + + public ColoredBlock withColor(BlockColor color) { + return new ColoredBlock(blockIdFormat, color); + } + + public static ColoredBlock fromBlockId(String blockId) { + if (COLORED_BLOCK_CACHE.containsKey(blockId)) { + return COLORED_BLOCK_CACHE.get(blockId); + } + + var matcher = COLORED_BLOCK_REGEX.matcher(blockId); + if (!matcher.matches()) { + return null; + } + + var color = matcher.group(1); + var blockType = matcher.group(2); + + var coloredBlock = new ColoredBlock("minecraft:%s_" + blockType, BlockColor.fromString(color)); + + COLORED_BLOCK_CACHE.put(blockId, coloredBlock); + + return coloredBlock; + } + + public String toBlockId() { + return String.format(blockIdFormat, color); + } + + public static ColoredBlock fromBlock(@NotNull Block block) { + var blockId = Registry.BLOCK.getId(block).toString(); + if (COLORED_BLOCK_CACHE.containsKey(blockId)) { + return COLORED_BLOCK_CACHE.get(blockId); + } + + var coloredBlock = fromBlockId(blockId); + + // The reason we only cache nulls here and not in the fromBlockId method is because the fromBlockId method would + // also cache invalid block ids (literally any string) which would make the cache massive. This method however + // only accepts actual blocks which means that the cache will never grow bigger than the amount of mc blocks. + COLORED_BLOCK_CACHE.put(blockId, coloredBlock); + + return coloredBlock; + } + + public Block toBlock() { + return Registry.BLOCK.get(Identifier.tryParse(toBlockId())); + } + + @Override + public String toString() { + return toBlockId(); + } +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/utils/ColoredBlockType.java b/oldSrc/main/java/tools/redstone/redstonetools/utils/ColoredBlockType.java new file mode 100644 index 00000000..701447c7 --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/utils/ColoredBlockType.java @@ -0,0 +1,39 @@ +package tools.redstone.redstonetools.utils; + +import net.minecraft.block.Block; +import net.minecraft.util.Identifier; +import net.minecraft.util.registry.Registry; + +public enum ColoredBlockType { + // TODO: Merge some things with the ColoredBlock class so we dont have to repeat the formats and stuff + WOOL("wool", "minecraft:%s_wool"), + GLASS("glass", "minecraft:%s_stained_glass"), + CONCRETE("concrete", "minecraft:%s_concrete"), + TERRACOTTA("terracotta", "minecraft:%s_terracotta"); + + private final String displayName; + private final String blockIdFormat; + + ColoredBlockType(String displayName, String blockIdFormat) { + this.displayName = displayName; + this.blockIdFormat = blockIdFormat; + } + + @Override + public String toString() { + return displayName; + } + + public ColoredBlock withColor(BlockColor color) { + return ColoredBlock.fromBlock(toBlock()) + .withColor(color); + } + + public String toBlockId() { + return String.format(blockIdFormat, BlockColor.WHITE); + } + + public Block toBlock() { + return Registry.BLOCK.get(Identifier.tryParse(toBlockId())); + } +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/utils/CommandSourceUtils.java b/oldSrc/main/java/tools/redstone/redstonetools/utils/CommandSourceUtils.java new file mode 100644 index 00000000..fd0b5c4a --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/utils/CommandSourceUtils.java @@ -0,0 +1,12 @@ +package tools.redstone.redstonetools.utils; + +import net.minecraft.server.command.ServerCommandSource; + +public class CommandSourceUtils { + private CommandSourceUtils() { + } + + public static void executeCommand(ServerCommandSource source, String command) { + source.getServer().getCommandManager().execute(source, command); + } +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/utils/CommandUtils.java b/oldSrc/main/java/tools/redstone/redstonetools/utils/CommandUtils.java new file mode 100644 index 00000000..5d42ef6f --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/utils/CommandUtils.java @@ -0,0 +1,59 @@ +package tools.redstone.redstonetools.utils; + +import com.mojang.brigadier.builder.LiteralArgumentBuilder; +import tools.redstone.redstonetools.features.arguments.Argument; +import com.mojang.brigadier.Command; +import com.mojang.brigadier.CommandDispatcher; +import com.mojang.brigadier.builder.ArgumentBuilder; +import net.minecraft.server.command.CommandManager; +import net.minecraft.server.command.ServerCommandSource; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; + +public class CommandUtils { + private CommandUtils() { } + + public static LiteralArgumentBuilder build(String name, List> arguments, Command executor) { + var base = CommandManager.literal(name); + + if (arguments.stream().allMatch(Argument::isOptional)) { + base.executes(executor); + } + + if (!arguments.isEmpty()) { + base.then(createArgumentChain(arguments.stream() + .sorted((a, b) -> Boolean.compare(a.isOptional(), b.isOptional())) + .toList(), executor)); + } + + return base; + } + + public static void register(String name, List> arguments, Command executor, CommandDispatcher dispatcher, boolean dedicated) { + var base = build(name, arguments, executor); + dispatcher.register(base); + } + + private static ArgumentBuilder createArgumentChain(List> arguments, Command executor) { + var reversedArguments = new ArrayList<>(arguments); + Collections.reverse(reversedArguments); + + ArgumentBuilder argument = null; + for (var arg : reversedArguments) { + if (argument == null) { + argument = CommandManager.argument(arg.getName(), arg.getType()).executes(executor); + } else { + argument = CommandManager.argument(arg.getName(), arg.getType()).then(argument); + + // If the argument is optional or if this is the last required argument it should run the executor + if (arg.isOptional() || reversedArguments.get(reversedArguments.indexOf(arg) - 1).isOptional()) { + argument.executes(executor); + } + } + } + + return argument; + } +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/utils/DependencyLookup.java b/oldSrc/main/java/tools/redstone/redstonetools/utils/DependencyLookup.java new file mode 100644 index 00000000..a316d3b8 --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/utils/DependencyLookup.java @@ -0,0 +1,25 @@ +package tools.redstone.redstonetools.utils; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public class DependencyLookup { + private static final Logger LOGGER = + LoggerFactory.getLogger(DependencyLookup.class); + public static final boolean WORLDEDIT_PRESENT = + require("com.sk89q.worldedit.WorldEdit"); + + private static boolean require(String... classNames) { + for (String className : classNames) { + try { + Class.forName(className); + } catch (ClassNotFoundException e) { + return false; + } catch (Throwable t) { + LOGGER.warn("Unexpected error while checking for dependency {}", className, t); + return false; + } + } + return true; + } +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/utils/DirectionArgument.java b/oldSrc/main/java/tools/redstone/redstonetools/utils/DirectionArgument.java new file mode 100644 index 00000000..3bc66d24 --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/utils/DirectionArgument.java @@ -0,0 +1,24 @@ +package tools.redstone.redstonetools.utils; + +public enum DirectionArgument { + ME, + FORWARD, + BACK, + NORTH, + EAST, + SOUTH, + WEST, + NORTHEAST, + NORTHWEST, + SOUTHEAST, + SOUTHWEST, + UP, + DOWN, + LEFT, + RIGHT; + + @Override + public String toString() { + return this.name().toLowerCase(); + } +} \ No newline at end of file diff --git a/oldSrc/main/java/tools/redstone/redstonetools/utils/DirectionUtils.java b/oldSrc/main/java/tools/redstone/redstonetools/utils/DirectionUtils.java new file mode 100644 index 00000000..2eb14654 --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/utils/DirectionUtils.java @@ -0,0 +1,115 @@ +package tools.redstone.redstonetools.utils; + + +import com.sk89q.worldedit.math.BlockVector3; +import com.sk89q.worldedit.util.Direction; +import net.minecraft.command.CommandException; +import net.minecraft.text.Text; +import org.jetbrains.annotations.NotNull; + +public class DirectionUtils { + public static Direction firstOrdinal(Direction playerFacing) { + return switch (playerFacing) { + case EAST_NORTHEAST, NORTH_NORTHEAST -> Direction.NORTHEAST; + case NORTH_NORTHWEST, WEST_NORTHWEST -> Direction.NORTHWEST; + case EAST_SOUTHEAST, SOUTH_SOUTHEAST -> Direction.SOUTHEAST; + case SOUTH_SOUTHWEST, WEST_SOUTHWEST -> Direction.SOUTHWEST; + default -> playerFacing; + }; + } + + public static DirectionArgument relativeToAbsolute(DirectionArgument direction, Direction playerFacing) { + return switch (direction) { + case ME, FORWARD -> switch (firstOrdinal(playerFacing)) { + case UP -> DirectionArgument.UP; + case DOWN -> DirectionArgument.DOWN; + case NORTH -> DirectionArgument.NORTH; + case EAST -> DirectionArgument.EAST; + case SOUTH -> DirectionArgument.SOUTH; + case WEST -> DirectionArgument.WEST; + case NORTHEAST -> DirectionArgument.NORTHEAST; + case NORTHWEST -> DirectionArgument.NORTHWEST; + case SOUTHWEST -> DirectionArgument.SOUTHWEST; + case SOUTHEAST -> DirectionArgument.SOUTHEAST; + default -> null; + }; + case LEFT -> switch (firstOrdinal(playerFacing)) { + case UP, DOWN -> throw new CommandException(Text.of("Can't determine direction")); + case NORTH -> DirectionArgument.WEST; + case EAST -> DirectionArgument.NORTH; + case SOUTH -> DirectionArgument.EAST; + case WEST -> DirectionArgument.SOUTH; + case NORTHWEST -> DirectionArgument.SOUTHWEST; + case NORTHEAST -> DirectionArgument.NORTHWEST; + case SOUTHEAST -> DirectionArgument.NORTHEAST; + case SOUTHWEST -> DirectionArgument.SOUTHEAST; + default -> null; + }; + case RIGHT -> switch (firstOrdinal(playerFacing)) { + case UP, DOWN -> throw new CommandException(Text.of("Can't determine direction")); + case NORTH -> DirectionArgument.EAST; + case EAST -> DirectionArgument.SOUTH; + case SOUTH -> DirectionArgument.WEST; + case WEST -> DirectionArgument.NORTH; + case NORTHEAST -> DirectionArgument.SOUTHEAST; + case NORTHWEST -> DirectionArgument.NORTHEAST; + case SOUTHWEST -> DirectionArgument.NORTHWEST; + case SOUTHEAST -> DirectionArgument.SOUTHWEST; + default -> null; + }; + case BACK -> switch (firstOrdinal(playerFacing)) { + case UP -> DirectionArgument.DOWN; + case DOWN -> DirectionArgument.UP; + case NORTH -> DirectionArgument.SOUTH; + case EAST -> DirectionArgument.WEST; + case SOUTH -> DirectionArgument.NORTH; + case WEST -> DirectionArgument.EAST; + case NORTHWEST -> DirectionArgument.SOUTHEAST; + case NORTHEAST -> DirectionArgument.SOUTHWEST; + case SOUTHEAST -> DirectionArgument.NORTHWEST; + case SOUTHWEST -> DirectionArgument.NORTHEAST; + default -> null; + }; + default -> direction; + }; + } + + // big evil match direction function, there might be a better way to do this but i don't know how + @NotNull + public static Direction matchDirection(DirectionArgument direction, Direction playerFacing) throws CommandException { + var absoluteDirection = relativeToAbsolute(direction, playerFacing); + return switch (absoluteDirection) { + case NORTH -> Direction.NORTH; + case EAST -> Direction.EAST; + case SOUTH -> Direction.SOUTH; + case WEST -> Direction.WEST; + case NORTHEAST -> Direction.NORTHEAST; + case NORTHWEST -> Direction.NORTHWEST; + case SOUTHEAST -> Direction.SOUTHEAST; + case SOUTHWEST -> Direction.SOUTHWEST; + case UP -> Direction.UP; + case DOWN -> Direction.DOWN; + default -> { + assert false; + yield null; + } + }; + } + + // so many switch cases + public static BlockVector3 directionToBlock(Direction direction) { + return switch (direction) { + case NORTH -> BlockVector3.at(0, 0, -1); + case EAST -> BlockVector3.at(1, 0, 0); + case SOUTH -> BlockVector3.at(0, 0, 1); + case WEST -> BlockVector3.at(-1, 0, 0); + case UP -> BlockVector3.at(0, 1, 0); + case DOWN -> BlockVector3.at(0, -1, 0); + case NORTHEAST -> BlockVector3.at(1, 0, -1); + case NORTHWEST -> BlockVector3.at(-1, 0, -1); + case SOUTHEAST -> BlockVector3.at(1, 0, 1); + case SOUTHWEST -> BlockVector3.at(-1, 0, 1); + default -> null; + }; + } +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/utils/ItemUtils.java b/oldSrc/main/java/tools/redstone/redstonetools/utils/ItemUtils.java new file mode 100644 index 00000000..652b9081 --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/utils/ItemUtils.java @@ -0,0 +1,68 @@ +package tools.redstone.redstonetools.utils; + +import net.minecraft.block.BlockState; +import net.minecraft.block.Blocks; +import net.minecraft.client.network.ClientPlayerEntity; +import net.minecraft.entity.player.PlayerEntity; +import net.minecraft.item.*; +import net.minecraft.util.registry.Registry; +import net.minecraft.world.BlockStateRaycastContext; +import net.minecraft.world.RaycastContext; + +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NbtCompound; +import net.minecraft.nbt.NbtList; +import net.minecraft.nbt.NbtString; + +public class ItemUtils { + + private ItemUtils(){ + } + + public static void addExtraNBTText(ItemStack itemStack, String text) { + NbtCompound displayNbt = itemStack.getSubNbt("display"); + NbtList loreList = new NbtList(); + + if (displayNbt == null) { + displayNbt = new NbtCompound(); + } else { + loreList = (NbtList) displayNbt.get("Lore"); + } + String lore = "\"(+"+text +")\""; + + if (loreList != null && !loreList.contains(NbtString.of(lore))) loreList.add(NbtString.of(lore)); + displayNbt.put("Lore", loreList); + itemStack.setSubNbt("display", displayNbt); + } + + public static boolean isEmpty(ItemStack itemStack) { + return itemStack == null || itemStack.getItem() == Items.AIR || itemStack.getCount() == 0; + } + + public static ItemStack getMainItem(PlayerEntity player) { + ItemStack stack = player.getMainHandStack(); + return isEmpty(stack) ? player.getOffHandStack() : stack; + } + + public static BlockState getPlacementState(ClientPlayerEntity player, ItemStack stack, float reach) { + Item type = stack.getItem(); + if (!(type instanceof BlockItem blockItem)) + return null; + return blockItem.getBlock().getPlacementState(new ItemPlacementContext( + player, + player.getActiveHand(), + stack, + RaycastUtils.rayCastFromEye(player, reach) + )); + } + + public static BlockState getUseState(ClientPlayerEntity player, ItemStack stack, float reach) { + if (stack == null || stack.getItem() == Items.AIR) + return null; + BlockState state = getPlacementState(player, stack, reach); + if (state == null) + state = Blocks.BEDROCK.getDefaultState(); + return state; + } + +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/utils/KeyBindingUtils.java b/oldSrc/main/java/tools/redstone/redstonetools/utils/KeyBindingUtils.java new file mode 100644 index 00000000..56e752eb --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/utils/KeyBindingUtils.java @@ -0,0 +1,19 @@ +package tools.redstone.redstonetools.utils; + +import net.minecraft.client.MinecraftClient; +import net.minecraft.client.option.KeyBinding; +import net.minecraft.client.util.InputUtil.Key; +import tools.redstone.redstonetools.macros.KeyBindingMixin; + +public class KeyBindingUtils { + + public static void removeKeyBinding(KeyBinding keyBinding) { + ((KeyBindingMixin)keyBinding).removeKeybinding(keyBinding); + } + + public static boolean isKeyAlreadyBound(Key key) { + KeyBinding foundKeyBinding = ( (KeyBindingMixin)MinecraftClient.getInstance().options.attackKey ).getBindingFromKey(key); + return foundKeyBinding != null; + } + +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/utils/NumberArg.java b/oldSrc/main/java/tools/redstone/redstonetools/utils/NumberArg.java new file mode 100644 index 00000000..130ddfeb --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/utils/NumberArg.java @@ -0,0 +1,62 @@ +package tools.redstone.redstonetools.utils; + +import org.jetbrains.annotations.NotNull; + +import java.math.BigInteger; + +public class NumberArg implements Comparable { + public final BigInteger numValue; + + public final Integer originalBase; + + public NumberArg(String num, int base){ + this.numValue = new BigInteger(num, base); + this.originalBase = base; + } + + public BigInteger getNum(){ + return this.numValue; + } + public Integer getBase(){ + return this.originalBase; + } + + /** + * Returns the number in a string format without a base prefix. + * @return Formatted String + */ + public String toString(){ + return this.toString(this.originalBase); + } + + /** + * Returns the number in a string format converted to another radix and without a base prefix. + * @param radix The Radix to turn use on the number + * @return Formatted String + */ + public String toString(int radix){ + return this.numValue.toString(radix); + } + + /** + * Returns the number in a string format with a base prefix. + * @return Formatted String + */ + public String toPrefixedString(){ + return toPrefixedString(this.originalBase); + } + + /** + * Returns the number in a string format converted to another radix and with a base prefix. + * @param radix The Radix to turn use on the number + * @return Formatted String + */ + public String toPrefixedString(int radix){ + return NumberBase.formatNumber(this.numValue.toString(radix),radix); + } + + @Override + public int compareTo(@NotNull NumberArg o) { + return this.numValue.compareTo(o.numValue); + } +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/utils/NumberBase.java b/oldSrc/main/java/tools/redstone/redstonetools/utils/NumberBase.java new file mode 100644 index 00000000..bb8c57ff --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/utils/NumberBase.java @@ -0,0 +1,101 @@ +package tools.redstone.redstonetools.utils; + +import java.util.Arrays; +import java.util.Optional; + +public enum NumberBase { + BINARY(2,'b'), + OCTAL(8,'o'), + DECIMAL(10,'d'), + HEXADECIMAL(16,'x'); + + private final int base; + + private final char prefixChar; + + NumberBase(int base,char prefixChar) { + this.base = base; + this.prefixChar = prefixChar; + } + + public int toInt() { + return base; + } + + public char getPrefixChar() {return prefixChar;} + + public String getPrefix(){ + return "0" + prefixChar; + } + + @Override + public String toString() { + return super.toString().toLowerCase(); + } + + /** + * Returns an Optional for a NumberBase. Returns empty Optional if not found. + * @param string Search input for the NumberBase + * @return Optional for a NumberBase + */ + public static Optional fromString(String string) { + return Arrays.stream(values()) + .filter(b -> b.toString().equalsIgnoreCase(string)) + .findFirst(); + } + + /** + * Returns an Optional for a NumberBase. Returns empty Optional if not found. + * @param i Search input for the NumberBase + * @return Optional for a NumberBase + */ + public static Optional fromInt(int i) { + return Arrays.stream(values()) + .filter(b -> b.toInt() == i) + .findFirst(); + } + + /** + * Returns an Optional for a NumberBase. Returns empty Optional if not found. + * @param c Search input for the NumberBase + * @return Optional for a NumberBase + */ + public static Optional fromCharacter(char c) { + return Arrays.stream(values()) + .filter(b -> b.getPrefixChar() == c) + .findFirst(); + } + + /** + * Returns an Optional for a NumberBase. Returns empty Optional if not found. + * @param prefix Search input for the NumberBase + * @return Optional for a NumberBase + */ + public static Optional fromPrefix(String prefix) { + return Arrays.stream(values()) + .filter(b -> b.getPrefix().equalsIgnoreCase(prefix)) + .findFirst(); + } + + /** + * Returns a formatted String that includes the base and the number prefix together + * @param num Number to be formatted + * @param base Base to be paired with the number + * @return Formatted String + */ + public static String formatNumber(String num, int base) { + String negsign = ""; + if(Integer.parseInt(num,base) < 0){ + num = num.substring(1); + negsign = "-"; + } + num = num.toUpperCase(); + return negsign + switch (base) { + case 2 -> "0b" + num; + case 8 -> "0o" + num; + case 10 -> "0d" + num; + case 16 -> "0x" + num; + default -> num + "_" + base; + }; + } +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/utils/PositionUtils.java b/oldSrc/main/java/tools/redstone/redstonetools/utils/PositionUtils.java new file mode 100644 index 00000000..9f57a527 --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/utils/PositionUtils.java @@ -0,0 +1,13 @@ +package tools.redstone.redstonetools.utils; + +import net.minecraft.util.math.BlockPos; +import net.minecraft.util.math.Vec3d; + +public class PositionUtils { + private PositionUtils() { + } + + public static Vec3d getBottomPositionOfBlock(BlockPos position) { + return Vec3d.ofCenter(position).subtract(0, 0.5, 0); + } +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/utils/RaycastUtils.java b/oldSrc/main/java/tools/redstone/redstonetools/utils/RaycastUtils.java new file mode 100644 index 00000000..abaf26a2 --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/utils/RaycastUtils.java @@ -0,0 +1,28 @@ +package tools.redstone.redstonetools.utils; + +import net.minecraft.entity.player.PlayerEntity; +import net.minecraft.util.hit.BlockHitResult; +import net.minecraft.world.RaycastContext; + +public class RaycastUtils { + private RaycastUtils() { + } + + public static BlockHitResult getBlockHitNeighbor(BlockHitResult hit) { + var sideOffset = hit.getSide().getUnitVector(); + + var newBlockPos = hit.getBlockPos().add(sideOffset.getX(), sideOffset.getY(), sideOffset.getZ()); + + return hit.withBlockPos(newBlockPos); + } + + public static BlockHitResult rayCastFromEye(PlayerEntity player, float reach) { + return player.getWorld().raycast(new RaycastContext( + player.getEyePos(), + player.getEyePos().add(player.getRotationVector().multiply(reach)), + RaycastContext.ShapeType.COLLIDER, + RaycastContext.FluidHandling.NONE, + player + )); + } +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/utils/RedstoneUtils.java b/oldSrc/main/java/tools/redstone/redstonetools/utils/RedstoneUtils.java new file mode 100644 index 00000000..bc4dc74d --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/utils/RedstoneUtils.java @@ -0,0 +1,12 @@ +package tools.redstone.redstonetools.utils; + +public class RedstoneUtils { + private RedstoneUtils() { + + } + + public static int signalStrengthToNonStackableItemCount(int signalStrength, int containerSlots) { + // Formula copied from https://minecraft.fandom.com/wiki/Redstone_Comparator + return Math.max(signalStrength, (int) Math.ceil((containerSlots / 14.0) * (signalStrength - 1))); + } +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/utils/ReflectionUtils.java b/oldSrc/main/java/tools/redstone/redstonetools/utils/ReflectionUtils.java new file mode 100644 index 00000000..e80d7ceb --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/utils/ReflectionUtils.java @@ -0,0 +1,153 @@ +package tools.redstone.redstonetools.utils; + +import org.apache.commons.io.IOUtils; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; +import org.jetbrains.annotations.Nullable; +import rip.hippo.inject.DoctorModule; +import sun.misc.Unsafe; +import tools.redstone.redstonetools.features.AbstractFeature; +import tools.redstone.redstonetools.features.Feature; +import tools.redstone.redstonetools.features.arguments.Argument; + +import java.lang.invoke.MethodHandles; +import java.lang.reflect.Field; +import java.io.IOException; +import java.lang.reflect.Modifier; +import java.net.URL; +import java.util.*; +import java.util.stream.Collectors; + +public class ReflectionUtils { + private static final Logger LOGGER = LogManager.getLogger(); + private static DoctorModule[] modules; + private static Set features; + + private ReflectionUtils() { + throw new IllegalStateException("Utility class"); + } + + private static final MethodHandles.Lookup INTERNAL_LOOKUP; + private static final Unsafe unsafe; + + static { + try { + Field f = Unsafe.class.getDeclaredField("theUnsafe"); + f.setAccessible(true); + unsafe = (Unsafe) f.get(null); + } catch (Throwable t) { + t.printStackTrace(); + throw new ExceptionInInitializerError(t); + } + + try { + // get lookup + Field field = MethodHandles.Lookup.class.getDeclaredField("IMPL_LOOKUP"); + MethodHandles.publicLookup(); + INTERNAL_LOOKUP = (MethodHandles.Lookup) + unsafe.getObject( + unsafe.staticFieldBase(field), + unsafe.staticFieldOffset(field) + ); + } catch (Exception e) { + e.printStackTrace(); + throw new ExceptionInInitializerError(e); + } + } + + public static MethodHandles.Lookup getInternalLookup() { + return INTERNAL_LOOKUP; + } + + public static DoctorModule[] getModules() { + if (modules == null) { + try { + modules = serviceLoad(DoctorModule.class) + .toArray(DoctorModule[]::new); + } catch (IOException e) { + throw new RuntimeException("Failed to load modules", e); + } + } + return modules; + } + + public static Set getFeatures() { + if (features == null) { + try { + features = serviceLoad(AbstractFeature.class); + } catch (IOException e) { + throw new RuntimeException("Failed to load features", e); + } + } + return features; + } + + private static Set serviceLoad(Class clazz) throws IOException { + ClassLoader cl = ReflectionUtils.class.getClassLoader(); + Enumeration serviceFiles = cl.getResources("META-INF/services/" + clazz.getName()); + Set classNames = new HashSet<>(); + while (serviceFiles.hasMoreElements()) { + URL serviceFile = serviceFiles.nextElement(); + try (var reader = serviceFile.openStream()) { + classNames.addAll(IOUtils.readLines(reader, "UTF-8")); + } + } + return classNames.stream() + .filter(it -> !it.isEmpty() && !it.isBlank()) + .map(ReflectionUtils::loadClass) + .filter(Objects::nonNull) + .filter(clazz::isAssignableFrom) + .map(it -> { + try { + return it.getDeclaredConstructor().newInstance(); + } catch (ReflectiveOperationException e) { + throw new RuntimeException("Failed to instantiate " + it, e); + } + }) + .map(clazz::cast) + .collect(Collectors.toSet()); + } + + @SuppressWarnings("unchecked") + private static @Nullable Class loadClass(String className) { + try { + return (Class) Class.forName(className); + } catch (ClassNotFoundException e) { + throw new RuntimeException("Failed to load class " + className, e); + } catch (NoClassDefFoundError e) { + LOGGER.warn("Failed to load class {}, required {}", className, e.getMessage()); + } + return null; + } + + public static List> getArguments(Class featureClass) { + return Arrays.stream(featureClass.getFields()) + .filter(field -> Argument.class.isAssignableFrom(field.getType())) + .map(field -> { + if (!Modifier.isPublic(field.getModifiers()) + || !Modifier.isStatic(field.getModifiers()) + || !Modifier.isFinal(field.getModifiers())) { + throw new RuntimeException("Field " + field.getName() + " of feature " + featureClass.getName() + " is not public static final"); + } + + try { + var argument = (Argument) field.get(null); + + return argument.ensureNamed(field.getName()); + } catch (IllegalAccessException e) { + throw new RuntimeException("Failed to get value of field " + field.getName(), e); + } + }) + .collect(Collectors.toList()); + } + + public static Feature getFeatureInfo(Class featureClass) { + var feature = featureClass.getAnnotation(Feature.class); + + if (feature == null) { + throw new RuntimeException("No feature annotation found for feature " + featureClass.getName()); + } + + return feature; + } +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/utils/SignalBlock.java b/oldSrc/main/java/tools/redstone/redstonetools/utils/SignalBlock.java new file mode 100644 index 00000000..aa83bc12 --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/utils/SignalBlock.java @@ -0,0 +1,48 @@ +package tools.redstone.redstonetools.utils; + +import net.minecraft.block.Block; +import net.minecraft.block.Blocks; +import net.minecraft.item.ItemStack; + +public enum SignalBlock { + COMPOSTER(Blocks.COMPOSTER, SignalBlockSupplier.composter()), + BARREL(Blocks.BARREL, SignalBlockSupplier.container(27)), + CHEST(Blocks.CHEST, SignalBlockSupplier.container(27)), + SHULKER_BOX(Blocks.SHULKER_BOX, SignalBlockSupplier.container(27)), + DISPENSER(Blocks.DISPENSER, SignalBlockSupplier.container(9)), + DROPPER(Blocks.DROPPER, SignalBlockSupplier.container(9)), + HOPPER(Blocks.HOPPER, SignalBlockSupplier.container(5)), + BREWING_STAND(Blocks.BREWING_STAND, SignalBlockSupplier.container(5)), + FURNACE(Blocks.FURNACE, SignalBlockSupplier.container(3)), + SMOKER(Blocks.SMOKER, SignalBlockSupplier.container(3)), + BLAST_FURNACE(Blocks.BLAST_FURNACE, SignalBlockSupplier.container(3)), + COMMAND_BLOCK(Blocks.COMMAND_BLOCK, SignalBlockSupplier.commandBlock()), + AUTO(null, null); + + private final Block block; + private final SignalBlockSupplier supplier; + + SignalBlock(Block block, SignalBlockSupplier supplier) { + this.block = block; + this.supplier = supplier; + } + + public static SignalBlock getBestBlock(int signal) { + return signal < 1780 + ? BARREL + : COMMAND_BLOCK; + } + + public ItemStack getItemStack(int signal) { + if (block == null || supplier == null) + return getBestBlock(signal).getItemStack(signal); + + return supplier.getItemStack(block, signal); + } + + @Override + public String toString() { + return this.name().toLowerCase(); + } + +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/utils/SignalBlockSupplier.java b/oldSrc/main/java/tools/redstone/redstonetools/utils/SignalBlockSupplier.java new file mode 100644 index 00000000..0b0d2558 --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/utils/SignalBlockSupplier.java @@ -0,0 +1,131 @@ +package tools.redstone.redstonetools.utils; + +import net.minecraft.block.Block; +import net.minecraft.enchantment.Enchantment; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.item.Items; +import net.minecraft.nbt.NbtCompound; +import net.minecraft.nbt.NbtList; +import net.minecraft.text.LiteralText; +import net.minecraft.text.MutableText; +import net.minecraft.util.Formatting; +import net.minecraft.util.math.MathHelper; +import net.minecraft.util.registry.Registry; + +@FunctionalInterface +public interface SignalBlockSupplier { + + NbtCompound createNbt(int signalStrength); + + default ItemStack getItemStack(Block block, int signalStrength) { + ItemStack item = new ItemStack(block); + setCompoundNbt(item, this.createNbt(signalStrength)); + setItemName(item, signalStrength); + return item; + } + + static SignalBlockSupplier container(int slots) { + return signalStrength -> { + if (isInvalidSignalStrength(signalStrength, 1779)) + throw new IllegalArgumentException("Container signal must be 0-1779"); + + NbtCompound tags = new NbtCompound(); + NbtList itemsTag = new NbtList(); + + Item item = getBestItem(signalStrength, slots); + int stackSize = getStackSize(signalStrength, item); + int itemsNeeded = Math.max(0, signalStrength == 1 + ? 1 + : (int) Math.ceil(slots * (signalStrength - 1) / 14D * item.getMaxCount())); + String itemId = Registry.ITEM.getId(item).toString(); + + // Check that the calculated number of items is correct. + // This is to prevent problems with items that have a maximum stack size of 1 but stackSize > 1. + // TODO: This can be improved by removing an item and adding stackable items up to the desired signal strength. + // Even with the improvement, this will still fail for inventories with no available slots. + if (calculateComparatorOutput(itemsNeeded, slots, item.getMaxCount()) != signalStrength) + throw new IllegalStateException("This signal strength cannot be achieved with the selected container"); + + for (int slot = 0, count = itemsNeeded; count > 0; slot++, count -= stackSize) { + NbtCompound slotTag = new NbtCompound(); + slotTag.putByte("Slot", (byte) slot); + slotTag.putString("id", itemId); + slotTag.putByte("Count", (byte) Math.min(stackSize, count)); + itemsTag.add(slotTag); + } + + NbtCompound tag = new NbtCompound(); + tag.put("Items", itemsTag); + tags.put("BlockEntityTag", tag); + + return tags; + }; + } + + static SignalBlockSupplier composter() { + return signalStrength -> { + if (signalStrength == 7 || isInvalidSignalStrength(signalStrength, 8)) + throw new IllegalArgumentException("Composter signal must be 0-6 or 8"); + + NbtCompound tags = new NbtCompound(); + NbtCompound tag = new NbtCompound(); + tag.putInt("level", signalStrength); + tags.put("BlockStateTag", tag); + return tags; + }; + } + + static SignalBlockSupplier commandBlock() { + return signalStrength -> { + if (isInvalidSignalStrength(signalStrength, Integer.MAX_VALUE)) + throw new IllegalArgumentException("Command block signal must be positive"); + + NbtCompound tags = new NbtCompound(); + NbtCompound tag = new NbtCompound(); + tag.putInt("SuccessCount", signalStrength); + tags.put("BlockEntityTag", tag); + return tags; + }; + } + + private static boolean isInvalidSignalStrength(int signalStrength, int maxSignalStrength) { + return signalStrength < 0 || signalStrength > maxSignalStrength; + } + + private static int calculateComparatorOutput(int items, int slots, int item$getMaxCount) { + float f = (float) items / (float) item$getMaxCount; + return MathHelper.floor((f /= (float)slots) * 14.0f) + (items > 0 ? 1 : 0); + } + + private static Item getBestItem(int signalStrength, int slots) { + if (signalStrength > 15) + return Items.WHITE_SHULKER_BOX; + else if (slots >= 15) + return Items.WOODEN_SHOVEL; + else + return Items.STICK; + } + + private static int getStackSize(int signalStrength, Item item) { + if (signalStrength > 897) + return 127; + else if (signalStrength > 15) + return 64; + else + return item.getMaxCount(); + } + + private static void setCompoundNbt(ItemStack item, NbtCompound nbt) { + nbt.putBoolean("HideFlags", true); + item.setNbt(nbt); + item.addEnchantment(Enchantment.byRawId(0), 0); + } + + private static void setItemName(ItemStack item, int signalStrength) { + MutableText text = new LiteralText(String.valueOf(signalStrength)); + text.setStyle(text.getStyle().withColor(Formatting.RED)); + item.setCustomName(text); + } + +} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/utils/WorldEditUtils.java b/oldSrc/main/java/tools/redstone/redstonetools/utils/WorldEditUtils.java new file mode 100644 index 00000000..29e8ece7 --- /dev/null +++ b/oldSrc/main/java/tools/redstone/redstonetools/utils/WorldEditUtils.java @@ -0,0 +1,69 @@ +package tools.redstone.redstonetools.utils; + +import tools.redstone.redstonetools.features.feedback.Feedback; +import com.mojang.datafixers.util.Either; +import com.sk89q.worldedit.IncompleteRegionException; +import com.sk89q.worldedit.WorldEdit; +import com.sk89q.worldedit.fabric.FabricAdapter; +import com.sk89q.worldedit.math.BlockVector3; +import com.sk89q.worldedit.regions.CuboidRegion; +import com.sk89q.worldedit.regions.Region; +import net.minecraft.server.network.ServerPlayerEntity; + +import java.util.function.Consumer; + +public class WorldEditUtils { + /** + * Execute a function for each block in + * the provided region. + * + * Iterates the bounding box of the region + * and checks if the position is contained + * for each block. + * + * TODO: maybe make an async version of this somehow + * + * @param region The region. + * @param consumer The function to run. + */ + public static void forEachBlockInRegion(Region region, + Consumer consumer) { + if (!DependencyLookup.WORLDEDIT_PRESENT) { + throw new IllegalStateException("WorldEdit is not loaded."); + } + + CuboidRegion bb = region.getBoundingBox(); + BlockVector3 min = bb.getMinimumPoint(); + BlockVector3 max = bb.getMaximumPoint(); + for (int x = min.getBlockX(); x <= max.getBlockX(); x++) { + for (int y = min.getBlockY(); y <= max.getBlockY(); y++) { + for (int z = min.getBlockZ(); z <= max.getBlockZ(); z++) { + BlockVector3 vec = BlockVector3.at(x, y, z); + if (!region.contains(vec)) + continue; + consumer.accept(vec); + } + } + } + } + + public static Either getSelection(ServerPlayerEntity player) { + if (!DependencyLookup.WORLDEDIT_PRESENT) { + throw new IllegalStateException("WorldEdit is not loaded."); + } + + var actor = FabricAdapter.adaptPlayer(player); + + var localSession = WorldEdit.getInstance() + .getSessionManager() + .get(actor); + + var selectionWorld = localSession.getSelectionWorld(); + + try { + return Either.left(localSession.getSelection(selectionWorld)); + } catch (IncompleteRegionException ex) { + return Either.right(Feedback.invalidUsage("Please make a selection with WorldEdit first")); + } + } +} diff --git a/src/main/resources/assets/redstonetools/gui/cross.png b/oldSrc/main/resources/assets/redstonetools/gui/cross.png similarity index 100% rename from src/main/resources/assets/redstonetools/gui/cross.png rename to oldSrc/main/resources/assets/redstonetools/gui/cross.png diff --git a/src/main/resources/assets/redstonetools/gui/pencil.png b/oldSrc/main/resources/assets/redstonetools/gui/pencil.png similarity index 100% rename from src/main/resources/assets/redstonetools/gui/pencil.png rename to oldSrc/main/resources/assets/redstonetools/gui/pencil.png diff --git a/src/main/resources/assets/redstonetools/icon.png b/oldSrc/main/resources/assets/redstonetools/icon.png similarity index 100% rename from src/main/resources/assets/redstonetools/icon.png rename to oldSrc/main/resources/assets/redstonetools/icon.png diff --git a/src/main/resources/assets/redstonetools/lang/en_au.json b/oldSrc/main/resources/assets/redstonetools/lang/en_au.json similarity index 100% rename from src/main/resources/assets/redstonetools/lang/en_au.json rename to oldSrc/main/resources/assets/redstonetools/lang/en_au.json diff --git a/src/main/resources/assets/redstonetools/lang/en_ca.json b/oldSrc/main/resources/assets/redstonetools/lang/en_ca.json similarity index 100% rename from src/main/resources/assets/redstonetools/lang/en_ca.json rename to oldSrc/main/resources/assets/redstonetools/lang/en_ca.json diff --git a/src/main/resources/assets/redstonetools/lang/en_gb.json b/oldSrc/main/resources/assets/redstonetools/lang/en_gb.json similarity index 100% rename from src/main/resources/assets/redstonetools/lang/en_gb.json rename to oldSrc/main/resources/assets/redstonetools/lang/en_gb.json diff --git a/src/main/resources/assets/redstonetools/lang/en_nz.json b/oldSrc/main/resources/assets/redstonetools/lang/en_nz.json similarity index 100% rename from src/main/resources/assets/redstonetools/lang/en_nz.json rename to oldSrc/main/resources/assets/redstonetools/lang/en_nz.json diff --git a/src/main/resources/assets/redstonetools/lang/en_us.json b/oldSrc/main/resources/assets/redstonetools/lang/en_us.json similarity index 100% rename from src/main/resources/assets/redstonetools/lang/en_us.json rename to oldSrc/main/resources/assets/redstonetools/lang/en_us.json diff --git a/src/main/resources/fabric.mod.json b/oldSrc/main/resources/fabric.mod.json similarity index 93% rename from src/main/resources/fabric.mod.json rename to oldSrc/main/resources/fabric.mod.json index 740381b0..03be2633 100644 --- a/src/main/resources/fabric.mod.json +++ b/oldSrc/main/resources/fabric.mod.json @@ -32,9 +32,9 @@ ], "depends": { - "fabricloader": ">=0.13.0", + "fabricloader": ">=0.15.0", "fabric": "*", - "minecraft": "~1.18.2", + "minecraft": "~1.20.4", "java": ">=17" }, "recommends": { diff --git a/src/main/resources/redstonetools.mixins.json b/oldSrc/main/resources/redstonetools.mixins.json similarity index 100% rename from src/main/resources/redstonetools.mixins.json rename to oldSrc/main/resources/redstonetools.mixins.json diff --git a/src/main/java/tools/redstone/redstonetools/di/FeatureModule.java b/src/main/java/tools/redstone/redstonetools/di/FeatureModule.java index 505e2179..9c866c57 100644 --- a/src/main/java/tools/redstone/redstonetools/di/FeatureModule.java +++ b/src/main/java/tools/redstone/redstonetools/di/FeatureModule.java @@ -3,6 +3,7 @@ import com.google.auto.service.AutoService; import rip.hippo.inject.DoctorModule; import rip.hippo.inject.binding.Binder; +import tools.redstone.redstonetools.features.AbstractFeature; import tools.redstone.redstonetools.utils.ReflectionUtils; @AutoService(DoctorModule.class) diff --git a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/BlockStateArgumentSerializer.java b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/BlockStateArgumentSerializer.java index 705bebac..a211c650 100644 --- a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/BlockStateArgumentSerializer.java +++ b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/BlockStateArgumentSerializer.java @@ -1,10 +1,14 @@ package tools.redstone.redstonetools.features.arguments.serializers; +import Z; import com.mojang.brigadier.StringReader; import com.mojang.brigadier.exceptions.CommandSyntaxException; +import net.minecraft.block.Block; +import net.minecraft.block.BlockState; import net.minecraft.command.argument.BlockStateArgument; import net.minecraft.command.argument.BlockStateArgumentType; -import net.minecraft.util.registry.Registry; +import net.minecraft.registry.Registry; +import net.minecraft.state.property.Property; public class BlockStateArgumentSerializer extends BrigadierSerializer { diff --git a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/EnumSerializer.java b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/EnumSerializer.java index be6d2e92..af7d354a 100644 --- a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/EnumSerializer.java +++ b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/EnumSerializer.java @@ -9,6 +9,8 @@ import java.util.Collection; import java.util.EnumSet; +import java.util.List; +import java.util.Optional; import java.util.concurrent.CompletableFuture; public abstract class EnumSerializer> diff --git a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/IntLikeSerializer.java b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/IntLikeSerializer.java index 0cfc6974..5619d8a5 100644 --- a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/IntLikeSerializer.java +++ b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/IntLikeSerializer.java @@ -1,5 +1,6 @@ package tools.redstone.redstonetools.features.arguments.serializers; +import ; import com.mojang.brigadier.StringReader; import com.mojang.brigadier.context.CommandContext; import com.mojang.brigadier.exceptions.CommandSyntaxException; diff --git a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/MacroNameSerializer.java b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/MacroNameSerializer.java index 2d4c697c..8f9ce185 100644 --- a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/MacroNameSerializer.java +++ b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/MacroNameSerializer.java @@ -1,5 +1,6 @@ package tools.redstone.redstonetools.features.arguments.serializers; +import tools.redstone.redstonetools.macros.Macro; import tools.redstone.redstonetools.macros.MacroManager; import com.mojang.brigadier.context.CommandContext; import com.mojang.brigadier.suggestion.Suggestions; diff --git a/src/main/java/tools/redstone/redstonetools/features/commands/BinaryBlockReadFeature.java b/src/main/java/tools/redstone/redstonetools/features/commands/BinaryBlockReadFeature.java index 808f5d10..4d324c13 100644 --- a/src/main/java/tools/redstone/redstonetools/features/commands/BinaryBlockReadFeature.java +++ b/src/main/java/tools/redstone/redstonetools/features/commands/BinaryBlockReadFeature.java @@ -7,11 +7,16 @@ import tools.redstone.redstonetools.features.feedback.Feedback; import tools.redstone.redstonetools.utils.WorldEditUtils; import com.mojang.brigadier.exceptions.CommandSyntaxException; +import com.mojang.datafixers.util.Either; import com.sk89q.worldedit.math.BlockVector3; +import com.sk89q.worldedit.regions.CuboidRegion; +import com.sk89q.worldedit.regions.Region; +import net.minecraft.block.BlockState; import net.minecraft.block.Blocks; import net.minecraft.block.RedstoneLampBlock; import net.minecraft.command.argument.BlockStateArgument; import net.minecraft.server.command.ServerCommandSource; +import net.minecraft.state.property.Property; import net.minecraft.util.math.BlockPos; import java.util.Collections; @@ -21,6 +26,8 @@ import static tools.redstone.redstonetools.features.arguments.serializers.IntegerSerializer.integer; import static tools.redstone.redstonetools.features.arguments.serializers.NumberBaseSerializer.numberBase; +import Z; + @AutoService(AbstractFeature.class) @Feature(name = "Binary Block Read", description = "Interprets your WorldEdit selection as a binary number.", command = "/read", worldedit = true) public class BinaryBlockReadFeature extends CommandFeature { @@ -45,7 +52,7 @@ public class BinaryBlockReadFeature extends CommandFeature { @Override protected Feedback execute(ServerCommandSource source) throws CommandSyntaxException { - var selectionOrFeedback = WorldEditUtils.getSelection(source.getPlayer()); + var selectionOrFeedback = WorldEditUtils.getSelection(source.getPlayerOrThrow()); if (selectionOrFeedback.right().isPresent()) { return selectionOrFeedback.right().get(); diff --git a/src/main/java/tools/redstone/redstonetools/features/commands/BlockRaycastFeature.java b/src/main/java/tools/redstone/redstonetools/features/commands/BlockRaycastFeature.java index d8c1b842..cb378d80 100644 --- a/src/main/java/tools/redstone/redstonetools/features/commands/BlockRaycastFeature.java +++ b/src/main/java/tools/redstone/redstonetools/features/commands/BlockRaycastFeature.java @@ -3,12 +3,15 @@ import tools.redstone.redstonetools.features.feedback.Feedback; import tools.redstone.redstonetools.utils.BlockInfo; import com.mojang.brigadier.exceptions.CommandSyntaxException; +import net.minecraft.block.Block; +import net.minecraft.block.BlockState; +import net.minecraft.block.entity.BlockEntity; import net.minecraft.client.MinecraftClient; import net.minecraft.server.command.ServerCommandSource; import net.minecraft.text.Text; import net.minecraft.util.hit.BlockHitResult; import net.minecraft.util.hit.HitResult; - +import net.minecraft.util.math.BlockPos; import javax.annotation.Nullable; public abstract class BlockRaycastFeature extends CommandFeature { diff --git a/src/main/java/tools/redstone/redstonetools/features/commands/ColorCodeFeature.java b/src/main/java/tools/redstone/redstonetools/features/commands/ColorCodeFeature.java index 00742feb..cbef6849 100644 --- a/src/main/java/tools/redstone/redstonetools/features/commands/ColorCodeFeature.java +++ b/src/main/java/tools/redstone/redstonetools/features/commands/ColorCodeFeature.java @@ -9,17 +9,23 @@ import tools.redstone.redstonetools.utils.ColoredBlock; import tools.redstone.redstonetools.utils.WorldEditUtils; import com.mojang.brigadier.exceptions.CommandSyntaxException; +import com.mojang.datafixers.util.Either; import com.sk89q.worldedit.EditSession; +import com.sk89q.worldedit.LocalSession; import com.sk89q.worldedit.WorldEdit; import com.sk89q.worldedit.fabric.FabricAdapter; +import com.sk89q.worldedit.fabric.FabricPlayer; import com.sk89q.worldedit.function.mask.Mask; import com.sk89q.worldedit.function.mask.Mask2D; import com.sk89q.worldedit.function.operation.Operations; import com.sk89q.worldedit.math.BlockVector3; +import com.sk89q.worldedit.regions.Region; import com.sk89q.worldedit.world.World; import com.sk89q.worldedit.world.block.BaseBlock; +import com.sk89q.worldedit.world.block.BlockState; import com.sk89q.worldedit.world.block.BlockType; import net.minecraft.server.command.ServerCommandSource; +import net.minecraft.server.network.ServerPlayerEntity; import org.jetbrains.annotations.Nullable; import static tools.redstone.redstonetools.features.arguments.serializers.BlockColorSerializer.blockColor; @@ -60,7 +66,7 @@ private BaseBlock getColoredBlock(World world, BlockVector3 pos, BlockColor colo @Override protected Feedback execute(ServerCommandSource source) throws CommandSyntaxException { - var player = source.getPlayer(); + var player = source.getPlayerOrThrow(); var selectionOrFeedback = WorldEditUtils.getSelection(player); if (selectionOrFeedback.right().isPresent()) { @@ -75,8 +81,8 @@ protected Feedback execute(ServerCommandSource source) throws CommandSyntaxExcep var playerSession = worldEdit.getSessionManager().get(wePlayer); // for each block in the selection - final World world = FabricAdapter.adapt(player.getWorld()); - try (EditSession session = worldEdit.newEditSession(FabricAdapter.adapt(player.getWorld()))) { + final World world = FabricAdapter.adapt(player.method_48926()); + try (EditSession session = worldEdit.newEditSession(FabricAdapter.adapt(player.method_48926()))) { // create mask and pattern and execute block set int blocksColored = session.replaceBlocks(selection, new Mask() { diff --git a/src/main/java/tools/redstone/redstonetools/features/commands/ColoredFeature.java b/src/main/java/tools/redstone/redstonetools/features/commands/ColoredFeature.java index d7505c29..efc4f347 100644 --- a/src/main/java/tools/redstone/redstonetools/features/commands/ColoredFeature.java +++ b/src/main/java/tools/redstone/redstonetools/features/commands/ColoredFeature.java @@ -7,6 +7,7 @@ import tools.redstone.redstonetools.features.feedback.Feedback; import tools.redstone.redstonetools.utils.BlockColor; import tools.redstone.redstonetools.utils.BlockInfo; +import tools.redstone.redstonetools.utils.ColoredBlock; import com.mojang.datafixers.util.Either; import net.minecraft.item.ItemStack; import net.minecraft.server.command.ServerCommandSource; diff --git a/src/main/java/tools/redstone/redstonetools/features/commands/CommandFeature.java b/src/main/java/tools/redstone/redstonetools/features/commands/CommandFeature.java index cc5f9412..af19cb21 100644 --- a/src/main/java/tools/redstone/redstonetools/features/commands/CommandFeature.java +++ b/src/main/java/tools/redstone/redstonetools/features/commands/CommandFeature.java @@ -5,6 +5,8 @@ import net.minecraft.client.option.KeyBinding; import net.minecraft.client.util.InputUtil; import tools.redstone.redstonetools.features.AbstractFeature; +import tools.redstone.redstonetools.features.Feature; +import tools.redstone.redstonetools.features.arguments.Argument; import tools.redstone.redstonetools.features.feedback.AbstractFeedbackSender; import tools.redstone.redstonetools.features.feedback.Feedback; import tools.redstone.redstonetools.utils.CommandUtils; @@ -18,6 +20,8 @@ import static tools.redstone.redstonetools.RedstoneToolsClient.INJECTOR; +import Z; + public abstract class CommandFeature extends AbstractFeature { private static final List keyBindings = new ArrayList<>(); diff --git a/src/main/java/tools/redstone/redstonetools/features/commands/ItemBindFeature.java b/src/main/java/tools/redstone/redstonetools/features/commands/ItemBindFeature.java index 4403353b..4c91177d 100644 --- a/src/main/java/tools/redstone/redstonetools/features/commands/ItemBindFeature.java +++ b/src/main/java/tools/redstone/redstonetools/features/commands/ItemBindFeature.java @@ -24,7 +24,7 @@ public class ItemBindFeature extends CommandFeature{ @Override protected Feedback execute(ServerCommandSource source) throws CommandSyntaxException { - player = source.getPlayer(); + player = source.getPlayerOrThrow(); waitingForCommand = true; return Feedback.success("Please run any command and hold the item you want the command be bound to"); diff --git a/src/main/java/tools/redstone/redstonetools/features/commands/MacroFeature.java b/src/main/java/tools/redstone/redstonetools/features/commands/MacroFeature.java index 6afa69ba..b449aa82 100644 --- a/src/main/java/tools/redstone/redstonetools/features/commands/MacroFeature.java +++ b/src/main/java/tools/redstone/redstonetools/features/commands/MacroFeature.java @@ -5,6 +5,7 @@ import tools.redstone.redstonetools.features.Feature; import tools.redstone.redstonetools.features.arguments.Argument; import tools.redstone.redstonetools.features.feedback.Feedback; +import tools.redstone.redstonetools.macros.Macro; import tools.redstone.redstonetools.macros.MacroManager; import com.mojang.brigadier.exceptions.CommandSyntaxException; import net.minecraft.server.command.ServerCommandSource; diff --git a/src/main/java/tools/redstone/redstonetools/features/commands/MinSelectionFeature.java b/src/main/java/tools/redstone/redstonetools/features/commands/MinSelectionFeature.java index 388da842..b97f7acf 100644 --- a/src/main/java/tools/redstone/redstonetools/features/commands/MinSelectionFeature.java +++ b/src/main/java/tools/redstone/redstonetools/features/commands/MinSelectionFeature.java @@ -1,17 +1,23 @@ package tools.redstone.redstonetools.features.commands; +import Z; import com.google.auto.service.AutoService; import tools.redstone.redstonetools.features.AbstractFeature; import tools.redstone.redstonetools.features.Feature; import tools.redstone.redstonetools.features.feedback.Feedback; import tools.redstone.redstonetools.utils.WorldEditUtils; import com.mojang.brigadier.exceptions.CommandSyntaxException; +import com.mojang.datafixers.util.Either; +import com.sk89q.worldedit.LocalSession; import com.sk89q.worldedit.WorldEdit; import com.sk89q.worldedit.fabric.FabricAdapter; +import com.sk89q.worldedit.fabric.FabricPlayer; import com.sk89q.worldedit.math.BlockVector3; +import com.sk89q.worldedit.math.Vector3; import com.sk89q.worldedit.regions.CuboidRegion; import com.sk89q.worldedit.regions.Region; import com.sk89q.worldedit.regions.RegionOperationException; +import com.sk89q.worldedit.regions.RegionSelector; import com.sk89q.worldedit.world.World; import com.sk89q.worldedit.world.block.BlockTypes; import net.minecraft.server.command.ServerCommandSource; @@ -26,7 +32,7 @@ public class MinSelectionFeature extends CommandFeature { @Override protected Feedback execute(ServerCommandSource source) throws CommandSyntaxException { - var selectionOrFeedback = WorldEditUtils.getSelection(source.getPlayer()); + var selectionOrFeedback = WorldEditUtils.getSelection(source.getPlayerOrThrow()); if (selectionOrFeedback.right().isPresent()) { return selectionOrFeedback.right().get(); } @@ -35,7 +41,7 @@ protected Feedback execute(ServerCommandSource source) throws CommandSyntaxExcep var selection = selectionOrFeedback.left().get(); var selectionWorld = selection.getWorld(); - var actor = FabricAdapter.adaptPlayer(source.getPlayer()); + var actor = FabricAdapter.adaptPlayer(source.getPlayerOrThrow()); var localSession = WorldEdit.getInstance() .getSessionManager() diff --git a/src/main/java/tools/redstone/redstonetools/features/commands/QuickTpFeature.java b/src/main/java/tools/redstone/redstonetools/features/commands/QuickTpFeature.java index dc3a6593..a0d9ef9f 100644 --- a/src/main/java/tools/redstone/redstonetools/features/commands/QuickTpFeature.java +++ b/src/main/java/tools/redstone/redstonetools/features/commands/QuickTpFeature.java @@ -10,12 +10,16 @@ import com.mojang.brigadier.exceptions.CommandSyntaxException; import net.minecraft.entity.player.PlayerEntity; import net.minecraft.server.command.ServerCommandSource; +import net.minecraft.server.network.ServerPlayerEntity; import net.minecraft.util.hit.BlockHitResult; import net.minecraft.util.hit.HitResult; +import net.minecraft.util.math.BlockPos; import net.minecraft.util.math.Vec3d; import static tools.redstone.redstonetools.features.arguments.serializers.BoolSerializer.bool; import static tools.redstone.redstonetools.features.arguments.serializers.FloatSerializer.floatArg; +import D; + @AutoService(AbstractFeature.class) @Feature(name = "Quick TP", description = "Teleports you in the direction you are looking.", command = "quicktp") public class QuickTpFeature extends CommandFeature { @@ -28,7 +32,7 @@ public class QuickTpFeature extends CommandFeature { @Override protected Feedback execute(ServerCommandSource source) throws CommandSyntaxException { - var player = source.getPlayer(); + var player = source.getPlayerOrThrow(); var targetPosition = getTargetPosition(player); diff --git a/src/main/java/tools/redstone/redstonetools/features/commands/RStackFeature.java b/src/main/java/tools/redstone/redstonetools/features/commands/RStackFeature.java index d06452a5..f92d302a 100644 --- a/src/main/java/tools/redstone/redstonetools/features/commands/RStackFeature.java +++ b/src/main/java/tools/redstone/redstonetools/features/commands/RStackFeature.java @@ -7,16 +7,21 @@ import tools.redstone.redstonetools.features.feedback.Feedback; import tools.redstone.redstonetools.utils.DirectionArgument; import com.mojang.brigadier.exceptions.CommandSyntaxException; +import com.sk89q.worldedit.EditSession; import com.sk89q.worldedit.IncompleteRegionException; +import com.sk89q.worldedit.LocalSession; import com.sk89q.worldedit.WorldEdit; import com.sk89q.worldedit.WorldEditException; import com.sk89q.worldedit.fabric.FabricAdapter; +import com.sk89q.worldedit.fabric.FabricPlayer; import com.sk89q.worldedit.function.mask.Mask; import com.sk89q.worldedit.function.mask.Mask2D; import com.sk89q.worldedit.function.operation.ForwardExtentCopy; import com.sk89q.worldedit.function.operation.Operations; import com.sk89q.worldedit.math.BlockVector3; import com.sk89q.worldedit.regions.Region; +import com.sk89q.worldedit.util.Direction; +import com.sk89q.worldedit.world.World; import net.minecraft.server.command.ServerCommandSource; import org.jetbrains.annotations.Nullable; @@ -25,6 +30,8 @@ import static tools.redstone.redstonetools.utils.DirectionUtils.directionToBlock; import static tools.redstone.redstonetools.utils.DirectionUtils.matchDirection; +import I; + @AutoService(AbstractFeature.class) @Feature(name = "RStack", description = "Stacks with custom distance", command = "/rstack", worldedit = true) public class RStackFeature extends CommandFeature { @@ -42,7 +49,7 @@ public class RStackFeature extends CommandFeature { @Override protected Feedback execute(ServerCommandSource source) throws CommandSyntaxException { - var actor = FabricAdapter.adaptPlayer(source.getPlayer()); + var actor = FabricAdapter.adaptPlayer(source.getPlayerOrThrow()); var localSession = WorldEdit.getInstance() .getSessionManager() diff --git a/src/main/java/tools/redstone/redstonetools/features/commands/SignalStrengthBlockFeature.java b/src/main/java/tools/redstone/redstonetools/features/commands/SignalStrengthBlockFeature.java index 066bbcba..5a6e798d 100644 --- a/src/main/java/tools/redstone/redstonetools/features/commands/SignalStrengthBlockFeature.java +++ b/src/main/java/tools/redstone/redstonetools/features/commands/SignalStrengthBlockFeature.java @@ -32,7 +32,7 @@ public class SignalStrengthBlockFeature extends CommandFeature { protected Feedback execute(ServerCommandSource source) throws CommandSyntaxException { try { ItemStack itemStack = block.getValue().getItemStack(signalStrength.getValue()); - source.getPlayer().giveItemStack(itemStack); + source.getPlayerOrThrow().giveItemStack(itemStack); } catch (IllegalArgumentException | IllegalStateException e) { return Feedback.error(e.getMessage()); } diff --git a/src/main/java/tools/redstone/redstonetools/features/commands/update/UpdateFeature.java b/src/main/java/tools/redstone/redstonetools/features/commands/update/UpdateFeature.java index f7e1078e..a19915aa 100644 --- a/src/main/java/tools/redstone/redstonetools/features/commands/update/UpdateFeature.java +++ b/src/main/java/tools/redstone/redstonetools/features/commands/update/UpdateFeature.java @@ -2,6 +2,8 @@ import com.google.auto.service.AutoService; import com.mojang.brigadier.exceptions.CommandSyntaxException; +import com.mojang.datafixers.util.Either; +import com.sk89q.worldedit.regions.Region; import net.minecraft.server.command.ServerCommandSource; import tools.redstone.redstonetools.features.AbstractFeature; import tools.redstone.redstonetools.features.Feature; @@ -14,7 +16,7 @@ public class UpdateFeature extends CommandFeature { @Override protected Feedback execute(ServerCommandSource source) throws CommandSyntaxException { - var selectionOrFeedback = WorldEditUtils.getSelection(source.getPlayer()); + var selectionOrFeedback = WorldEditUtils.getSelection(source.getPlayerOrThrow()); if (selectionOrFeedback.right().isPresent()) { return selectionOrFeedback.right().get(); } diff --git a/src/main/java/tools/redstone/redstonetools/features/toggleable/ToggleableFeature.java b/src/main/java/tools/redstone/redstonetools/features/toggleable/ToggleableFeature.java index 2ace5531..4d104471 100644 --- a/src/main/java/tools/redstone/redstonetools/features/toggleable/ToggleableFeature.java +++ b/src/main/java/tools/redstone/redstonetools/features/toggleable/ToggleableFeature.java @@ -13,6 +13,7 @@ import com.google.gson.GsonBuilder; import com.google.gson.JsonObject; import com.mojang.brigadier.CommandDispatcher; +import com.mojang.brigadier.builder.LiteralArgumentBuilder; import com.mojang.brigadier.context.CommandContext; import com.mojang.brigadier.exceptions.CommandSyntaxException; import net.fabricmc.fabric.api.client.event.lifecycle.v1.ClientLifecycleEvents; @@ -38,6 +39,8 @@ import static tools.redstone.redstonetools.RedstoneToolsClient.INJECTOR; +import Z; + import static net.minecraft.server.command.CommandManager.argument; import static net.minecraft.server.command.CommandManager.literal; diff --git a/src/main/java/tools/redstone/redstonetools/macros/MacroManager.java b/src/main/java/tools/redstone/redstonetools/macros/MacroManager.java index 95b1f0cf..1701fcfe 100644 --- a/src/main/java/tools/redstone/redstonetools/macros/MacroManager.java +++ b/src/main/java/tools/redstone/redstonetools/macros/MacroManager.java @@ -8,7 +8,12 @@ import javax.inject.Singleton; import javax.json.Json; import javax.json.JsonArray; +import javax.json.JsonArrayBuilder; import javax.json.JsonObject; +import javax.json.JsonReader; +import javax.json.JsonWriter; +import ; +import Z; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; diff --git a/src/main/java/tools/redstone/redstonetools/macros/actions/CommandAction.java b/src/main/java/tools/redstone/redstonetools/macros/actions/CommandAction.java index 6c680e74..d44dc4c8 100644 --- a/src/main/java/tools/redstone/redstonetools/macros/actions/CommandAction.java +++ b/src/main/java/tools/redstone/redstonetools/macros/actions/CommandAction.java @@ -1,6 +1,7 @@ package tools.redstone.redstonetools.macros.actions; import net.minecraft.client.MinecraftClient; +import net.minecraft.client.network.ClientPlayerEntity; public class CommandAction extends Action { public String command; diff --git a/src/main/java/tools/redstone/redstonetools/macros/gui/MacroCommandSuggestor.java b/src/main/java/tools/redstone/redstonetools/macros/gui/MacroCommandSuggestor.java new file mode 100644 index 00000000..6ef4da74 --- /dev/null +++ b/src/main/java/tools/redstone/redstonetools/macros/gui/MacroCommandSuggestor.java @@ -0,0 +1,42 @@ +package tools.redstone.redstonetools.macros.gui; + +import net.minecraft.client.MinecraftClient; +import net.minecraft.client.font.TextRenderer; +import net.minecraft.client.gui.screen.ChatInputSuggestor; +import net.minecraft.client.gui.screen.Screen; +import net.minecraft.client.gui.widget.TextFieldWidget; + +import java.util.HashMap; + +public class MacroCommandSuggestor extends ChatInputSuggestor { + private static final HashMap yMap = new HashMap<>(); + + + + public MacroCommandSuggestor(MinecraftClient client, Screen owner, TextFieldWidget textField, TextRenderer textRenderer, boolean slashOptional, boolean suggestingWhenEmpty, int y, int maxSuggestionSize, int color) { + super(client, owner, textField, textRenderer, slashOptional, suggestingWhenEmpty, 0, maxSuggestionSize, false, color); + yMap.put(this,y); + + } + + public void close(){ + yMap.remove(this); + } + + public static boolean instance(Object object) { + return object instanceof MacroCommandSuggestor; + } + + public static int getY(Object object){ + return yMap.get(object); + } + + @Override + public void refresh() { + if (MinecraftClient.getInstance().player == null) return; + super.refresh(); + + } + + +} diff --git a/src/main/java/tools/redstone/redstonetools/macros/gui/screen/CommandEditScreen.java b/src/main/java/tools/redstone/redstonetools/macros/gui/screen/CommandEditScreen.java index 4e64fd5f..d7eee994 100644 --- a/src/main/java/tools/redstone/redstonetools/macros/gui/screen/CommandEditScreen.java +++ b/src/main/java/tools/redstone/redstonetools/macros/gui/screen/CommandEditScreen.java @@ -1,6 +1,6 @@ package tools.redstone.redstonetools.macros.gui.screen; -import tools.redstone.redstonetools.macros.gui.MaroCommandSuggestor; +import tools.redstone.redstonetools.macros.gui.MacroCommandSuggestor; import net.minecraft.client.MinecraftClient; import net.minecraft.client.gui.screen.Screen; import net.minecraft.client.gui.screen.option.GameOptionsScreen; @@ -14,18 +14,18 @@ public class CommandEditScreen extends GameOptionsScreen { private final TextFieldWidget commandField; - private final MaroCommandSuggestor commandMaroCommandSuggestor; + private final MacroCommandSuggestor commandMacroCommandSuggestor; private boolean changed = false; public CommandEditScreen(Screen parent, GameOptions gameOptions, TextFieldWidget commandField) { super(parent, gameOptions, Text.of("")); this.commandField = commandField; client = MinecraftClient.getInstance(); - this.commandMaroCommandSuggestor = new MaroCommandSuggestor(client, parent, commandField,client.textRenderer,true,false, commandField.y -20,5,-805306368); + this.commandMacroCommandSuggestor = new MacroCommandSuggestor(client, parent, commandField,client.textRenderer,true,false, commandField.y -20,5,-805306368); commandField.setChangedListener((s) -> changed = true); - commandMaroCommandSuggestor.setWindowActive(true); - commandMaroCommandSuggestor.refresh(); + commandMacroCommandSuggestor.setWindowActive(true); + commandMacroCommandSuggestor.refresh(); } @Override @@ -36,9 +36,9 @@ public void render(MatrixStack matrices, int mouseX, int mouseY, float delta) { commandField.render(matrices, mouseX, mouseY, delta); - commandMaroCommandSuggestor.render(matrices, mouseX, mouseY); + commandMacroCommandSuggestor.render(matrices, mouseX, mouseY); if (changed) { - commandMaroCommandSuggestor.refresh(); + commandMacroCommandSuggestor.refresh(); changed = false; } @@ -62,15 +62,15 @@ public void close() { super.close(); commandField.setTextFieldFocused(false); commandField.setChangedListener(null); - commandMaroCommandSuggestor.setWindowActive(false); - commandMaroCommandSuggestor.refresh(); - commandMaroCommandSuggestor.close(); + commandMacroCommandSuggestor.setWindowActive(false); + commandMacroCommandSuggestor.refresh(); + commandMacroCommandSuggestor.close(); } @Override public boolean mouseClicked(double mouseX, double mouseY, int button) { if (!commandField.mouseClicked(mouseX, mouseY, button)) { - if (!commandMaroCommandSuggestor.mouseClicked(mouseX, mouseY, button)) { + if (!commandMacroCommandSuggestor.mouseClicked(mouseX, mouseY, button)) { close(); } else { commandField.setTextFieldFocused(true); @@ -82,7 +82,7 @@ public boolean mouseClicked(double mouseX, double mouseY, int button) { @Override public boolean mouseScrolled(double mouseX, double mouseY, double amount) { - return commandMaroCommandSuggestor.mouseScrolled(amount); + return commandMacroCommandSuggestor.mouseScrolled(amount); } @Override @@ -96,7 +96,7 @@ public boolean keyPressed(int keyCode, int scanCode, int modifiers) { close(); return true; } - commandMaroCommandSuggestor.keyPressed(keyCode, scanCode, modifiers); + commandMacroCommandSuggestor.keyPressed(keyCode, scanCode, modifiers); return commandField.keyPressed(keyCode, scanCode, modifiers); } diff --git a/src/main/java/tools/redstone/redstonetools/macros/gui/screen/MacroEditScreen.java b/src/main/java/tools/redstone/redstonetools/macros/gui/screen/MacroEditScreen.java index 8ad466c9..0e7ac2b2 100644 --- a/src/main/java/tools/redstone/redstonetools/macros/gui/screen/MacroEditScreen.java +++ b/src/main/java/tools/redstone/redstonetools/macros/gui/screen/MacroEditScreen.java @@ -12,7 +12,6 @@ import tools.redstone.redstonetools.macros.gui.widget.macrolist.MacroListWidget; import net.minecraft.client.MinecraftClient; import net.minecraft.client.gui.screen.Screen; -import net.minecraft.client.gui.screen.ScreenTexts; import net.minecraft.client.gui.screen.option.GameOptionsScreen; import net.minecraft.client.gui.widget.ButtonWidget; import net.minecraft.client.gui.widget.TextFieldWidget; @@ -21,6 +20,7 @@ import net.minecraft.client.util.InputUtil.Key; import net.minecraft.client.util.InputUtil.Type; import net.minecraft.client.util.math.MatrixStack; +import net.minecraft.screen.ScreenTexts; import net.minecraft.text.LiteralText; import net.minecraft.text.Text; import net.minecraft.util.Formatting; @@ -96,7 +96,7 @@ public void init() { keyBindButton = new ButtonWidget(this.width / 2 + 26, 55, 75, 20, text, (button) -> { detectingKeycodeKey = true; - keyBindButton.setMessage((new LiteralText("> ")).append(keyBindButton.getMessage().shallowCopy().formatted(Formatting.YELLOW)).append(" <").formatted(Formatting.YELLOW)); + keyBindButton.setMessage((new LiteralText("> ")).append(keyBindButton.getMessage().copy().formatted(Formatting.YELLOW)).append(" <").formatted(Formatting.YELLOW)); }); if (detectingKeycodeKey) keyBindButton.onPress(); @@ -147,9 +147,9 @@ public void render(MatrixStack matrices, int mouseX, int mouseY, float delta) { commandList.render(matrices, mouseX, mouseY, delta); super.render(matrices, mouseX, mouseY, delta); - drawCenteredText(matrices, this.textRenderer, this.title, this.width / 2, 8, 16777215); + drawCenteredTextWithShadow(matrices, this.textRenderer, this.title, this.width / 2, 8, 16777215); - drawCenteredText(matrices, this.textRenderer, "Key Bind", width / 2 - (99 - textRenderer.getWidth("Key Bind") / 2), 55 + textRenderer.fontHeight / 2, 16777215); + drawCenteredTextWithShadow(matrices, this.textRenderer, "Key Bind", width / 2 - (99 - textRenderer.getWidth("Key Bind") / 2), 55 + textRenderer.fontHeight / 2, 16777215); nameField.render(matrices, mouseX, mouseY, delta); if (nameField.getText().isEmpty() && !nameField.isFocused()) { diff --git a/src/main/java/tools/redstone/redstonetools/macros/gui/screen/MacroSelectScreen.java b/src/main/java/tools/redstone/redstonetools/macros/gui/screen/MacroSelectScreen.java index cab88a08..a67687d8 100644 --- a/src/main/java/tools/redstone/redstonetools/macros/gui/screen/MacroSelectScreen.java +++ b/src/main/java/tools/redstone/redstonetools/macros/gui/screen/MacroSelectScreen.java @@ -3,11 +3,11 @@ import tools.redstone.redstonetools.macros.gui.widget.macrolist.MacroEntry; import tools.redstone.redstonetools.macros.gui.widget.macrolist.MacroListWidget; import net.minecraft.client.gui.screen.Screen; -import net.minecraft.client.gui.screen.ScreenTexts; import net.minecraft.client.gui.screen.option.GameOptionsScreen; import net.minecraft.client.gui.widget.ButtonWidget; import net.minecraft.client.option.GameOptions; import net.minecraft.client.util.math.MatrixStack; +import net.minecraft.screen.ScreenTexts; import net.minecraft.text.Text; public class MacroSelectScreen extends GameOptionsScreen { @@ -40,7 +40,7 @@ public void render(MatrixStack matrices, int mouseX, int mouseY, float delta) { this.renderBackgroundTexture(0); macroList.render(matrices, mouseX, mouseY, delta); - drawCenteredText(matrices, this.textRenderer, this.title, this.width / 2, 8, 16777215); + drawCenteredTextWithShadow(matrices, this.textRenderer, this.title, this.width / 2, 8, 16777215); super.render(matrices, mouseX, mouseY, delta); } diff --git a/src/main/java/tools/redstone/redstonetools/macros/gui/widget/commandlist/CommandEntry.java b/src/main/java/tools/redstone/redstonetools/macros/gui/widget/commandlist/CommandEntry.java index afb75e28..bdc9c0da 100644 --- a/src/main/java/tools/redstone/redstonetools/macros/gui/widget/commandlist/CommandEntry.java +++ b/src/main/java/tools/redstone/redstonetools/macros/gui/widget/commandlist/CommandEntry.java @@ -1,6 +1,6 @@ package tools.redstone.redstonetools.macros.gui.widget.commandlist; -import tools.redstone.redstonetools.macros.gui.MaroCommandSuggestor; +import tools.redstone.redstonetools.macros.gui.MacroCommandSuggestor; import tools.redstone.redstonetools.macros.gui.widget.IconButtonWidget; import net.minecraft.client.MinecraftClient; import net.minecraft.client.gui.widget.ButtonWidget; @@ -29,10 +29,10 @@ public CommandEntry(MinecraftClient client, CommandListWidget owner, String text this.owner.removeCommand(this); }); - MaroCommandSuggestor commandMaroCommandSuggestor = new MaroCommandSuggestor(client, owner.getParent(), command,client.textRenderer,true,false, 0,0,0); - commandMaroCommandSuggestor.setWindowActive(false); - commandMaroCommandSuggestor.refresh(); - commandMaroCommandSuggestor.close(); + MacroCommandSuggestor commandMacroCommandSuggestor = new MacroCommandSuggestor(client, owner.getParent(), command,client.textRenderer,true,false, 0,0,0); + commandMacroCommandSuggestor.setWindowActive(false); + commandMacroCommandSuggestor.refresh(); + commandMacroCommandSuggestor.close(); } diff --git a/src/main/java/tools/redstone/redstonetools/macros/gui/widget/macrolist/MacroEntry.java b/src/main/java/tools/redstone/redstonetools/macros/gui/widget/macrolist/MacroEntry.java index 443de635..523e4810 100644 --- a/src/main/java/tools/redstone/redstonetools/macros/gui/widget/macrolist/MacroEntry.java +++ b/src/main/java/tools/redstone/redstonetools/macros/gui/widget/macrolist/MacroEntry.java @@ -8,7 +8,7 @@ import net.minecraft.client.util.math.MatrixStack; import net.minecraft.sound.SoundEvents; import net.minecraft.text.Text; -import net.minecraft.text.TranslatableText; +import net.minecraft.text.TranslatableTextContent; public class MacroEntry extends AlwaysSelectedEntryListWidget.Entry{ @@ -94,7 +94,7 @@ private void onPressed() { } public Text getNarration() { - return new TranslatableText("narrator.select"); + return new TranslatableTextContent("narrator.select"); } diff --git a/src/main/java/tools/redstone/redstonetools/mixin/features/AutoDustMixin.java b/src/main/java/tools/redstone/redstonetools/mixin/features/AutoDustMixin.java index f1131970..d3fcf6bb 100644 --- a/src/main/java/tools/redstone/redstonetools/mixin/features/AutoDustMixin.java +++ b/src/main/java/tools/redstone/redstonetools/mixin/features/AutoDustMixin.java @@ -49,6 +49,6 @@ private void onPlaced(World world, BlockPos pos, BlockState state, LivingEntity } ItemPlacementContext context = new ItemPlacementContext((PlayerEntity) placer, Hand.MAIN_HAND,new ItemStack(Items.REDSTONE),new BlockHitResult(new Vec3d(dustPos.getX(),dustPos.getY(),dustPos.getZ()), Direction.UP, dustPos,false)); - placer.getWorld().setBlockState(dustPos, Blocks.REDSTONE_WIRE.getPlacementState(context)); + placer.method_48926().setBlockState(dustPos, Blocks.REDSTONE_WIRE.getPlacementState(context)); } } diff --git a/src/main/java/tools/redstone/redstonetools/mixin/macros/autocomplete/CommandSuggestorMixin.java b/src/main/java/tools/redstone/redstonetools/mixin/macros/autocomplete/CommandSuggestorMixin.java index c88c08b4..b958d060 100644 --- a/src/main/java/tools/redstone/redstonetools/mixin/macros/autocomplete/CommandSuggestorMixin.java +++ b/src/main/java/tools/redstone/redstonetools/mixin/macros/autocomplete/CommandSuggestorMixin.java @@ -1,7 +1,7 @@ package tools.redstone.redstonetools.mixin.macros.autocomplete; import com.mojang.brigadier.suggestion.Suggestions; -import net.minecraft.client.gui.screen.CommandSuggestor; +import net.minecraft.client.gui.screen.ChatInputSuggestor; import net.minecraft.client.gui.widget.TextFieldWidget; import net.minecraft.client.util.math.MatrixStack; import org.jetbrains.annotations.Nullable; @@ -12,12 +12,12 @@ import org.spongepowered.asm.mixin.injection.Inject; import org.spongepowered.asm.mixin.injection.ModifyVariable; import org.spongepowered.asm.mixin.injection.callback.CallbackInfo; -import tools.redstone.redstonetools.macros.gui.MaroCommandSuggestor; +import tools.redstone.redstonetools.macros.gui.MacroCommandSuggestor; import java.util.concurrent.CompletableFuture; -@Mixin(CommandSuggestor.class) +@Mixin(ChatInputSuggestor.class) public class CommandSuggestorMixin{ @Shadow @Final @@ -29,7 +29,7 @@ public class CommandSuggestorMixin{ @ModifyVariable(method = "showSuggestions", at = @At("STORE"), ordinal = 1) public int suggestionWindXPos(int j){ - if (MaroCommandSuggestor.instance(this)) { + if (MacroCommandSuggestor.instance(this)) { Suggestions suggestions = this.pendingSuggestions.join(); return this.textField.getCharacterX(suggestions.getRange().getStart())+4; } @@ -38,10 +38,10 @@ public int suggestionWindXPos(int j){ @ModifyVariable(method = "showSuggestions", at = @At("STORE"), ordinal = 2) public int suggestionWindYPos(int k){ - if (MaroCommandSuggestor.instance(this)) { + if (MacroCommandSuggestor.instance(this)) { Suggestions suggestions = this.pendingSuggestions.join(); - int y = MaroCommandSuggestor.getY(this)-2; + int y = MacroCommandSuggestor.getY(this)-2; return y +20 - Math.min(suggestions.getList().size(), this.maxSuggestionSize) * 12; } return k; @@ -57,8 +57,8 @@ public void render(MatrixStack matrices, int mouseX, int mouseY, CallbackInfo ci @ModifyVariable(method = "render", at = @At("STORE"), ordinal = 3) public int messageYPos(int j) { - if (MaroCommandSuggestor.instance(this)) { - int y = MaroCommandSuggestor.getY(this); + if (MacroCommandSuggestor.instance(this)) { + int y = MacroCommandSuggestor.getY(this); i++; return y - 12*(i-1)+43; } diff --git a/src/main/java/tools/redstone/redstonetools/utils/BlockStateNbtUtil.java b/src/main/java/tools/redstone/redstonetools/utils/BlockStateNbtUtil.java index fcef4e28..8938af04 100644 --- a/src/main/java/tools/redstone/redstonetools/utils/BlockStateNbtUtil.java +++ b/src/main/java/tools/redstone/redstonetools/utils/BlockStateNbtUtil.java @@ -7,11 +7,10 @@ import net.minecraft.nbt.NbtCompound; import net.minecraft.nbt.NbtElement; import net.minecraft.nbt.NbtList; +import net.minecraft.registry.Registry; import net.minecraft.server.world.ServerWorld; import net.minecraft.state.property.Property; import net.minecraft.util.Identifier; -import net.minecraft.util.registry.Registry; - import java.util.Objects; /** diff --git a/src/main/java/tools/redstone/redstonetools/utils/ColoredBlock.java b/src/main/java/tools/redstone/redstonetools/utils/ColoredBlock.java index 266ab358..da288a52 100644 --- a/src/main/java/tools/redstone/redstonetools/utils/ColoredBlock.java +++ b/src/main/java/tools/redstone/redstonetools/utils/ColoredBlock.java @@ -1,11 +1,12 @@ package tools.redstone.redstonetools.utils; import net.minecraft.block.Block; +import net.minecraft.registry.Registry; import net.minecraft.util.Identifier; -import net.minecraft.util.registry.Registry; import org.jetbrains.annotations.NotNull; import java.util.HashMap; +import java.util.regex.Matcher; import java.util.regex.Pattern; public class ColoredBlock { diff --git a/src/main/java/tools/redstone/redstonetools/utils/ColoredBlockType.java b/src/main/java/tools/redstone/redstonetools/utils/ColoredBlockType.java index 701447c7..c8b14d90 100644 --- a/src/main/java/tools/redstone/redstonetools/utils/ColoredBlockType.java +++ b/src/main/java/tools/redstone/redstonetools/utils/ColoredBlockType.java @@ -1,8 +1,8 @@ package tools.redstone.redstonetools.utils; import net.minecraft.block.Block; +import net.minecraft.registry.Registry; import net.minecraft.util.Identifier; -import net.minecraft.util.registry.Registry; public enum ColoredBlockType { // TODO: Merge some things with the ColoredBlock class so we dont have to repeat the formats and stuff diff --git a/src/main/java/tools/redstone/redstonetools/utils/ItemUtils.java b/src/main/java/tools/redstone/redstonetools/utils/ItemUtils.java index 652b9081..bf1bead1 100644 --- a/src/main/java/tools/redstone/redstonetools/utils/ItemUtils.java +++ b/src/main/java/tools/redstone/redstonetools/utils/ItemUtils.java @@ -5,11 +5,8 @@ import net.minecraft.client.network.ClientPlayerEntity; import net.minecraft.entity.player.PlayerEntity; import net.minecraft.item.*; -import net.minecraft.util.registry.Registry; import net.minecraft.world.BlockStateRaycastContext; import net.minecraft.world.RaycastContext; - -import net.minecraft.item.ItemStack; import net.minecraft.nbt.NbtCompound; import net.minecraft.nbt.NbtList; import net.minecraft.nbt.NbtString; diff --git a/src/main/java/tools/redstone/redstonetools/utils/RaycastUtils.java b/src/main/java/tools/redstone/redstonetools/utils/RaycastUtils.java index abaf26a2..7286b95d 100644 --- a/src/main/java/tools/redstone/redstonetools/utils/RaycastUtils.java +++ b/src/main/java/tools/redstone/redstonetools/utils/RaycastUtils.java @@ -2,6 +2,8 @@ import net.minecraft.entity.player.PlayerEntity; import net.minecraft.util.hit.BlockHitResult; +import net.minecraft.util.math.BlockPos; +import net.minecraft.util.math.Vec3f; import net.minecraft.world.RaycastContext; public class RaycastUtils { @@ -17,7 +19,7 @@ public static BlockHitResult getBlockHitNeighbor(BlockHitResult hit) { } public static BlockHitResult rayCastFromEye(PlayerEntity player, float reach) { - return player.getWorld().raycast(new RaycastContext( + return player.method_48926().raycast(new RaycastContext( player.getEyePos(), player.getEyePos().add(player.getRotationVector().multiply(reach)), RaycastContext.ShapeType.COLLIDER, diff --git a/src/main/java/tools/redstone/redstonetools/utils/ReflectionUtils.java b/src/main/java/tools/redstone/redstonetools/utils/ReflectionUtils.java index e80d7ceb..ead82a6b 100644 --- a/src/main/java/tools/redstone/redstonetools/utils/ReflectionUtils.java +++ b/src/main/java/tools/redstone/redstonetools/utils/ReflectionUtils.java @@ -13,6 +13,7 @@ import java.lang.invoke.MethodHandles; import java.lang.reflect.Field; import java.io.IOException; +import java.io.InputStream; import java.lang.reflect.Modifier; import java.net.URL; import java.util.*; diff --git a/src/main/java/tools/redstone/redstonetools/utils/SignalBlockSupplier.java b/src/main/java/tools/redstone/redstonetools/utils/SignalBlockSupplier.java index 0b0d2558..4f34f8e1 100644 --- a/src/main/java/tools/redstone/redstonetools/utils/SignalBlockSupplier.java +++ b/src/main/java/tools/redstone/redstonetools/utils/SignalBlockSupplier.java @@ -7,11 +7,11 @@ import net.minecraft.item.Items; import net.minecraft.nbt.NbtCompound; import net.minecraft.nbt.NbtList; +import net.minecraft.registry.Registry; import net.minecraft.text.LiteralText; import net.minecraft.text.MutableText; import net.minecraft.util.Formatting; import net.minecraft.util.math.MathHelper; -import net.minecraft.util.registry.Registry; @FunctionalInterface public interface SignalBlockSupplier { diff --git a/src/main/java/tools/redstone/redstonetools/utils/WorldEditUtils.java b/src/main/java/tools/redstone/redstonetools/utils/WorldEditUtils.java index 29e8ece7..6f2588d9 100644 --- a/src/main/java/tools/redstone/redstonetools/utils/WorldEditUtils.java +++ b/src/main/java/tools/redstone/redstonetools/utils/WorldEditUtils.java @@ -3,11 +3,14 @@ import tools.redstone.redstonetools.features.feedback.Feedback; import com.mojang.datafixers.util.Either; import com.sk89q.worldedit.IncompleteRegionException; +import com.sk89q.worldedit.LocalSession; import com.sk89q.worldedit.WorldEdit; import com.sk89q.worldedit.fabric.FabricAdapter; +import com.sk89q.worldedit.fabric.FabricPlayer; import com.sk89q.worldedit.math.BlockVector3; import com.sk89q.worldedit.regions.CuboidRegion; import com.sk89q.worldedit.regions.Region; +import com.sk89q.worldedit.world.World; import net.minecraft.server.network.ServerPlayerEntity; import java.util.function.Consumer; From f747d7f01e0b1c011c4574d1c3021445218c4d8e Mon Sep 17 00:00:00 2001 From: Quie_ Date: Sat, 30 Dec 2023 13:51:20 -0500 Subject: [PATCH 02/29] Deleted oldSrc --- .../redstonetools/RedstoneToolsClient.java | 42 --- .../redstonetools/RedstoneToolsGameRules.java | 23 -- .../redstonetools/di/FeatureModule.java | 18 -- .../redstonetools/di/UtilityModule.java | 15 - .../features/AbstractFeature.java | 60 ---- .../redstonetools/features/Feature.java | 16 -- .../features/arguments/Argument.java | 80 ------ .../serializers/BigIntegerSerializer.java | 33 --- .../serializers/BlockColorSerializer.java | 15 - .../BlockStateArgumentSerializer.java | 60 ---- .../arguments/serializers/BoolSerializer.java | 23 -- .../serializers/BrigadierSerializer.java | 38 --- .../serializers/CollectionSerializer.java | 176 ------------ .../ColoredBlockTypeSerializer.java | 15 - .../serializers/DirectionSerializer.java | 15 - .../serializers/DoubleSerializer.java | 31 --- .../arguments/serializers/EnumSerializer.java | 80 ------ .../serializers/FloatSerializer.java | 31 --- .../serializers/IntLikeSerializer.java | 129 --------- .../serializers/IntegerSerializer.java | 32 --- .../arguments/serializers/LongSerializer.java | 32 --- .../serializers/MacroNameSerializer.java | 35 --- .../serializers/NumberBaseSerializer.java | 75 ----- .../serializers/NumberSerializer.java | 34 --- .../serializers/SignalBlockSerializer.java | 15 - .../StringBrigadierSerializer.java | 22 -- .../serializers/StringSerializer.java | 34 --- .../arguments/serializers/TypeSerializer.java | 47 ---- .../features/commands/BaseConvertFeature.java | 32 --- .../commands/BinaryBlockReadFeature.java | 101 ------- .../commands/BlockRaycastFeature.java | 42 --- .../features/commands/ColorCodeFeature.java | 113 -------- .../features/commands/ColoredFeature.java | 38 --- .../features/commands/CommandFeature.java | 78 ------ .../features/commands/CopyStateFeature.java | 48 ---- .../features/commands/ItemBindFeature.java | 53 ---- .../features/commands/MacroFeature.java | 31 --- .../commands/MinSelectionFeature.java | 126 --------- .../features/commands/PickBlockFeature.java | 45 --- .../features/commands/QuickTpFeature.java | 60 ---- .../features/commands/RStackFeature.java | 98 ------- .../commands/SignalStrengthBlockFeature.java | 53 ---- .../commands/update/RegionUpdater.java | 28 -- .../commands/update/UpdateFeature.java | 28 -- .../feedback/AbstractFeedbackSender.java | 7 - .../features/feedback/Feedback.java | 178 ------------ .../features/feedback/FeedbackSender.java | 19 -- .../features/feedback/FeedbackType.java | 18 -- .../features/toggleable/AirPlaceFeature.java | 125 --------- .../features/toggleable/AutoDustFeature.java | 11 - .../features/toggleable/BigDustFeature.java | 16 -- .../toggleable/ToggleableFeature.java | 257 ----------------- .../macros/ClientPlayerEntityMixin.java | 9 - .../redstonetools/macros/KeyBindingMixin.java | 12 - .../redstone/redstonetools/macros/Macro.java | 132 --------- .../redstonetools/macros/MacroManager.java | 192 ------------- .../redstonetools/macros/actions/Action.java | 5 - .../macros/actions/CommandAction.java | 29 -- .../macros/gui/MaroCommandSuggestor.java | 42 --- .../macros/gui/screen/CommandEditScreen.java | 108 -------- .../macros/gui/screen/MacroEditScreen.java | 259 ------------------ .../macros/gui/screen/MacroSelectScreen.java | 52 ---- .../macros/gui/widget/IconButtonWidget.java | 35 --- .../gui/widget/commandlist/CommandEntry.java | 112 -------- .../commandlist/CommandEntryPlaceHolder.java | 23 -- .../widget/commandlist/CommandListWidget.java | 127 --------- .../gui/widget/macrolist/MacroEntry.java | 117 -------- .../gui/widget/macrolist/MacroListWidget.java | 77 ------ .../accessors/MinecraftClientAccessor.java | 15 - .../accessors/WorldRendererAccessor.java | 18 -- .../mixin/blocks/RedstoneHitboxMixin.java | 46 ---- .../mixin/features/AirPlaceClientMixin.java | 85 ------ .../mixin/features/AirPlaceServerMixin.java | 27 -- .../mixin/features/AutoDustMixin.java | 54 ---- .../mixin/features/CopyStateMixin.java | 29 -- .../mixin/features/ItemBindMixin.java | 78 ------ .../gamerules/DoContainerDropsMixin.java | 20 -- .../mixin/macros/AddMacroButtonMixin.java | 27 -- .../macros/InitializeMacroManagerMixin.java | 18 -- .../mixin/macros/KeyBindingMixinImpl.java | 30 -- .../ClientPlayerEntityMixinImpl.java | 22 -- .../autocomplete/CommandSuggestorMixin.java | 71 ----- .../mixin/update/CheckUpdateMixin.java | 91 ------ .../redstonetools/utils/BlockColor.java | 50 ---- .../redstonetools/utils/BlockInfo.java | 20 -- .../utils/BlockStateNbtUtil.java | 181 ------------ .../redstonetools/utils/ColoredBlock.java | 85 ------ .../redstonetools/utils/ColoredBlockType.java | 39 --- .../utils/CommandSourceUtils.java | 12 - .../redstonetools/utils/CommandUtils.java | 59 ---- .../redstonetools/utils/DependencyLookup.java | 25 -- .../utils/DirectionArgument.java | 24 -- .../redstonetools/utils/DirectionUtils.java | 115 -------- .../redstonetools/utils/ItemUtils.java | 68 ----- .../redstonetools/utils/KeyBindingUtils.java | 19 -- .../redstonetools/utils/NumberArg.java | 62 ----- .../redstonetools/utils/NumberBase.java | 101 ------- .../redstonetools/utils/PositionUtils.java | 13 - .../redstonetools/utils/RaycastUtils.java | 28 -- .../redstonetools/utils/RedstoneUtils.java | 12 - .../redstonetools/utils/ReflectionUtils.java | 153 ----------- .../redstonetools/utils/SignalBlock.java | 48 ---- .../utils/SignalBlockSupplier.java | 131 --------- .../redstonetools/utils/WorldEditUtils.java | 69 ----- .../assets/redstonetools/gui/cross.png | Bin 3361 -> 0 bytes .../assets/redstonetools/gui/pencil.png | Bin 3328 -> 0 bytes .../resources/assets/redstonetools/icon.png | Bin 1799 -> 0 bytes .../assets/redstonetools/lang/en_au.json | 6 - .../assets/redstonetools/lang/en_ca.json | 6 - .../assets/redstonetools/lang/en_gb.json | 6 - .../assets/redstonetools/lang/en_nz.json | 6 - .../assets/redstonetools/lang/en_us.json | 6 - oldSrc/main/resources/fabric.mod.json | 43 --- .../main/resources/redstonetools.mixins.json | 29 -- 114 files changed, 6209 deletions(-) delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/RedstoneToolsClient.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/RedstoneToolsGameRules.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/di/FeatureModule.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/di/UtilityModule.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/AbstractFeature.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/Feature.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/arguments/Argument.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/BigIntegerSerializer.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/BlockColorSerializer.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/BlockStateArgumentSerializer.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/BoolSerializer.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/BrigadierSerializer.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/CollectionSerializer.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/ColoredBlockTypeSerializer.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/DirectionSerializer.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/DoubleSerializer.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/EnumSerializer.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/FloatSerializer.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/IntLikeSerializer.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/IntegerSerializer.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/LongSerializer.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/MacroNameSerializer.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/NumberBaseSerializer.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/NumberSerializer.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/SignalBlockSerializer.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/StringBrigadierSerializer.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/StringSerializer.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/TypeSerializer.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/commands/BaseConvertFeature.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/commands/BinaryBlockReadFeature.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/commands/BlockRaycastFeature.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/commands/ColorCodeFeature.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/commands/ColoredFeature.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/commands/CommandFeature.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/commands/CopyStateFeature.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/commands/ItemBindFeature.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/commands/MacroFeature.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/commands/MinSelectionFeature.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/commands/PickBlockFeature.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/commands/QuickTpFeature.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/commands/RStackFeature.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/commands/SignalStrengthBlockFeature.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/commands/update/RegionUpdater.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/commands/update/UpdateFeature.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/feedback/AbstractFeedbackSender.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/feedback/Feedback.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/feedback/FeedbackSender.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/feedback/FeedbackType.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/toggleable/AirPlaceFeature.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/toggleable/AutoDustFeature.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/toggleable/BigDustFeature.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/features/toggleable/ToggleableFeature.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/macros/ClientPlayerEntityMixin.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/macros/KeyBindingMixin.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/macros/Macro.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/macros/MacroManager.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/macros/actions/Action.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/macros/actions/CommandAction.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/macros/gui/MaroCommandSuggestor.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/macros/gui/screen/CommandEditScreen.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/macros/gui/screen/MacroEditScreen.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/macros/gui/screen/MacroSelectScreen.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/macros/gui/widget/IconButtonWidget.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/macros/gui/widget/commandlist/CommandEntry.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/macros/gui/widget/commandlist/CommandEntryPlaceHolder.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/macros/gui/widget/commandlist/CommandListWidget.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/macros/gui/widget/macrolist/MacroEntry.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/macros/gui/widget/macrolist/MacroListWidget.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/mixin/accessors/MinecraftClientAccessor.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/mixin/accessors/WorldRendererAccessor.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/mixin/blocks/RedstoneHitboxMixin.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/mixin/features/AirPlaceClientMixin.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/mixin/features/AirPlaceServerMixin.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/mixin/features/AutoDustMixin.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/mixin/features/CopyStateMixin.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/mixin/features/ItemBindMixin.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/mixin/gamerules/DoContainerDropsMixin.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/mixin/macros/AddMacroButtonMixin.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/mixin/macros/InitializeMacroManagerMixin.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/mixin/macros/KeyBindingMixinImpl.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/mixin/macros/autocomplete/ClientPlayerEntityMixinImpl.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/mixin/macros/autocomplete/CommandSuggestorMixin.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/mixin/update/CheckUpdateMixin.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/utils/BlockColor.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/utils/BlockInfo.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/utils/BlockStateNbtUtil.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/utils/ColoredBlock.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/utils/ColoredBlockType.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/utils/CommandSourceUtils.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/utils/CommandUtils.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/utils/DependencyLookup.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/utils/DirectionArgument.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/utils/DirectionUtils.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/utils/ItemUtils.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/utils/KeyBindingUtils.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/utils/NumberArg.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/utils/NumberBase.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/utils/PositionUtils.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/utils/RaycastUtils.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/utils/RedstoneUtils.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/utils/ReflectionUtils.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/utils/SignalBlock.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/utils/SignalBlockSupplier.java delete mode 100644 oldSrc/main/java/tools/redstone/redstonetools/utils/WorldEditUtils.java delete mode 100644 oldSrc/main/resources/assets/redstonetools/gui/cross.png delete mode 100644 oldSrc/main/resources/assets/redstonetools/gui/pencil.png delete mode 100644 oldSrc/main/resources/assets/redstonetools/icon.png delete mode 100644 oldSrc/main/resources/assets/redstonetools/lang/en_au.json delete mode 100644 oldSrc/main/resources/assets/redstonetools/lang/en_ca.json delete mode 100644 oldSrc/main/resources/assets/redstonetools/lang/en_gb.json delete mode 100644 oldSrc/main/resources/assets/redstonetools/lang/en_nz.json delete mode 100644 oldSrc/main/resources/assets/redstonetools/lang/en_us.json delete mode 100644 oldSrc/main/resources/fabric.mod.json delete mode 100644 oldSrc/main/resources/redstonetools.mixins.json diff --git a/oldSrc/main/java/tools/redstone/redstonetools/RedstoneToolsClient.java b/oldSrc/main/java/tools/redstone/redstonetools/RedstoneToolsClient.java deleted file mode 100644 index 2207c32b..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/RedstoneToolsClient.java +++ /dev/null @@ -1,42 +0,0 @@ -package tools.redstone.redstonetools; - -import net.fabricmc.api.ClientModInitializer; -import net.fabricmc.loader.api.FabricLoader; -import net.minecraft.client.MinecraftClient; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; -import rip.hippo.inject.Doctor; -import rip.hippo.inject.Injector; -import tools.redstone.redstonetools.utils.DependencyLookup; -import tools.redstone.redstonetools.utils.ReflectionUtils; - -import java.nio.file.Path; - -public class RedstoneToolsClient implements ClientModInitializer { - - public static final String MOD_ID = "redstonetools"; - public static final String MOD_VERSION = "v" + FabricLoader.getInstance().getModContainer(MOD_ID).orElseThrow().getMetadata().getVersion().getFriendlyString(); - public static final Logger LOGGER = LoggerFactory.getLogger(MOD_ID); - public static final Path CONFIG_DIR = FabricLoader.getInstance().getConfigDir().resolve("redstonetools"); - public static final Injector INJECTOR = Doctor.createInjector(ReflectionUtils.getModules()); - - @Override - public void onInitializeClient() { - LOGGER.info("Initializing Redstone Tools"); - - // Register game rules - RedstoneToolsGameRules.register(); - - // Register features - ReflectionUtils.getFeatures().forEach(feature -> { - LOGGER.trace("Registering feature {}", feature.getClass().getName()); - - if (feature.requiresWorldEdit() && !DependencyLookup.WORLDEDIT_PRESENT) { - LOGGER.warn("Feature {} requires WorldEdit, but WorldEdit is not loaded. Skipping registration.", feature.getName()); - return; - } - feature.register(); - }); - } - -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/RedstoneToolsGameRules.java b/oldSrc/main/java/tools/redstone/redstonetools/RedstoneToolsGameRules.java deleted file mode 100644 index 73a9e2f8..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/RedstoneToolsGameRules.java +++ /dev/null @@ -1,23 +0,0 @@ -package tools.redstone.redstonetools; - -import net.fabricmc.fabric.api.gamerule.v1.GameRuleFactory; -import net.fabricmc.fabric.api.gamerule.v1.GameRuleRegistry; -import net.minecraft.world.GameRules; -import tools.redstone.redstonetools.utils.DependencyLookup; - - -public class RedstoneToolsGameRules { - private RedstoneToolsGameRules() { - } - - public static GameRules.Key DO_CONTAINER_DROPS; - public static GameRules.Key DO_BLOCK_UPDATES_AFTER_EDIT; - - public static void register() { - DO_CONTAINER_DROPS = GameRuleRegistry.register("doContainerDrops", GameRules.Category.DROPS, GameRuleFactory.createBooleanRule(true)); - - if (DependencyLookup.WORLDEDIT_PRESENT) { - DO_BLOCK_UPDATES_AFTER_EDIT = GameRuleRegistry.register("doBlockUpdatesAfterEdit", GameRules.Category.UPDATES, GameRuleFactory.createBooleanRule(false)); - } - } -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/di/FeatureModule.java b/oldSrc/main/java/tools/redstone/redstonetools/di/FeatureModule.java deleted file mode 100644 index 505e2179..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/di/FeatureModule.java +++ /dev/null @@ -1,18 +0,0 @@ -package tools.redstone.redstonetools.di; - -import com.google.auto.service.AutoService; -import rip.hippo.inject.DoctorModule; -import rip.hippo.inject.binding.Binder; -import tools.redstone.redstonetools.utils.ReflectionUtils; - -@AutoService(DoctorModule.class) -public class FeatureModule implements DoctorModule { - @SuppressWarnings({"rawtypes", "unchecked"}) // this is probably the only way to make it work - @Override - public void configure(Binder binder) { - for (var feature : ReflectionUtils.getFeatures()) { - Class clazz = feature.getClass(); - binder.bind(clazz).toInstance(feature); - } - } -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/di/UtilityModule.java b/oldSrc/main/java/tools/redstone/redstonetools/di/UtilityModule.java deleted file mode 100644 index 3415b5e3..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/di/UtilityModule.java +++ /dev/null @@ -1,15 +0,0 @@ -package tools.redstone.redstonetools.di; - -import com.google.auto.service.AutoService; -import rip.hippo.inject.DoctorModule; -import rip.hippo.inject.binding.Binder; -import tools.redstone.redstonetools.features.feedback.AbstractFeedbackSender; -import tools.redstone.redstonetools.features.feedback.FeedbackSender; - -@AutoService(DoctorModule.class) -public class UtilityModule implements DoctorModule { - @Override - public void configure(Binder binder) { - binder.bind(AbstractFeedbackSender.class).to(FeedbackSender.class); - } -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/AbstractFeature.java b/oldSrc/main/java/tools/redstone/redstonetools/features/AbstractFeature.java deleted file mode 100644 index e8e6f1af..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/features/AbstractFeature.java +++ /dev/null @@ -1,60 +0,0 @@ -package tools.redstone.redstonetools.features; - -import com.mojang.brigadier.CommandDispatcher; -import net.fabricmc.fabric.api.command.v1.CommandRegistrationCallback; -import net.minecraft.server.command.ServerCommandSource; - -public abstract class AbstractFeature { - - private final Feature featureInfo; - private final String id; - - { - featureInfo = getClass().getAnnotation(Feature.class); - - if (featureInfo == null) { - throw new IllegalStateException("Feature " + getClass() + " is not annotated with @Feature"); - } - - String id = featureInfo.id(); - if (id.isEmpty()) { - // derive id from name - // Air Place -> airplace - id = featureInfo.name() - .toLowerCase() - .replace(" ", ""); - } - - this.id = id; - } - - public String getID() { - return id; - } - - public String getName() { - return featureInfo.name(); - } - - public String getDescription() { - return featureInfo.description(); - } - - public String getCommand() { - return featureInfo.command(); - } - - public boolean requiresWorldEdit() { - return featureInfo.worldedit(); - } - - /** - * Register this feature. - */ - public void register() { - CommandRegistrationCallback.EVENT.register(this::registerCommands); - } - - protected abstract void registerCommands(CommandDispatcher dispatcher, boolean dedicated); - -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/Feature.java b/oldSrc/main/java/tools/redstone/redstonetools/features/Feature.java deleted file mode 100644 index 14979af7..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/features/Feature.java +++ /dev/null @@ -1,16 +0,0 @@ -package tools.redstone.redstonetools.features; - -import java.lang.annotation.ElementType; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; -import java.lang.annotation.Target; - -@Target(ElementType.TYPE) -@Retention(RetentionPolicy.RUNTIME) -public @interface Feature { - String id() default ""; - String name(); - String description(); - String command(); - boolean worldedit() default false; -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/Argument.java b/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/Argument.java deleted file mode 100644 index 683536c0..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/Argument.java +++ /dev/null @@ -1,80 +0,0 @@ -package tools.redstone.redstonetools.features.arguments; - -import tools.redstone.redstonetools.features.arguments.serializers.TypeSerializer; -import com.mojang.brigadier.context.CommandContext; - -public class Argument { - private String name; - private final TypeSerializer type; - private boolean optional = false; - private volatile T value; - private T defaultValue; - - private Argument(TypeSerializer type) { - this.type = type; - } - - public static Argument ofType(TypeSerializer type) { - return new Argument<>(type); - } - - public Argument withDefault(T defaultValue) { - optional = true; - this.defaultValue = defaultValue; - this.value = defaultValue; // for options, temporary - - return this; - } - - public T getDefaultValue() { - return defaultValue; - } - - public Argument named(String name) { - this.name = name; - - return this; - } - - public Argument ensureNamed(String fieldName) { - if (name == null) { - name = fieldName; - } - - return this; - } - - public String getName() { - return name; - } - - public TypeSerializer getType() { - return type; - } - - public boolean isOptional() { - return optional; - } - - @SuppressWarnings("unchecked") - public void updateValue(CommandContext context) { - try { - value = (T) context.getArgument(name, Object.class); - } catch (IllegalArgumentException e) { - if (!optional) { - throw e; - } - - value = defaultValue; - } - } - - public void setValue(T value) { - this.value = value; - } - - public T getValue() { - return value; - } - -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/BigIntegerSerializer.java b/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/BigIntegerSerializer.java deleted file mode 100644 index 36b94bbb..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/BigIntegerSerializer.java +++ /dev/null @@ -1,33 +0,0 @@ -package tools.redstone.redstonetools.features.arguments.serializers; - -import java.math.BigInteger; -import java.util.Optional; - -public class BigIntegerSerializer extends IntLikeSerializer { - private static final BigIntegerSerializer INSTANCE = new BigIntegerSerializer(null, null); - - public static BigIntegerSerializer bigInteger() { - return INSTANCE; - } - - public static BigIntegerSerializer bigInteger(BigInteger min) { - return new BigIntegerSerializer(min, null); - } - - public static BigIntegerSerializer bigInteger(BigInteger min, BigInteger max) { - return new BigIntegerSerializer(min, max); - } - - private BigIntegerSerializer(BigInteger min, BigInteger max) { - super(BigInteger.class, min, max); - } - - @Override - protected Optional tryParseOptional(String string, int radix) { - try { - return Optional.of(new BigInteger(string, radix)); - } catch (NumberFormatException ignored) { - return Optional.empty(); - } - } -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/BlockColorSerializer.java b/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/BlockColorSerializer.java deleted file mode 100644 index a90c2a85..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/BlockColorSerializer.java +++ /dev/null @@ -1,15 +0,0 @@ -package tools.redstone.redstonetools.features.arguments.serializers; - -import tools.redstone.redstonetools.utils.BlockColor; - -public class BlockColorSerializer extends EnumSerializer { - private static final BlockColorSerializer INSTANCE = new BlockColorSerializer(); - - private BlockColorSerializer() { - super(BlockColor.class); - } - - public static BlockColorSerializer blockColor() { - return INSTANCE; - } -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/BlockStateArgumentSerializer.java b/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/BlockStateArgumentSerializer.java deleted file mode 100644 index 705bebac..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/BlockStateArgumentSerializer.java +++ /dev/null @@ -1,60 +0,0 @@ -package tools.redstone.redstonetools.features.arguments.serializers; - -import com.mojang.brigadier.StringReader; -import com.mojang.brigadier.exceptions.CommandSyntaxException; -import net.minecraft.command.argument.BlockStateArgument; -import net.minecraft.command.argument.BlockStateArgumentType; -import net.minecraft.util.registry.Registry; - -public class BlockStateArgumentSerializer extends BrigadierSerializer { - - private static final BlockStateArgumentSerializer INSTANCE = new BlockStateArgumentSerializer(); - - private BlockStateArgumentSerializer() { - super(BlockStateArgument.class, BlockStateArgumentType.blockState()); - } - - public static BlockStateArgumentSerializer blockState() { - return INSTANCE; - } - - @Override - public BlockStateArgument deserialize(String serialized) { - try { - return deserialize(new StringReader(serialized)); - } catch (CommandSyntaxException e) { - throw new IllegalStateException("Syntax Exception: " + e.getMessage()); - } - } - - @Override - public String serialize(BlockStateArgument value) { - var state = value.getBlockState(); - var block = state.getBlock(); - - var builder = new StringBuilder() - .append(Registry.BLOCK.getId(block)); - - if (state.getProperties().size() == 0) { - return builder.toString(); - } - - builder.append('['); - var first = true; - for (var prop : state.getProperties()) { - if (first) { - first = false; - } else { - builder.append(','); - } - - builder.append(prop.getName()) - .append('=') - .append(state.get(prop)); - } - builder.append(']'); - - return builder.toString(); - } - -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/BoolSerializer.java b/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/BoolSerializer.java deleted file mode 100644 index 02fb39e5..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/BoolSerializer.java +++ /dev/null @@ -1,23 +0,0 @@ -package tools.redstone.redstonetools.features.arguments.serializers; - -import com.mojang.brigadier.arguments.ArgumentType; -import com.mojang.brigadier.arguments.BoolArgumentType; - -public class BoolSerializer extends StringBrigadierSerializer { - - private static final BoolSerializer INSTANCE = new BoolSerializer(BoolArgumentType.bool()); - - public static BoolSerializer bool() { - return INSTANCE; - } - - private BoolSerializer(ArgumentType argumentType) { - super(Boolean.class, argumentType); - } - - @Override - public String serialize(Boolean value) { - return String.valueOf(value); - } - -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/BrigadierSerializer.java b/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/BrigadierSerializer.java deleted file mode 100644 index 5a2e5ba9..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/BrigadierSerializer.java +++ /dev/null @@ -1,38 +0,0 @@ -package tools.redstone.redstonetools.features.arguments.serializers; - -import com.mojang.brigadier.StringReader; -import com.mojang.brigadier.arguments.ArgumentType; -import com.mojang.brigadier.context.CommandContext; -import com.mojang.brigadier.exceptions.CommandSyntaxException; -import com.mojang.brigadier.suggestion.Suggestions; -import com.mojang.brigadier.suggestion.SuggestionsBuilder; - -import java.util.Collection; -import java.util.concurrent.CompletableFuture; - -public abstract class BrigadierSerializer extends TypeSerializer { - - // the wrapped brigadier argument type - private final ArgumentType argumentType; - - public BrigadierSerializer(Class clazz, ArgumentType argumentType) { - super(clazz); - this.argumentType = argumentType; - } - - @Override - public T deserialize(StringReader reader) throws CommandSyntaxException { - return argumentType.parse(reader); - } - - @Override - public CompletableFuture listSuggestions(CommandContext context, SuggestionsBuilder builder) { - return argumentType.listSuggestions(context, builder); - } - - @Override - public Collection getExamples() { - return argumentType.getExamples(); - } - -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/CollectionSerializer.java b/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/CollectionSerializer.java deleted file mode 100644 index c68c7c29..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/CollectionSerializer.java +++ /dev/null @@ -1,176 +0,0 @@ -package tools.redstone.redstonetools.features.arguments.serializers; - -import com.mojang.brigadier.StringReader; -import com.mojang.brigadier.context.CommandContext; -import com.mojang.brigadier.exceptions.CommandSyntaxException; -import com.mojang.brigadier.suggestion.Suggestions; -import com.mojang.brigadier.suggestion.SuggestionsBuilder; - -import java.util.*; -import java.util.concurrent.CompletableFuture; -import java.util.function.Function; - -/** - * Serializes any collection type as a list, - * and handles it specially for configuration. - * - * @param The element type. - * @param The collection type. - */ -public class CollectionSerializer> - extends TypeSerializer> -{ - - public static CollectionSerializer> listOf(TypeSerializer element) { - return new CollectionSerializer<>(List.class, element, ArrayList::new); - } - - public static CollectionSerializer> setOf(TypeSerializer element) { - return new CollectionSerializer<>(Set.class, element, HashSet::new); - } - - final TypeSerializer elementType; - final Function, C> collectionFactory; - - // cache example because - // its relatively expensive - // to compute correctly - final String example; - - @SuppressWarnings("unchecked") - protected CollectionSerializer(Class clazz, - TypeSerializer elementType, - Function, C> collectionFactory) { - super((Class) clazz); - this.elementType = (TypeSerializer) elementType; - this.collectionFactory = collectionFactory; - - // build example - StringBuilder b = new StringBuilder("["); - for (String elemStr : elementType.getExamples()) { - b.append(elemStr); - b.append(", "); - } - - this.example = b.delete(b.length() - 3, b.length()).append("]").toString(); - } - - public TypeSerializer getElementType() { - return elementType; - } - - @Override - public C deserialize(StringReader reader) throws CommandSyntaxException { - List list = new ArrayList<>(); - reader.expect('['); - reader.skipWhitespace(); - if (reader.peek() == ']') { // empty list - reader.skip(); - return collectionFactory.apply(list); - } - - while (reader.canRead()) { - E element = elementType.deserialize(reader); - list.add(element); - reader.skipWhitespace(); - if (reader.peek() == ']') - break; - reader.expect(','); - reader.skipWhitespace(); - } - - reader.skipWhitespace(); - reader.expect(']'); - - return collectionFactory.apply(list); - } - - @Override - public Collection getExamples() { - return List.of("[a, b, c]"); - } - - @Override - public CompletableFuture listSuggestions(CommandContext context, SuggestionsBuilder builder) { - String remaining = builder.getRemaining(); - - if (remaining.isBlank()) { - // suggest opening the list - builder.suggest("["); - } else { - builder.suggest(","); - builder.suggest("]"); - - // suggest element options - // the start index is the index - // of the last comma if open, otherwise - // it will be -1 and no elements will - // be suggested - // TODO: fix because this doesnt work for some reason - StringReader inputParser = new StringReader(remaining); - int startIndex = -1; - try { - inputParser.skip(); // [ - while (inputParser.canRead()) { - // skip element - int oldCursor = inputParser.getCursor(); - try { - elementType.deserialize(inputParser); - } catch (CommandSyntaxException ignored) { } - if (oldCursor == inputParser.getCursor()) - break; - inputParser.skipWhitespace(); - - // skip and register comma - if (inputParser.peek() == ',') { - startIndex = inputParser.getCursor(); - } - - inputParser.skip(); - if (!inputParser.canRead()) - break; - - // end on closer - if (inputParser.peek() == ']') { - startIndex = -1; - break; - } - - inputParser.skipWhitespace(); - } - } catch (Exception e) { - startIndex = -1; - } - - if (startIndex != -1) { - SuggestionsBuilder b2 = new SuggestionsBuilder( - remaining, - remaining.toLowerCase(), - startIndex + 1); - - elementType.listSuggestions(context, b2); - builder.add(b2); - } - } - - return builder.buildFuture(); - } - - @Override - @SuppressWarnings({ "rawtypes", "unchecked" }) - public C deserialize(List in) { - List elementList = in.stream() - .map(elementType::deserialize) - .toList(); - return collectionFactory.apply(elementList); - } - - @Override - public List serialize(C value) { - return value - .stream() - .map(elementType::serialize) - .toList(); - } - -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/ColoredBlockTypeSerializer.java b/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/ColoredBlockTypeSerializer.java deleted file mode 100644 index 3b7b6e99..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/ColoredBlockTypeSerializer.java +++ /dev/null @@ -1,15 +0,0 @@ -package tools.redstone.redstonetools.features.arguments.serializers; - -import tools.redstone.redstonetools.utils.ColoredBlockType; - -public class ColoredBlockTypeSerializer extends EnumSerializer { - private static final ColoredBlockTypeSerializer INSTANCE = new ColoredBlockTypeSerializer(); - - private ColoredBlockTypeSerializer() { - super(ColoredBlockType.class); - } - - public static ColoredBlockTypeSerializer coloredBlockType() { - return INSTANCE; - } -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/DirectionSerializer.java b/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/DirectionSerializer.java deleted file mode 100644 index 9a2f3b36..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/DirectionSerializer.java +++ /dev/null @@ -1,15 +0,0 @@ -package tools.redstone.redstonetools.features.arguments.serializers; - -import tools.redstone.redstonetools.utils.DirectionArgument; - -public class DirectionSerializer extends EnumSerializer { - private static final DirectionSerializer INSTANCE = new DirectionSerializer(); - - private DirectionSerializer() { - super(DirectionArgument.class); - } - - public static DirectionSerializer direction() { - return INSTANCE; - } -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/DoubleSerializer.java b/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/DoubleSerializer.java deleted file mode 100644 index 86daafa0..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/DoubleSerializer.java +++ /dev/null @@ -1,31 +0,0 @@ -package tools.redstone.redstonetools.features.arguments.serializers; - -import com.mojang.brigadier.arguments.ArgumentType; -import com.mojang.brigadier.arguments.DoubleArgumentType; - -public class DoubleSerializer extends StringBrigadierSerializer { - - private static final DoubleSerializer INSTANCE = new DoubleSerializer(DoubleArgumentType.doubleArg()); - - public static DoubleSerializer doubleArg() { - return INSTANCE; - } - - public static DoubleSerializer doubleArg(double min) { - return new DoubleSerializer(DoubleArgumentType.doubleArg(min)); - } - - public static DoubleSerializer doubleArg(double min, double max) { - return new DoubleSerializer(DoubleArgumentType.doubleArg(min, max)); - } - - private DoubleSerializer(ArgumentType argumentType) { - super(Double.class, argumentType); - } - - @Override - public String serialize(Double value) { - return String.valueOf(value); - } - -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/EnumSerializer.java b/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/EnumSerializer.java deleted file mode 100644 index be6d2e92..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/EnumSerializer.java +++ /dev/null @@ -1,80 +0,0 @@ -package tools.redstone.redstonetools.features.arguments.serializers; - -import com.mojang.brigadier.StringReader; -import com.mojang.brigadier.context.CommandContext; -import com.mojang.brigadier.exceptions.CommandSyntaxException; -import com.mojang.brigadier.suggestion.Suggestions; -import com.mojang.brigadier.suggestion.SuggestionsBuilder; -import net.minecraft.text.Text; - -import java.util.Collection; -import java.util.EnumSet; -import java.util.concurrent.CompletableFuture; - -public abstract class EnumSerializer> - extends TypeSerializer { - - protected EnumSerializer(Class clazz) { - super(clazz); - } - - // common method for stringification - // of the enum constants, can be overridden - @Override - public String serialize(T value) { - return value.toString(); - } - - @Override - public T deserialize(StringReader reader) throws CommandSyntaxException { - var input = reader.readUnquotedString(); - - try { - return deserialize(input); - } catch (IllegalArgumentException e) { - throw new CommandSyntaxException(null, Text.of(e.getMessage())); - } - } - - @Override - public T deserialize(String input) { - String inputLowerCase = input.toLowerCase(); - - var matches = EnumSet.allOf(clazz) - .stream() - .filter(elem -> serialize(elem).toLowerCase().startsWith(inputLowerCase)) - .toList(); - - var exactMatch = matches.stream().filter(elem -> serialize(elem).toLowerCase().equals(input)).findFirst(); - if (exactMatch.isPresent()) { - return exactMatch.get(); - } - - if (matches.isEmpty()) { - throw new IllegalArgumentException("No such option '" + input + "'"); - } - - if (matches.size() > 1) { - throw new IllegalArgumentException("Ambiguous option '" + input + "'"); - } - - return matches.get(0); - } - - @Override - public Collection getExamples() { - return EnumSet.allOf(clazz).stream() - .map(this::serialize) - .toList(); - } - - @Override - public CompletableFuture listSuggestions(CommandContext context, SuggestionsBuilder builder) { - for (var value : EnumSet.allOf(clazz)) { - builder = builder.suggest(serialize(value)); - } - - return builder.buildFuture(); - } - -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/FloatSerializer.java b/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/FloatSerializer.java deleted file mode 100644 index 3511e418..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/FloatSerializer.java +++ /dev/null @@ -1,31 +0,0 @@ -package tools.redstone.redstonetools.features.arguments.serializers; - -import com.mojang.brigadier.arguments.ArgumentType; -import com.mojang.brigadier.arguments.FloatArgumentType; - -public class FloatSerializer extends StringBrigadierSerializer { - - private static final FloatSerializer INSTANCE = new FloatSerializer(FloatArgumentType.floatArg()); - - public static FloatSerializer floatArg() { - return INSTANCE; - } - - public static FloatSerializer floatArg(float min) { - return new FloatSerializer(FloatArgumentType.floatArg(min)); - } - - public static FloatSerializer floatArg(float min, float max) { - return new FloatSerializer(FloatArgumentType.floatArg(min, max)); - } - - private FloatSerializer(ArgumentType argumentType) { - super(Float.class, argumentType); - } - - @Override - public String serialize(Float value) { - return String.valueOf(value); - } - -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/IntLikeSerializer.java b/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/IntLikeSerializer.java deleted file mode 100644 index 0cfc6974..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/IntLikeSerializer.java +++ /dev/null @@ -1,129 +0,0 @@ -package tools.redstone.redstonetools.features.arguments.serializers; - -import com.mojang.brigadier.StringReader; -import com.mojang.brigadier.context.CommandContext; -import com.mojang.brigadier.exceptions.CommandSyntaxException; -import com.mojang.brigadier.suggestion.Suggestions; -import com.mojang.brigadier.suggestion.SuggestionsBuilder; -import net.minecraft.text.Text; -import tools.redstone.redstonetools.utils.NumberBase; - -import java.util.Collection; -import java.util.Collections; -import java.util.Optional; -import java.util.concurrent.CompletableFuture; - -public abstract class IntLikeSerializer> extends TypeSerializer { - private final T min; - private final boolean hasMin; - private final T max; - private final boolean hasMax; - - protected IntLikeSerializer(Class clazz, T min, T max) { - super(clazz); - - this.min = min; - hasMin = min != null; - this.max = max; - hasMax = max != null; - } - - @Override - public T deserialize(StringReader reader) throws CommandSyntaxException { - var input = reader.readUnquotedString(); - - try { - return deserialize(input); - } catch (IllegalArgumentException e) { - throw new CommandSyntaxException(null, Text.of(e.getMessage())); - } - } - - @Override - public T deserialize(String serialized) { - var value = deserializeUnchecked(serialized); - - if (hasMin && value.compareTo(min) < 0) { - throw new IllegalArgumentException(value + " is below the minimum of " + min + "."); - } else if (hasMax && value.compareTo(max) > 0) { - throw new IllegalArgumentException(value + " is above the maximum of " + max + "."); - } - - return value; - } - - private T deserializeUnchecked(String serialized) { - boolean isNegative = false; - if (serialized.length() == 1) { - return tryParse(serialized); - } - - if(serialized.charAt(0) == '-' && serialized.chars().filter(ch -> ch == '-').count() == 1){ - isNegative = true; - serialized = serialized.replace("-",""); - } - - if (serialized.charAt(0) == '0') { - if(serialized.length() > 1) { - var prefixedBase = serialized.substring(0, 2); - var number = serialized.substring(2); - - var numberBase = NumberBase.fromPrefix(prefixedBase).orElse(null); - - if (numberBase != null) { - return isNegative ? tryParse("-" + number, numberBase.toInt()) : tryParse(number, numberBase.toInt()); - } - } else { - return tryParse(serialized,10); - } - } - - var parts = serialized.split("_", 2); - if (parts.length == 2) { - var number = parts[0]; - - int base; - try { - base = Integer.parseInt(parts[1]); - - if (2 > base || base > 36) { - throw new NumberFormatException(); - } - } catch (NumberFormatException ignored) { - throw new IllegalArgumentException("Invalid base '" + parts[1] + "'."); - } - - return isNegative ? tryParse("-"+number, base) : tryParse(number, base); - } - - return isNegative ? tryParse("-"+serialized) : tryParse(serialized); - } - - private T tryParse(String string) { - return tryParse(string, 10); - } - - private T tryParse(String string, int radix) { - return tryParseOptional(string, radix) - .orElseThrow(() -> new IllegalArgumentException(radix == 10 - ? "Invalid number '" + string + "'." - : "Invalid base " + radix + " number '" + string + "'.")); - } - - protected abstract Optional tryParseOptional(String string, int radix); - - @Override - public String serialize(T value) { - return String.valueOf(value); - } - - @Override - public Collection getExamples() { - return Collections.emptyList(); - } - - @Override - public CompletableFuture listSuggestions(CommandContext context, SuggestionsBuilder builder) { - return builder.buildFuture(); - } -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/IntegerSerializer.java b/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/IntegerSerializer.java deleted file mode 100644 index 8a53cf08..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/IntegerSerializer.java +++ /dev/null @@ -1,32 +0,0 @@ -package tools.redstone.redstonetools.features.arguments.serializers; - -import java.util.Optional; - -public class IntegerSerializer extends IntLikeSerializer { - private static final IntegerSerializer INSTANCE = new IntegerSerializer(Integer.MIN_VALUE, Integer.MAX_VALUE); - - public static IntegerSerializer integer() { - return INSTANCE; - } - - public static IntegerSerializer integer(int min) { - return new IntegerSerializer(min, Integer.MAX_VALUE); - } - - public static IntegerSerializer integer(int min, int max) { - return new IntegerSerializer(min, max); - } - - private IntegerSerializer(int min, int max) { - super(Integer.class, min, max); - } - - @Override - protected Optional tryParseOptional(String string, int radix) { - try { - return Optional.of(Integer.parseInt(string, radix)); - } catch (NumberFormatException ignored) { - return Optional.empty(); - } - } -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/LongSerializer.java b/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/LongSerializer.java deleted file mode 100644 index 43516d84..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/LongSerializer.java +++ /dev/null @@ -1,32 +0,0 @@ -package tools.redstone.redstonetools.features.arguments.serializers; - -import java.util.Optional; - -public class LongSerializer extends IntLikeSerializer { - private static final LongSerializer INSTANCE = new LongSerializer(Long.MIN_VALUE, Long.MAX_VALUE); - - public static LongSerializer longArg() { - return INSTANCE; - } - - public static LongSerializer longArg(long min) { - return new LongSerializer(min, Long.MAX_VALUE); - } - - public static LongSerializer longArg(long min, long max) { - return new LongSerializer(min, max); - } - - private LongSerializer(long min, long max) { - super(Long.class, min, max); - } - - @Override - protected Optional tryParseOptional(String string, int radix) { - try { - return Optional.of(Long.parseLong(string, radix)); - } catch (NumberFormatException ignored) { - return Optional.empty(); - } - } -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/MacroNameSerializer.java b/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/MacroNameSerializer.java deleted file mode 100644 index 2d4c697c..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/MacroNameSerializer.java +++ /dev/null @@ -1,35 +0,0 @@ -package tools.redstone.redstonetools.features.arguments.serializers; - -import tools.redstone.redstonetools.macros.MacroManager; -import com.mojang.brigadier.context.CommandContext; -import com.mojang.brigadier.suggestion.Suggestions; -import com.mojang.brigadier.suggestion.SuggestionsBuilder; -import java.util.concurrent.CompletableFuture; - -import static tools.redstone.redstonetools.RedstoneToolsClient.INJECTOR; - - -public class MacroNameSerializer extends StringSerializer { - private static final MacroNameSerializer INSTANCE = new MacroNameSerializer(); - - private MacroNameSerializer() { - - super(StringSerializer.greedyString()); - - } - - public static MacroNameSerializer macroName() { - return INSTANCE; - } - - @Override - public CompletableFuture listSuggestions(CommandContext context, SuggestionsBuilder builder) { - - for (var macro : INJECTOR.getInstance(MacroManager.class).getMacros()) { - - builder = builder.suggest(serialize(macro.name)); - } - - return builder.buildFuture(); - } -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/NumberBaseSerializer.java b/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/NumberBaseSerializer.java deleted file mode 100644 index 87126ee2..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/NumberBaseSerializer.java +++ /dev/null @@ -1,75 +0,0 @@ -package tools.redstone.redstonetools.features.arguments.serializers; - -import com.mojang.brigadier.StringReader; -import com.mojang.brigadier.context.CommandContext; -import com.mojang.brigadier.exceptions.CommandSyntaxException; -import com.mojang.brigadier.suggestion.Suggestions; -import com.mojang.brigadier.suggestion.SuggestionsBuilder; -import net.minecraft.text.Text; -import tools.redstone.redstonetools.utils.NumberBase; - -import java.util.Arrays; -import java.util.Collection; -import java.util.concurrent.CompletableFuture; - -public class NumberBaseSerializer extends TypeSerializer { - private static final IntegerSerializer INT_SERIALIZER = IntegerSerializer.integer(2, 36); - private static final NumberBaseSerializer INSTANCE = new NumberBaseSerializer(); - - public static NumberBaseSerializer numberBase() { - return INSTANCE; - } - - protected NumberBaseSerializer() { - super(Integer.class); - } - - @Override - public Integer deserialize(StringReader reader) throws CommandSyntaxException { - var input = reader.readUnquotedString(); - - try { - return deserialize(input); - } catch (IllegalArgumentException e) { - throw new CommandSyntaxException(null, Text.of(e.getMessage())); - } - } - - @Override - public Integer deserialize(String serialized) { - try { - return NumberBase.fromString(serialized) - .map(NumberBase::toInt) - .orElseGet(() -> INT_SERIALIZER.deserialize(serialized)); - } catch (IllegalArgumentException e) { - throw new IllegalArgumentException("Invalid base '" + serialized + "'.", e); - } - } - - @Override - public String serialize(Integer value) { - return NumberBase.fromInt(value) - .map(NumberBase::toString) - .orElseGet(() -> INT_SERIALIZER.serialize(value)); - } - - public String serialize(NumberBase value) { - return serialize(value.toInt()); - } - - @Override - public Collection getExamples() { - return Arrays.stream(NumberBase.values()) - .map(this::serialize) - .toList(); - } - - @Override - public CompletableFuture listSuggestions(CommandContext context, SuggestionsBuilder builder) { - for (var value : NumberBase.values()) { - builder = builder.suggest(serialize(value)); - } - - return builder.buildFuture(); - } -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/NumberSerializer.java b/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/NumberSerializer.java deleted file mode 100644 index 320eb217..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/NumberSerializer.java +++ /dev/null @@ -1,34 +0,0 @@ -package tools.redstone.redstonetools.features.arguments.serializers; - -import tools.redstone.redstonetools.utils.NumberArg; - -import java.util.Optional; - -public class NumberSerializer extends IntLikeSerializer { - private static final NumberSerializer INSTANCE = new NumberSerializer(null,null); - - public static NumberSerializer numberArg(){ - return INSTANCE; - } - - public static NumberSerializer numberArg(NumberArg min) { - return new NumberSerializer(min, null); - } - - public static NumberSerializer numberArg(NumberArg min, NumberArg max) { - return new NumberSerializer(min, max); - } - - private NumberSerializer(NumberArg min, NumberArg max){ - super(NumberArg.class,min, max); - } - - @Override - protected Optional tryParseOptional(String string, int radix) { - try { - return Optional.of(new NumberArg(string, radix)); - } catch (NumberFormatException ignored) { - return Optional.empty(); - } - } -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/SignalBlockSerializer.java b/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/SignalBlockSerializer.java deleted file mode 100644 index 14c12ad3..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/SignalBlockSerializer.java +++ /dev/null @@ -1,15 +0,0 @@ -package tools.redstone.redstonetools.features.arguments.serializers; - -import tools.redstone.redstonetools.utils.SignalBlock; - -public class SignalBlockSerializer extends EnumSerializer { - private static final SignalBlockSerializer INSTANCE = new SignalBlockSerializer(); - - private SignalBlockSerializer() { - super(SignalBlock.class); - } - - public static SignalBlockSerializer signalBlock() { - return INSTANCE; - } -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/StringBrigadierSerializer.java b/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/StringBrigadierSerializer.java deleted file mode 100644 index f5dba14b..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/StringBrigadierSerializer.java +++ /dev/null @@ -1,22 +0,0 @@ -package tools.redstone.redstonetools.features.arguments.serializers; - -import com.mojang.brigadier.StringReader; -import com.mojang.brigadier.arguments.ArgumentType; -import com.mojang.brigadier.exceptions.CommandSyntaxException; - -public abstract class StringBrigadierSerializer extends BrigadierSerializer { - - public StringBrigadierSerializer(Class clazz, ArgumentType argumentType) { - super(clazz, argumentType); - } - - @Override - public T deserialize(String serialized) { - try { - return deserialize(new StringReader(serialized)); - } catch (CommandSyntaxException e) { - throw new IllegalStateException("Syntax Exception: " + e.getMessage()); - } - } - -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/StringSerializer.java b/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/StringSerializer.java deleted file mode 100644 index a7ddbf29..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/StringSerializer.java +++ /dev/null @@ -1,34 +0,0 @@ -package tools.redstone.redstonetools.features.arguments.serializers; - -import com.mojang.brigadier.arguments.ArgumentType; -import com.mojang.brigadier.arguments.StringArgumentType; - -public class StringSerializer extends StringBrigadierSerializer { - - private static final StringSerializer INSTANCE_WORD = new StringSerializer(StringArgumentType.word()); - private static final StringSerializer INSTANCE_STRING = new StringSerializer(StringArgumentType.string()); - private static final StringSerializer INSTANCE_GREEDY_STRING = new StringSerializer(StringArgumentType.greedyString()); - - public static StringSerializer string() { - return INSTANCE_STRING; - } - - public static StringSerializer word() { - return INSTANCE_WORD; - } - - public static StringSerializer greedyString() { - return INSTANCE_GREEDY_STRING; - } - - protected StringSerializer(ArgumentType argumentType) { - super(String.class, argumentType); - } - - @Override - public String serialize(String value) { - // TODO: Check if this is correct, doesn't StringArgumentType.string() require quotes which this doesn't add? - return value; - } - -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/TypeSerializer.java b/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/TypeSerializer.java deleted file mode 100644 index 9796c052..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/features/arguments/serializers/TypeSerializer.java +++ /dev/null @@ -1,47 +0,0 @@ -package tools.redstone.redstonetools.features.arguments.serializers; - -import com.mojang.brigadier.StringReader; -import com.mojang.brigadier.arguments.ArgumentType; -import com.mojang.brigadier.context.CommandContext; -import com.mojang.brigadier.exceptions.CommandSyntaxException; -import com.mojang.brigadier.suggestion.Suggestions; -import com.mojang.brigadier.suggestion.SuggestionsBuilder; - -import java.util.Collection; -import java.util.concurrent.CompletableFuture; - -/** - * Base class for the 'wrapped' argument type. - * - * @param The value type. - * @param The serialized type. - */ -public abstract class TypeSerializer implements ArgumentType { - - protected final Class clazz; - - // TODO: Consider moving this constructor to enum serializer as it's the only class that uses the clazz field - protected TypeSerializer(Class clazz) { - this.clazz = clazz; - } - - public Class getTypeClass() { - return clazz; - } - - /* ArgumentType impl */ - @Override - public final T parse(StringReader reader) throws CommandSyntaxException { - return deserialize(reader); - } - - /* String Serialization */ - public abstract T deserialize(StringReader reader) throws CommandSyntaxException; - public abstract T deserialize(S serialized); - public abstract S serialize(T value); - - /* Usage In Commands */ - public abstract Collection getExamples(); - public abstract CompletableFuture listSuggestions(CommandContext context, SuggestionsBuilder builder); - -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/commands/BaseConvertFeature.java b/oldSrc/main/java/tools/redstone/redstonetools/features/commands/BaseConvertFeature.java deleted file mode 100644 index 818d4203..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/features/commands/BaseConvertFeature.java +++ /dev/null @@ -1,32 +0,0 @@ -package tools.redstone.redstonetools.features.commands; - -import com.google.auto.service.AutoService; -import net.minecraft.server.command.ServerCommandSource; -import tools.redstone.redstonetools.features.AbstractFeature; -import tools.redstone.redstonetools.features.Feature; -import tools.redstone.redstonetools.features.arguments.Argument; -import tools.redstone.redstonetools.features.feedback.Feedback; -import tools.redstone.redstonetools.utils.NumberArg; - - -import static tools.redstone.redstonetools.features.arguments.serializers.NumberBaseSerializer.numberBase; -import static tools.redstone.redstonetools.features.arguments.serializers.NumberSerializer.numberArg; - -@AutoService(AbstractFeature.class) -@Feature(name = "Base Convert", description = "Converts a number from one base to another.", command = "base") -public class BaseConvertFeature extends CommandFeature { - - public static final Argument inputNum = Argument - .ofType(numberArg()); - public static final Argument toBase = Argument - .ofType(numberBase()) - .withDefault(10); - - @Override - protected Feedback execute(ServerCommandSource source) { - var input = inputNum.getValue().toPrefixedString(); - var output = inputNum.getValue().toPrefixedString(toBase.getValue()); - - return Feedback.success("{} = {}", input, output); - } -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/commands/BinaryBlockReadFeature.java b/oldSrc/main/java/tools/redstone/redstonetools/features/commands/BinaryBlockReadFeature.java deleted file mode 100644 index 808f5d10..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/features/commands/BinaryBlockReadFeature.java +++ /dev/null @@ -1,101 +0,0 @@ -package tools.redstone.redstonetools.features.commands; - -import com.google.auto.service.AutoService; -import tools.redstone.redstonetools.features.AbstractFeature; -import tools.redstone.redstonetools.features.Feature; -import tools.redstone.redstonetools.features.arguments.Argument; -import tools.redstone.redstonetools.features.feedback.Feedback; -import tools.redstone.redstonetools.utils.WorldEditUtils; -import com.mojang.brigadier.exceptions.CommandSyntaxException; -import com.sk89q.worldedit.math.BlockVector3; -import net.minecraft.block.Blocks; -import net.minecraft.block.RedstoneLampBlock; -import net.minecraft.command.argument.BlockStateArgument; -import net.minecraft.server.command.ServerCommandSource; -import net.minecraft.util.math.BlockPos; - -import java.util.Collections; - -import static tools.redstone.redstonetools.features.arguments.serializers.BlockStateArgumentSerializer.blockState; -import static tools.redstone.redstonetools.features.arguments.serializers.BoolSerializer.bool; -import static tools.redstone.redstonetools.features.arguments.serializers.IntegerSerializer.integer; -import static tools.redstone.redstonetools.features.arguments.serializers.NumberBaseSerializer.numberBase; - -@AutoService(AbstractFeature.class) -@Feature(name = "Binary Block Read", description = "Interprets your WorldEdit selection as a binary number.", command = "/read", worldedit = true) -public class BinaryBlockReadFeature extends CommandFeature { - private static final BlockStateArgument LIT_LAMP_ARG = new BlockStateArgument( - Blocks.REDSTONE_LAMP.getDefaultState().with(RedstoneLampBlock.LIT, true), - Collections.singleton(RedstoneLampBlock.LIT), - null - ); - - public static final Argument offset = Argument - .ofType(integer(1)) - .withDefault(2); - public static final Argument onBlock = Argument - .ofType(blockState()) - .withDefault(LIT_LAMP_ARG); - public static final Argument toBase = Argument - .ofType(numberBase()) - .withDefault(10); - public static final Argument reverseBits = Argument - .ofType(bool()) - .withDefault(false); - - @Override - protected Feedback execute(ServerCommandSource source) throws CommandSyntaxException { - var selectionOrFeedback = WorldEditUtils.getSelection(source.getPlayer()); - - if (selectionOrFeedback.right().isPresent()) { - return selectionOrFeedback.right().get(); - } - - assert selectionOrFeedback.left().isPresent(); - var selection = selectionOrFeedback.left().get(); - - var boundingBox = selection.getBoundingBox(); - var pos1 = boundingBox.getPos1(); - var pos2 = boundingBox.getPos2(); - var direction = pos2.subtract(pos1).normalize(); - - // prevent infinite loop - if (direction.lengthSq() == 0) { - direction = BlockVector3.at(0, 0, 1); - } - - var spacingVector = direction.multiply(offset.getValue()); - - if (direction.getBlockX() + direction.getBlockY() + direction.getBlockZ() > 1) { - return Feedback.invalidUsage("The selection must have 2 axis the same."); - } - - var bits = new StringBuilder(); - for (BlockVector3 point = pos1; boundingBox.contains(point); point = point.add(spacingVector)) { - var pos = new BlockPos(point.getBlockX(), point.getBlockY(), point.getBlockZ()); - var actualState = source.getWorld().getBlockState(pos); - - var matches = actualState.getBlock() == onBlock.getValue().getBlockState().getBlock(); - if (matches) { - for (var property : onBlock.getValue().getProperties()) { - var propertyValue = onBlock.getValue().getBlockState().get(property); - - if (!actualState.get(property).equals(propertyValue)) { - matches = false; - break; - } - } - } - - bits.append(matches ? 1 : 0); - } - - if (reverseBits.getValue()) { - bits.reverse(); - } - - var output = Integer.toString(Integer.parseInt(bits.toString(), 2), toBase.getValue()); - return Feedback.success("{}.", output); - } - -} \ No newline at end of file diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/commands/BlockRaycastFeature.java b/oldSrc/main/java/tools/redstone/redstonetools/features/commands/BlockRaycastFeature.java deleted file mode 100644 index d8c1b842..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/features/commands/BlockRaycastFeature.java +++ /dev/null @@ -1,42 +0,0 @@ -package tools.redstone.redstonetools.features.commands; - -import tools.redstone.redstonetools.features.feedback.Feedback; -import tools.redstone.redstonetools.utils.BlockInfo; -import com.mojang.brigadier.exceptions.CommandSyntaxException; -import net.minecraft.client.MinecraftClient; -import net.minecraft.server.command.ServerCommandSource; -import net.minecraft.text.Text; -import net.minecraft.util.hit.BlockHitResult; -import net.minecraft.util.hit.HitResult; - -import javax.annotation.Nullable; - -public abstract class BlockRaycastFeature extends CommandFeature { - protected Feedback execute(ServerCommandSource source) throws CommandSyntaxException { - MinecraftClient client = MinecraftClient.getInstance(); - if (client.player == null || client.world == null) { - throw new CommandSyntaxException(null, Text.of("This command is client-side only.")); - } - - if (client.crosshairTarget == null || client.crosshairTarget.getType() != HitResult.Type.BLOCK) { - if (requiresBlock()) { - return Feedback.invalidUsage("You must be looking at a block to use this command."); - } else { - return execute(source, null); - } - } - - var blockPos = ((BlockHitResult) client.crosshairTarget).getBlockPos(); - var blockState = client.world.getBlockState(blockPos); - var blockEntity = client.world.getBlockEntity(blockPos); - var block = blockState.getBlock(); - - return execute(source, new BlockInfo(block, blockPos, blockState, blockEntity)); - } - - protected boolean requiresBlock() { - return true; - } - - protected abstract Feedback execute(ServerCommandSource source, @Nullable BlockInfo blockInfo) throws CommandSyntaxException; -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/commands/ColorCodeFeature.java b/oldSrc/main/java/tools/redstone/redstonetools/features/commands/ColorCodeFeature.java deleted file mode 100644 index 00742feb..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/features/commands/ColorCodeFeature.java +++ /dev/null @@ -1,113 +0,0 @@ -package tools.redstone.redstonetools.features.commands; - -import com.google.auto.service.AutoService; -import tools.redstone.redstonetools.features.AbstractFeature; -import tools.redstone.redstonetools.features.Feature; -import tools.redstone.redstonetools.features.arguments.Argument; -import tools.redstone.redstonetools.features.feedback.Feedback; -import tools.redstone.redstonetools.utils.BlockColor; -import tools.redstone.redstonetools.utils.ColoredBlock; -import tools.redstone.redstonetools.utils.WorldEditUtils; -import com.mojang.brigadier.exceptions.CommandSyntaxException; -import com.sk89q.worldedit.EditSession; -import com.sk89q.worldedit.WorldEdit; -import com.sk89q.worldedit.fabric.FabricAdapter; -import com.sk89q.worldedit.function.mask.Mask; -import com.sk89q.worldedit.function.mask.Mask2D; -import com.sk89q.worldedit.function.operation.Operations; -import com.sk89q.worldedit.math.BlockVector3; -import com.sk89q.worldedit.world.World; -import com.sk89q.worldedit.world.block.BaseBlock; -import com.sk89q.worldedit.world.block.BlockType; -import net.minecraft.server.command.ServerCommandSource; -import org.jetbrains.annotations.Nullable; -import static tools.redstone.redstonetools.features.arguments.serializers.BlockColorSerializer.blockColor; - -@AutoService(AbstractFeature.class) -@Feature(name = "Color Code", description = "Color codes all color-able blocks in your WorldEdit selection.", command = "/colorcode", worldedit = true) -public class ColorCodeFeature extends CommandFeature { - public static final Argument color = Argument - .ofType(blockColor()); - public static final Argument onlyColor = Argument - .ofType(blockColor()) - .withDefault(null); - - private boolean shouldBeColored(World world, BlockVector3 pos, BlockColor onlyColor) { - var state = world.getBlock(pos); - var blockId = state.getBlockType().getId(); - - var coloredBlock = ColoredBlock.fromBlockId(blockId); - if (coloredBlock == null) return false; - - if (onlyColor == null) return true; - - var blockColor = coloredBlock.color; - return blockColor == onlyColor; - } - - private BaseBlock getColoredBlock(World world, BlockVector3 pos, BlockColor color) { - var state = world.getBlock(pos); - var blockId = state.getBlockType().getId(); - - var coloredBlock = ColoredBlock.fromBlockId(blockId); - if (coloredBlock == null) return state.toBaseBlock(); - - var blockType = BlockType.REGISTRY.get(coloredBlock.withColor(color).toBlockId()); - assert blockType != null; - - return blockType.getDefaultState().toBaseBlock(); - } - - @Override - protected Feedback execute(ServerCommandSource source) throws CommandSyntaxException { - var player = source.getPlayer(); - - var selectionOrFeedback = WorldEditUtils.getSelection(player); - if (selectionOrFeedback.right().isPresent()) { - return selectionOrFeedback.right().get(); - } - - assert selectionOrFeedback.left().isPresent(); - var selection = selectionOrFeedback.left().get(); - - var worldEdit = WorldEdit.getInstance(); - var wePlayer = FabricAdapter.adaptPlayer(player); - var playerSession = worldEdit.getSessionManager().get(wePlayer); - - // for each block in the selection - final World world = FabricAdapter.adapt(player.getWorld()); - try (EditSession session = worldEdit.newEditSession(FabricAdapter.adapt(player.getWorld()))) { - // create mask and pattern and execute block set - int blocksColored = session.replaceBlocks(selection, - new Mask() { - @Override - public boolean test(BlockVector3 vector) { - return shouldBeColored(world, vector, onlyColor.getValue()); - } - - @Nullable - @Override - public Mask2D toMask2D() { - return null; - } - }, - new com.sk89q.worldedit.function.pattern.Pattern() { - @Override - public BaseBlock applyBlock(BlockVector3 position) { - return getColoredBlock(world, position, color.getValue()); - } - } - ); - - Operations.complete(session.commit()); - - // call remember to allow undo - playerSession.remember(session); - - return Feedback.success("Successfully colored {} block(s) {}.", blocksColored, color.getValue()); - } catch (Exception e) { - return Feedback.error("An error occurred while coloring the block(s)."); - } - } - -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/commands/ColoredFeature.java b/oldSrc/main/java/tools/redstone/redstonetools/features/commands/ColoredFeature.java deleted file mode 100644 index d7505c29..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/features/commands/ColoredFeature.java +++ /dev/null @@ -1,38 +0,0 @@ -package tools.redstone.redstonetools.features.commands; - -import com.google.auto.service.AutoService; -import tools.redstone.redstonetools.features.AbstractFeature; -import tools.redstone.redstonetools.features.Feature; -import tools.redstone.redstonetools.features.arguments.Argument; -import tools.redstone.redstonetools.features.feedback.Feedback; -import tools.redstone.redstonetools.utils.BlockColor; -import tools.redstone.redstonetools.utils.BlockInfo; -import com.mojang.datafixers.util.Either; -import net.minecraft.item.ItemStack; -import net.minecraft.server.command.ServerCommandSource; -import tools.redstone.redstonetools.utils.ColoredBlockType; - -import javax.annotation.Nullable; - -import static tools.redstone.redstonetools.features.arguments.serializers.ColoredBlockTypeSerializer.coloredBlockType; - -@AutoService(AbstractFeature.class) -@Feature(name = "Colored", description = "Gives the player specified variant of block being looked at, with the same color. Default is White.", command = "colored") -public class ColoredFeature extends PickBlockFeature { - public static final Argument blockType = Argument.ofType(coloredBlockType()); - @Override - protected boolean requiresBlock() { - return false; - } - - @Override - protected Either getItemStack(ServerCommandSource source, @Nullable BlockInfo blockInfo) { - var color = blockInfo == null - ? BlockColor.WHITE - : BlockColor.fromBlock(blockInfo.block); - - var coloredBlock = blockType.getValue().withColor(color); - - return Either.left(new ItemStack(coloredBlock.toBlock())); - } -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/commands/CommandFeature.java b/oldSrc/main/java/tools/redstone/redstonetools/features/commands/CommandFeature.java deleted file mode 100644 index cc5f9412..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/features/commands/CommandFeature.java +++ /dev/null @@ -1,78 +0,0 @@ -package tools.redstone.redstonetools.features.commands; - -import net.fabricmc.fabric.api.client.event.lifecycle.v1.ClientTickEvents; -import net.fabricmc.fabric.api.client.keybinding.v1.KeyBindingHelper; -import net.minecraft.client.option.KeyBinding; -import net.minecraft.client.util.InputUtil; -import tools.redstone.redstonetools.features.AbstractFeature; -import tools.redstone.redstonetools.features.feedback.AbstractFeedbackSender; -import tools.redstone.redstonetools.features.feedback.Feedback; -import tools.redstone.redstonetools.utils.CommandUtils; -import tools.redstone.redstonetools.utils.ReflectionUtils; -import com.mojang.brigadier.CommandDispatcher; -import com.mojang.brigadier.exceptions.CommandSyntaxException; -import net.minecraft.server.command.ServerCommandSource; - -import java.util.ArrayList; -import java.util.List; - -import static tools.redstone.redstonetools.RedstoneToolsClient.INJECTOR; - - -public abstract class CommandFeature extends AbstractFeature { - private static final List keyBindings = new ArrayList<>(); - - @Override - public void register() { - super.register(); - - var containsRequiredArguments = ReflectionUtils.getArguments(getClass()).stream() - .anyMatch(a -> !a.isOptional()); - if (containsRequiredArguments) { - return; - } - - var info = ReflectionUtils.getFeatureInfo(getClass()); - var keyBinding = KeyBindingHelper.registerKeyBinding(new KeyBinding( - info.name(), - InputUtil.Type.KEYSYM, - -1, - "Redstone Tools" - )); - - keyBindings.add(keyBinding); - - ClientTickEvents.END_CLIENT_TICK.register(client -> { - while (keyBinding.wasPressed()) { - assert client.player != null; - client.player.sendChatMessage("/" + info.command()); - } - }); - } - - @Override - protected void registerCommands(CommandDispatcher dispatcher, boolean dedicated) { - var info = ReflectionUtils.getFeatureInfo(getClass()); - var arguments = ReflectionUtils.getArguments(getClass()); - - CommandUtils.register( - info.command(), - arguments, - context -> { - for (var argument : arguments) { - argument.updateValue(context); - } - - var feedback = execute(context.getSource()); - - INJECTOR.getInstance(AbstractFeedbackSender.class) - .sendFeedback(context.getSource(), feedback); - - return feedback.getType().getCode(); - }, - dispatcher, - dedicated); - } - - protected abstract Feedback execute(ServerCommandSource source) throws CommandSyntaxException; -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/commands/CopyStateFeature.java b/oldSrc/main/java/tools/redstone/redstonetools/features/commands/CopyStateFeature.java deleted file mode 100644 index 3e0a7cc3..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/features/commands/CopyStateFeature.java +++ /dev/null @@ -1,48 +0,0 @@ -package tools.redstone.redstonetools.features.commands; - -import com.google.auto.service.AutoService; -import com.mojang.datafixers.util.Either; -import net.minecraft.block.BlockState; -import net.minecraft.client.MinecraftClient; -import net.minecraft.item.ItemStack; -import net.minecraft.server.command.ServerCommandSource; -import tools.redstone.redstonetools.features.AbstractFeature; -import tools.redstone.redstonetools.features.Feature; -import tools.redstone.redstonetools.features.feedback.Feedback; -import tools.redstone.redstonetools.mixin.accessors.MinecraftClientAccessor; -import tools.redstone.redstonetools.utils.BlockInfo; -import tools.redstone.redstonetools.utils.BlockStateNbtUtil; - - -import static tools.redstone.redstonetools.utils.ItemUtils.addExtraNBTText; - - -@AutoService(AbstractFeature.class) -@Feature(name = "Copy State", description = "Gives you a copy of the block you're looking at with its BlockState.", command = "copystate") -public class CopyStateFeature extends PickBlockFeature { - @Override - protected Either getItemStack(ServerCommandSource source, BlockInfo blockInfo) { - MinecraftClient client = MinecraftClient.getInstance(); - - ItemStack itemStack = blockInfo.block.getPickStack(client.world, blockInfo.pos, blockInfo.state); - - if (blockInfo.state.hasBlockEntity()) { - ((MinecraftClientAccessor) client).invokeAddBlockEntityNbt(itemStack, blockInfo.entity); - } - - int i = addBlockStateNbt(itemStack, blockInfo.state); - if (i == -1) { - return Either.right(Feedback.invalidUsage("This block doesn't have any BlockState!")); - } - - return Either.left(itemStack); - } - - private int addBlockStateNbt(ItemStack itemStack, BlockState blockState) { - addExtraNBTText(itemStack, "BlockState"); - BlockStateNbtUtil.putPlacement(itemStack, blockState); - return 1; - } - - -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/commands/ItemBindFeature.java b/oldSrc/main/java/tools/redstone/redstonetools/features/commands/ItemBindFeature.java deleted file mode 100644 index 4403353b..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/features/commands/ItemBindFeature.java +++ /dev/null @@ -1,53 +0,0 @@ -package tools.redstone.redstonetools.features.commands; - - -import com.google.auto.service.AutoService; -import com.mojang.brigadier.exceptions.CommandSyntaxException; -import net.minecraft.client.MinecraftClient; -import net.minecraft.item.ItemStack; -import net.minecraft.item.Items; -import net.minecraft.nbt.NbtString; -import net.minecraft.server.command.ServerCommandSource; -import net.minecraft.server.network.ServerPlayerEntity; -import tools.redstone.redstonetools.features.AbstractFeature; -import tools.redstone.redstonetools.features.Feature; -import tools.redstone.redstonetools.features.feedback.Feedback; -import tools.redstone.redstonetools.utils.ItemUtils; - -@AutoService(AbstractFeature.class) -@Feature(command = "itembind", description = "Allows you to bind command to a specific item", name = "Item Bind") -public class ItemBindFeature extends CommandFeature{ - public static boolean waitingForCommand = false; - private static ServerPlayerEntity player; - - - @Override - protected Feedback execute(ServerCommandSource source) throws CommandSyntaxException { - - player = source.getPlayer(); - waitingForCommand = true; - - return Feedback.success("Please run any command and hold the item you want the command be bound to"); - } - - public static Feedback addCommand(String command) { - if (!waitingForCommand || MinecraftClient.getInstance().getServer() == null) return null; - - if (player == null || MinecraftClient.getInstance().getServer().getPlayerManager().getPlayer(player.getUuid()) != player) { - waitingForCommand = false; - return null; - } - - ItemStack mainHandStack = player.getMainHandStack(); - if (mainHandStack == null || mainHandStack.getItem() == Items.AIR) { - return Feedback.error("You need to be holding an item!"); - } - - mainHandStack.getOrCreateNbt().put("command", NbtString.of(command)); - ItemUtils.addExtraNBTText(mainHandStack,"Command"); - - waitingForCommand = false; - - return Feedback.success("Successfully bound command: '{}' to this item ({})!", command, mainHandStack.getItem()); - } -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/commands/MacroFeature.java b/oldSrc/main/java/tools/redstone/redstonetools/features/commands/MacroFeature.java deleted file mode 100644 index 6afa69ba..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/features/commands/MacroFeature.java +++ /dev/null @@ -1,31 +0,0 @@ -package tools.redstone.redstonetools.features.commands; - -import com.google.auto.service.AutoService; -import tools.redstone.redstonetools.features.AbstractFeature; -import tools.redstone.redstonetools.features.Feature; -import tools.redstone.redstonetools.features.arguments.Argument; -import tools.redstone.redstonetools.features.feedback.Feedback; -import tools.redstone.redstonetools.macros.MacroManager; -import com.mojang.brigadier.exceptions.CommandSyntaxException; -import net.minecraft.server.command.ServerCommandSource; -import static tools.redstone.redstonetools.RedstoneToolsClient.INJECTOR; -import static tools.redstone.redstonetools.features.arguments.serializers.MacroNameSerializer.macroName; - -@AutoService(AbstractFeature.class) -@Feature(command = "macro", description = "Allows you to execute a macro", name = "Macro") -public class MacroFeature extends CommandFeature { - public static final Argument macro = Argument.ofType(macroName()); - - @Override - protected Feedback execute(ServerCommandSource source) throws CommandSyntaxException { - var macroObj = INJECTOR.getInstance(MacroManager.class).getMacro(macro.getValue()); - - - if (macroObj == null) { - return Feedback.invalidUsage("Macro \"{}\" does not exist.", macro.getValue()); - } - - macroObj.run(); - return Feedback.none(); - } -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/commands/MinSelectionFeature.java b/oldSrc/main/java/tools/redstone/redstonetools/features/commands/MinSelectionFeature.java deleted file mode 100644 index 388da842..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/features/commands/MinSelectionFeature.java +++ /dev/null @@ -1,126 +0,0 @@ -package tools.redstone.redstonetools.features.commands; - -import com.google.auto.service.AutoService; -import tools.redstone.redstonetools.features.AbstractFeature; -import tools.redstone.redstonetools.features.Feature; -import tools.redstone.redstonetools.features.feedback.Feedback; -import tools.redstone.redstonetools.utils.WorldEditUtils; -import com.mojang.brigadier.exceptions.CommandSyntaxException; -import com.sk89q.worldedit.WorldEdit; -import com.sk89q.worldedit.fabric.FabricAdapter; -import com.sk89q.worldedit.math.BlockVector3; -import com.sk89q.worldedit.regions.CuboidRegion; -import com.sk89q.worldedit.regions.Region; -import com.sk89q.worldedit.regions.RegionOperationException; -import com.sk89q.worldedit.world.World; -import com.sk89q.worldedit.world.block.BlockTypes; -import net.minecraft.server.command.ServerCommandSource; -import net.minecraft.text.Text; - -import java.util.ArrayList; -import java.util.List; - -@AutoService(AbstractFeature.class) -@Feature(command = "/minsel", description = "Removes all air-only layers from a selection", name = "Minimize Selection", worldedit = true) -public class MinSelectionFeature extends CommandFeature { - - @Override - protected Feedback execute(ServerCommandSource source) throws CommandSyntaxException { - var selectionOrFeedback = WorldEditUtils.getSelection(source.getPlayer()); - if (selectionOrFeedback.right().isPresent()) { - return selectionOrFeedback.right().get(); - } - - assert selectionOrFeedback.left().isPresent(); - var selection = selectionOrFeedback.left().get(); - var selectionWorld = selection.getWorld(); - - var actor = FabricAdapter.adaptPlayer(source.getPlayer()); - - var localSession = WorldEdit.getInstance() - .getSessionManager() - .get(actor); - - var selector = localSession.getRegionSelector(selectionWorld); - - boolean isEmpty = true; - for (BlockVector3 point : selection) { - if (!selectionWorld.getBlock(point).equals(BlockTypes.AIR.getDefaultState())) - isEmpty = false; - } - - if (isEmpty) { - return Feedback.invalidUsage("Cannot minimize empty selections."); - } - - - minimiseSelection(selectionWorld, selection); - - selector.learnChanges(); - selector.explainRegionAdjust(actor, localSession); - - return Feedback.success("Minimized selection."); - } - - private void minimiseSelection(World selectionWorld, Region selection) - throws CommandSyntaxException { - List changes = new ArrayList<>(); - var faces = getFaces(selection); - var finished = true; - - for (CuboidRegion face : faces) { - var isOnlyAir = true; - - for (BlockVector3 point : face) { - if (selectionWorld.getBlock(point).getBlockType().getDefaultState() != BlockTypes.AIR - .getDefaultState()) { - isOnlyAir = false; - break; - } - } - - if (!isOnlyAir) - continue; - - var difference = selection.getCenter().subtract(face.getCenter()); - difference = difference.normalize(); - - changes.add(difference.toBlockPoint()); - - finished = false; - - } - - try { - selection.contract(changes.toArray(new BlockVector3[changes.size()])); - } catch (RegionOperationException e) { - throw new net.minecraft.command.CommandException(Text.of("There was an error modifying the region.")); - } - - if (!finished) - minimiseSelection(selectionWorld, selection); - - } - - private List getFaces(Region selection) { - var faces = new ArrayList(); - - var pos1 = selection.getBoundingBox().getPos1(); - var pos2 = selection.getBoundingBox().getPos2(); - - var min = selection.getMinimumPoint(); - var max = selection.getMaximumPoint(); - - faces.add(new CuboidRegion(pos1.withX(min.getX()), pos2.withX(min.getX()))); - faces.add(new CuboidRegion(pos1.withX(max.getX()), pos2.withX(max.getX()))); - - faces.add(new CuboidRegion(pos1.withZ(min.getZ()), pos2.withZ(min.getZ()))); - faces.add(new CuboidRegion(pos1.withZ(max.getZ()), pos2.withZ(max.getZ()))); - - faces.add(new CuboidRegion(pos1.withY(min.getY()), pos2.withY(min.getY()))); - faces.add(new CuboidRegion(pos1.withY(max.getY()), pos2.withY(max.getY()))); - - return faces; - } - -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/commands/PickBlockFeature.java b/oldSrc/main/java/tools/redstone/redstonetools/features/commands/PickBlockFeature.java deleted file mode 100644 index 756563e3..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/features/commands/PickBlockFeature.java +++ /dev/null @@ -1,45 +0,0 @@ -package tools.redstone.redstonetools.features.commands; - -import tools.redstone.redstonetools.features.feedback.Feedback; -import tools.redstone.redstonetools.utils.BlockInfo; -import com.mojang.brigadier.exceptions.CommandSyntaxException; -import com.mojang.datafixers.util.Either; -import net.minecraft.client.MinecraftClient; -import net.minecraft.entity.player.PlayerInventory; -import net.minecraft.item.ItemStack; -import net.minecraft.server.command.ServerCommandSource; -import net.minecraft.text.Text; -import net.minecraft.util.Hand; - -import javax.annotation.Nullable; - -public abstract class PickBlockFeature extends BlockRaycastFeature { - @Override - protected final Feedback execute(ServerCommandSource source, @Nullable BlockInfo blockInfo) throws CommandSyntaxException { - MinecraftClient client = MinecraftClient.getInstance(); - if (client.player == null) { - return Feedback.error("Failed to get player."); - } - - var stackOrFeedback = getItemStack(source, blockInfo); - if (stackOrFeedback.right().isPresent()) { - return stackOrFeedback.right().get(); - } - - assert stackOrFeedback.left().isPresent(); - var stack = stackOrFeedback.left().get(); - - PlayerInventory playerInventory = client.player.getInventory(); - playerInventory.addPickBlock(stack); - - if (client.interactionManager == null) { - throw new CommandSyntaxException(null, Text.of("Failed to get interaction manager.")); - } - - client.interactionManager.clickCreativeStack(client.player.getStackInHand(Hand.MAIN_HAND), 36 + playerInventory.selectedSlot); - - return Feedback.none(); - } - - protected abstract Either getItemStack(ServerCommandSource source, @Nullable BlockInfo blockInfo) throws CommandSyntaxException; -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/commands/QuickTpFeature.java b/oldSrc/main/java/tools/redstone/redstonetools/features/commands/QuickTpFeature.java deleted file mode 100644 index dc3a6593..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/features/commands/QuickTpFeature.java +++ /dev/null @@ -1,60 +0,0 @@ -package tools.redstone.redstonetools.features.commands; - -import com.google.auto.service.AutoService; -import tools.redstone.redstonetools.features.AbstractFeature; -import tools.redstone.redstonetools.features.Feature; -import tools.redstone.redstonetools.features.arguments.Argument; -import tools.redstone.redstonetools.features.feedback.Feedback; -import tools.redstone.redstonetools.utils.PositionUtils; -import tools.redstone.redstonetools.utils.RaycastUtils; -import com.mojang.brigadier.exceptions.CommandSyntaxException; -import net.minecraft.entity.player.PlayerEntity; -import net.minecraft.server.command.ServerCommandSource; -import net.minecraft.util.hit.BlockHitResult; -import net.minecraft.util.hit.HitResult; -import net.minecraft.util.math.Vec3d; -import static tools.redstone.redstonetools.features.arguments.serializers.BoolSerializer.bool; -import static tools.redstone.redstonetools.features.arguments.serializers.FloatSerializer.floatArg; - -@AutoService(AbstractFeature.class) -@Feature(name = "Quick TP", description = "Teleports you in the direction you are looking.", command = "quicktp") -public class QuickTpFeature extends CommandFeature { - public static final Argument distance = Argument - .ofType(floatArg(1.0f)) - .withDefault(50.0f); - public static final Argument includeFluids = Argument - .ofType(bool()) - .withDefault(false); - - @Override - protected Feedback execute(ServerCommandSource source) throws CommandSyntaxException { - var player = source.getPlayer(); - - var targetPosition = getTargetPosition(player); - - player.teleport(targetPosition.x, targetPosition.y, targetPosition.z); - - return Feedback.none(); - } - - private Vec3d getTargetPosition(PlayerEntity player) { - // 8 chunks default, 16 blocks per chunk - var renderDistanceBlocks = PlayerEntity.getRenderDistanceMultiplier() * 8 * 16; - var hit = player.raycast(Math.min(distance.getValue(), renderDistanceBlocks), 0, includeFluids.getValue()); - - return clampHitPosition(hit).subtract(0, 1.12, 0); - } - - private Vec3d clampHitPosition(HitResult hit) { - if (hit.getType() != HitResult.Type.BLOCK) { - return hit.getPos().subtract(0, 0.5, 0); - } - - var blockHit = (BlockHitResult) hit; - - var neighbor = RaycastUtils.getBlockHitNeighbor(blockHit); - var neighborPos = neighbor.getBlockPos(); - - return PositionUtils.getBottomPositionOfBlock(neighborPos); - } -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/commands/RStackFeature.java b/oldSrc/main/java/tools/redstone/redstonetools/features/commands/RStackFeature.java deleted file mode 100644 index d06452a5..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/features/commands/RStackFeature.java +++ /dev/null @@ -1,98 +0,0 @@ -package tools.redstone.redstonetools.features.commands; - -import com.google.auto.service.AutoService; -import tools.redstone.redstonetools.features.AbstractFeature; -import tools.redstone.redstonetools.features.Feature; -import tools.redstone.redstonetools.features.arguments.Argument; -import tools.redstone.redstonetools.features.feedback.Feedback; -import tools.redstone.redstonetools.utils.DirectionArgument; -import com.mojang.brigadier.exceptions.CommandSyntaxException; -import com.sk89q.worldedit.IncompleteRegionException; -import com.sk89q.worldedit.WorldEdit; -import com.sk89q.worldedit.WorldEditException; -import com.sk89q.worldedit.fabric.FabricAdapter; -import com.sk89q.worldedit.function.mask.Mask; -import com.sk89q.worldedit.function.mask.Mask2D; -import com.sk89q.worldedit.function.operation.ForwardExtentCopy; -import com.sk89q.worldedit.function.operation.Operations; -import com.sk89q.worldedit.math.BlockVector3; -import com.sk89q.worldedit.regions.Region; -import net.minecraft.server.command.ServerCommandSource; -import org.jetbrains.annotations.Nullable; - -import static tools.redstone.redstonetools.features.arguments.serializers.DirectionSerializer.direction; -import static tools.redstone.redstonetools.features.arguments.serializers.IntegerSerializer.integer; -import static tools.redstone.redstonetools.utils.DirectionUtils.directionToBlock; -import static tools.redstone.redstonetools.utils.DirectionUtils.matchDirection; - -@AutoService(AbstractFeature.class) -@Feature(name = "RStack", description = "Stacks with custom distance", command = "/rstack", worldedit = true) -public class RStackFeature extends CommandFeature { - public static final Argument count = Argument - .ofType(integer()) - .withDefault(1); - - public static final Argument direction = Argument - .ofType(direction()) - .withDefault(DirectionArgument.ME); - - public static final Argument offset = Argument - .ofType(integer(1)) - .withDefault(2); - - @Override - protected Feedback execute(ServerCommandSource source) throws CommandSyntaxException { - var actor = FabricAdapter.adaptPlayer(source.getPlayer()); - - var localSession = WorldEdit.getInstance() - .getSessionManager() - .get(actor); - - final var selectionWorld = localSession.getSelectionWorld(); - assert selectionWorld != null; - - final Region selection; - try { - selection = localSession.getSelection(selectionWorld); - } catch (IncompleteRegionException ex) { - return Feedback.error("Please make a selection with WorldEdit first."); - } - - final Mask airFilter = new Mask() { - @Override - public boolean test(BlockVector3 vector) { - return !"minecraft:air".equals(selectionWorld.getBlock(vector).getBlockType().getId()); - } - - @Nullable - @Override - public Mask2D toMask2D() { - return null; - } - }; - - var playerFacing = actor.getLocation().getDirectionEnum(); - var stackDirection = matchDirection(direction.getValue(), playerFacing); - - var stackVector = directionToBlock(stackDirection); - - - try (var editSession = localSession.createEditSession(actor)) { - for (var i = 1; i <= count.getValue(); i++) { - var copy = new ForwardExtentCopy( - editSession, - selection, - editSession, - selection.getMinimumPoint().add(stackVector.multiply(i * offset.getValue())) - ); - copy.setSourceMask(airFilter); - Operations.complete(copy); - } - localSession.remember(editSession); - } catch (WorldEditException e) { - throw new RuntimeException(e); - } - - return Feedback.success("Stacked {} time(s).", count.getValue()); - } -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/commands/SignalStrengthBlockFeature.java b/oldSrc/main/java/tools/redstone/redstonetools/features/commands/SignalStrengthBlockFeature.java deleted file mode 100644 index 066bbcba..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/features/commands/SignalStrengthBlockFeature.java +++ /dev/null @@ -1,53 +0,0 @@ -package tools.redstone.redstonetools.features.commands; - -import com.google.auto.service.AutoService; -import com.mojang.brigadier.exceptions.CommandSyntaxException; -import com.mojang.brigadier.exceptions.SimpleCommandExceptionType; -import net.minecraft.item.ItemStack; -import net.minecraft.server.command.ServerCommandSource; -import net.minecraft.text.Text; -import tools.redstone.redstonetools.features.AbstractFeature; -import tools.redstone.redstonetools.features.Feature; -import tools.redstone.redstonetools.features.arguments.Argument; -import tools.redstone.redstonetools.features.arguments.serializers.SignalBlockSerializer; -import tools.redstone.redstonetools.features.feedback.Feedback; -import tools.redstone.redstonetools.utils.SignalBlock; - -import java.util.Random; - -import static tools.redstone.redstonetools.features.arguments.serializers.IntegerSerializer.integer; - -@AutoService(AbstractFeature.class) -@Feature(name = "Signal Strength Block", description = "Creates a block with the specified signal strength.", command = "ssb") -public class SignalStrengthBlockFeature extends CommandFeature { - - public static final Argument signalStrength = Argument - .ofType(integer(0)); - - public static final Argument block = Argument - .ofType(SignalBlockSerializer.signalBlock()) - .withDefault(SignalBlock.AUTO); - - @Override - protected Feedback execute(ServerCommandSource source) throws CommandSyntaxException { - try { - ItemStack itemStack = block.getValue().getItemStack(signalStrength.getValue()); - source.getPlayer().giveItemStack(itemStack); - } catch (IllegalArgumentException | IllegalStateException e) { - return Feedback.error(e.getMessage()); - } - - //funny - if(signalStrength.getValue() == 0) { - String[] funny = { - "Why would you want this??", "Wtf are you going to use this for?", "What for?", - "... Ok, if you're sure.", "I'm 99% sure you could just use any other block.", - "This seems unnecessary.", "Is that a typo?", "Do you just like the glint?", - "Wow, what a fancy but otherwise useless barrel.", "For decoration?"}; - return Feedback.success(funny[new Random().nextInt(funny.length)]); - } - - return Feedback.none(); - } - -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/commands/update/RegionUpdater.java b/oldSrc/main/java/tools/redstone/redstonetools/features/commands/update/RegionUpdater.java deleted file mode 100644 index 3f23d3d3..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/features/commands/update/RegionUpdater.java +++ /dev/null @@ -1,28 +0,0 @@ -package tools.redstone.redstonetools.features.commands.update; - -import tools.redstone.redstonetools.features.feedback.Feedback; -import com.sk89q.worldedit.math.BlockVector3; -import net.minecraft.util.math.BlockPos; -import net.minecraft.world.World; - -public class RegionUpdater { - - - public static Feedback updateRegion(World world, BlockVector3 minPos, BlockVector3 maxPos) { - long blockCount = 0; - - for (int x = minPos.getX() - 1; x <= maxPos.getX() + 1; x++) { - for (int y = minPos.getY() - 1; y <= maxPos.getY() + 1; y++) { - for (int z = minPos.getZ() - 1; z <= maxPos.getZ() + 1; z++) { - BlockPos pos = new BlockPos(x, y, z); - - world.updateNeighbors(new BlockPos(x, y, z), world.getBlockState(pos).getBlock()); - blockCount++; - - } - } - } - return Feedback.success("Successfully forced block updates for {} block(s).", blockCount); - } - -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/commands/update/UpdateFeature.java b/oldSrc/main/java/tools/redstone/redstonetools/features/commands/update/UpdateFeature.java deleted file mode 100644 index f7e1078e..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/features/commands/update/UpdateFeature.java +++ /dev/null @@ -1,28 +0,0 @@ -package tools.redstone.redstonetools.features.commands.update; - -import com.google.auto.service.AutoService; -import com.mojang.brigadier.exceptions.CommandSyntaxException; -import net.minecraft.server.command.ServerCommandSource; -import tools.redstone.redstonetools.features.AbstractFeature; -import tools.redstone.redstonetools.features.Feature; -import tools.redstone.redstonetools.features.commands.CommandFeature; -import tools.redstone.redstonetools.features.feedback.Feedback; -import tools.redstone.redstonetools.utils.WorldEditUtils; - -@AutoService(AbstractFeature.class) -@Feature(name = "Update", description = "Forces block updates in the selected area.", command = "/update") -public class UpdateFeature extends CommandFeature { - @Override - protected Feedback execute(ServerCommandSource source) throws CommandSyntaxException { - var selectionOrFeedback = WorldEditUtils.getSelection(source.getPlayer()); - if (selectionOrFeedback.right().isPresent()) { - return selectionOrFeedback.right().get(); - } - - assert selectionOrFeedback.left().isPresent(); - var selection = selectionOrFeedback.left().get(); - - - return RegionUpdater.updateRegion(source.getWorld(), selection.getMinimumPoint(), selection.getMaximumPoint()); - } -} \ No newline at end of file diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/feedback/AbstractFeedbackSender.java b/oldSrc/main/java/tools/redstone/redstonetools/features/feedback/AbstractFeedbackSender.java deleted file mode 100644 index b61374b4..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/features/feedback/AbstractFeedbackSender.java +++ /dev/null @@ -1,7 +0,0 @@ -package tools.redstone.redstonetools.features.feedback; - -import net.minecraft.server.command.ServerCommandSource; - -public abstract class AbstractFeedbackSender { - public abstract void sendFeedback(ServerCommandSource source, Feedback feedback); -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/feedback/Feedback.java b/oldSrc/main/java/tools/redstone/redstonetools/features/feedback/Feedback.java deleted file mode 100644 index c3d6df18..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/features/feedback/Feedback.java +++ /dev/null @@ -1,178 +0,0 @@ -package tools.redstone.redstonetools.features.feedback; - -import com.mojang.brigadier.context.CommandContext; -import net.minecraft.server.command.ServerCommandSource; -import net.minecraft.util.Formatting; -import tools.redstone.redstonetools.RedstoneToolsClient; - -import javax.annotation.Nullable; - -public abstract class Feedback { - private final @Nullable String message; - private final @Nullable Object[] values; - - protected Feedback(@Nullable String message, @Nullable Object... values) { - this.message = message; - this.values = values; - } - - private String formatMessage(String message) { - return String.format("%s[%sRST%s]%s ", Formatting.GRAY, Formatting.RED, Formatting.GRAY, Formatting.RESET) + message; - } - - public final String getMessage() { - if (message != null) { - String sentMessage = message; - for (Object value : values) { - sentMessage = sentMessage.replaceFirst("\\{\\}", Formatting.RED + value.toString() + getFormatting()); - } - - return formatMessage(sentMessage); - } else { - return formatMessage(getDefaultMessage()); - } - } - - /** Returns the status code. */ - public int send(ServerCommandSource source) { - RedstoneToolsClient.INJECTOR - .getInstance(FeedbackSender.class) - .sendFeedback(source, this); - - return getType().getCode(); - } - - /** Returns the status code. */ - public int send(CommandContext context) { - return send(context.getSource()); - } - - public abstract Formatting getFormatting(); - public abstract String getDefaultMessage(); - public abstract FeedbackType getType(); - - public static None none() { - return new None(); - } - - public static class None extends Feedback { - public None() { - super(null); - } - - @Override - public Formatting getFormatting() { - return Formatting.WHITE; - } - - @Override - public String getDefaultMessage() { - return ""; - } - - @Override - public FeedbackType getType() { - return FeedbackType.NONE; - } - } - - public static Success success(@Nullable String message, @Nullable Object... values) { - return new Success(message, values); - } - - public static class Success extends Feedback { - public Success(@Nullable String message, @Nullable Object... values) { - super(message, values); - } - - @Override - public Formatting getFormatting() { - return Formatting.WHITE; - } - - @Override - public String getDefaultMessage() { - return "Success"; - } - - @Override - public FeedbackType getType() { - return FeedbackType.SUCCESS; - } - } - - public static Warning warning(@Nullable String message, @Nullable Object... values) { - return new Warning(message, values); - } - - public static class Warning extends Feedback { - public Warning(@Nullable String message, @Nullable Object... values) { - super(message, values); - } - - @Override - public Formatting getFormatting() { - return Formatting.YELLOW; - } - - @Override - public String getDefaultMessage() { - return "Warning"; - } - - @Override - public FeedbackType getType() { - return FeedbackType.WARNING; - } - } - - public static Error error(@Nullable String message, @Nullable Object... values) { - return new Error(message, values); - } - - public static class Error extends Feedback { - public Error(@Nullable String message, @Nullable Object... values) { - super(message, values); - } - - @Override - public Formatting getFormatting() { - return Formatting.RED; - } - - @Override - public String getDefaultMessage() { - return "Error"; - } - - @Override - public FeedbackType getType() { - return FeedbackType.ERROR; - } - } - - public static InvalidUsage invalidUsage(@Nullable String message, @Nullable Object... values) { - return new InvalidUsage(message, values); - } - - public static class InvalidUsage extends Feedback { - public InvalidUsage(@Nullable String message, @Nullable Object... values) { - super(message, values); - } - - @Override - public Formatting getFormatting() { - return Formatting.RED; - } - - @Override - public String getDefaultMessage() { - return "Invalid usage"; - } - - @Override - public FeedbackType getType() { - return FeedbackType.ERROR; - } - } -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/feedback/FeedbackSender.java b/oldSrc/main/java/tools/redstone/redstonetools/features/feedback/FeedbackSender.java deleted file mode 100644 index efd5a156..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/features/feedback/FeedbackSender.java +++ /dev/null @@ -1,19 +0,0 @@ -package tools.redstone.redstonetools.features.feedback; - -import net.minecraft.server.command.ServerCommandSource; -import net.minecraft.text.LiteralText; - -import javax.inject.Singleton; - -@Singleton -public class FeedbackSender extends AbstractFeedbackSender { - @Override - public void sendFeedback(ServerCommandSource source, Feedback feedback) { - if (feedback.getType() == FeedbackType.NONE) { - return; - } - - source.sendFeedback(new LiteralText(feedback.getMessage()) - .formatted(feedback.getFormatting()), false); - } -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/feedback/FeedbackType.java b/oldSrc/main/java/tools/redstone/redstonetools/features/feedback/FeedbackType.java deleted file mode 100644 index 81f81e9b..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/features/feedback/FeedbackType.java +++ /dev/null @@ -1,18 +0,0 @@ -package tools.redstone.redstonetools.features.feedback; - -public enum FeedbackType { - SUCCESS(1), - NONE(0), - WARNING(0), - ERROR(-1); - - private final int code; - - FeedbackType(int code) { - this.code = code; - } - - public int getCode() { - return code; - } -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/toggleable/AirPlaceFeature.java b/oldSrc/main/java/tools/redstone/redstonetools/features/toggleable/AirPlaceFeature.java deleted file mode 100644 index db0eba6a..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/features/toggleable/AirPlaceFeature.java +++ /dev/null @@ -1,125 +0,0 @@ -package tools.redstone.redstonetools.features.toggleable; - -import com.google.auto.service.AutoService; -import net.fabricmc.fabric.api.client.rendering.v1.WorldRenderEvents; -import net.minecraft.block.BlockState; -import net.minecraft.block.Blocks; -import net.minecraft.client.MinecraftClient; -import net.minecraft.client.network.ClientPlayerEntity; -import net.minecraft.client.render.Camera; -import net.minecraft.client.render.RenderLayer; -import net.minecraft.client.render.VertexConsumer; -import net.minecraft.entity.EquipmentSlot; -import net.minecraft.entity.player.PlayerEntity; -import net.minecraft.item.ItemStack; -import net.minecraft.item.Items; -import net.minecraft.util.hit.BlockHitResult; -import net.minecraft.util.hit.HitResult; -import net.minecraft.util.math.BlockPos; -import net.minecraft.util.math.Vec3d; -import tools.redstone.redstonetools.features.AbstractFeature; -import tools.redstone.redstonetools.features.Feature; -import tools.redstone.redstonetools.features.arguments.Argument; -import tools.redstone.redstonetools.features.arguments.serializers.BoolSerializer; -import tools.redstone.redstonetools.mixin.accessors.WorldRendererAccessor; -import tools.redstone.redstonetools.utils.ItemUtils; -import tools.redstone.redstonetools.utils.RaycastUtils; - -import static tools.redstone.redstonetools.features.arguments.serializers.FloatSerializer.floatArg; - -@AutoService(AbstractFeature.class) -@Feature(name = "Air Place", description = "Allows you to place blocks in the air.", command = "airplace") -public class AirPlaceFeature extends ToggleableFeature { - - public static boolean canAirPlace(PlayerEntity player) { - ItemStack itemStack = ItemUtils.getMainItem(player); - - // empty slot - if (itemStack == null || itemStack.getItem() == Items.AIR) - return false; - - // rocket boost for elytra - if (itemStack.getItem() == Items.FIREWORK_ROCKET && - player.getEquippedStack(EquipmentSlot.CHEST).getItem() == Items.ELYTRA && - player.isFallFlying()) - return false; - - return true; - } - - public static HitResult findAirPlacePosition(MinecraftClient client) { - if (client.player == null) - return null; - ClientPlayerEntity player = client.player; - - float reach = AirPlaceFeature.reach.getValue(); - return player.raycast(reach, 0, false); - } - - public static BlockHitResult findAirPlaceBlockHit(PlayerEntity playerEntity) { - var hit = RaycastUtils.rayCastFromEye(playerEntity, reach.getValue()); - return new BlockHitResult(hit.getPos(), hit.getSide(), hit.getBlockPos(), false); - } - - public static final Argument reach = Argument - .ofType(floatArg(3.0f)) - .withDefault(5.0f); - - public static final Argument showOutline = Argument - .ofType(BoolSerializer.bool()) - .withDefault(true); - - private static final BlockState FULL_BLOCK_STATE = Blocks.BEDROCK.getDefaultState(); - - { - // register ghost block renderer - WorldRenderEvents.BEFORE_BLOCK_OUTLINE.register((context, blockOutlineContext) -> { - if (!isEnabled()) - return true; - if (showOutline.getValue() != Boolean.TRUE) - return true; - - MinecraftClient client = MinecraftClient.getInstance(); - if (client.player == null || client.interactionManager == null) - return true; - if (blockOutlineContext.getType() != HitResult.Type.MISS) - return true; - - if (!canAirPlace(client.player)) - return true; - - HitResult hitResult = findAirPlacePosition(client); - if (hitResult == null) - return true; - BlockPos blockPos = new BlockPos(hitResult.getPos()); - - BlockState blockState = ItemUtils.getUseState(client.player, - ItemUtils.getMainItem(client.player), - reach.getValue()); - if (blockState == null) - return true; - - /* render block outline */ - Camera camera = client.gameRenderer.getCamera(); - Vec3d camPos = camera.getPos(); - - try { - VertexConsumer consumer = context.consumers().getBuffer(RenderLayer.getLines()); - - ((WorldRendererAccessor)context.worldRenderer()).invokeDrawBlockOutline( - context.matrixStack(), - consumer, - client.player, - camPos.x, camPos.y, camPos.z, - blockPos, - blockState - ); - } catch (Throwable t) { - throw new IllegalStateException(t); - } - - return true; - }); - } - -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/toggleable/AutoDustFeature.java b/oldSrc/main/java/tools/redstone/redstonetools/features/toggleable/AutoDustFeature.java deleted file mode 100644 index 9a9e1c7a..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/features/toggleable/AutoDustFeature.java +++ /dev/null @@ -1,11 +0,0 @@ -package tools.redstone.redstonetools.features.toggleable; - -import com.google.auto.service.AutoService; -import tools.redstone.redstonetools.features.AbstractFeature; -import tools.redstone.redstonetools.features.Feature; - -@AutoService(AbstractFeature.class) -@Feature(name = "Auto Dust", description = "Automatically places redstone on top of colored blocks.", command = "autodust") -public class AutoDustFeature extends ToggleableFeature { - -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/toggleable/BigDustFeature.java b/oldSrc/main/java/tools/redstone/redstonetools/features/toggleable/BigDustFeature.java deleted file mode 100644 index 6f6490c8..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/features/toggleable/BigDustFeature.java +++ /dev/null @@ -1,16 +0,0 @@ -package tools.redstone.redstonetools.features.toggleable; - -import com.google.auto.service.AutoService; -import tools.redstone.redstonetools.features.AbstractFeature; -import tools.redstone.redstonetools.features.Feature; -import tools.redstone.redstonetools.features.arguments.Argument; -import tools.redstone.redstonetools.features.arguments.serializers.IntegerSerializer; - -@AutoService(AbstractFeature.class) -@Feature(name = "Big Dust", description = "Change the size of redstone's hitbox.", command = "bigdust") -public class BigDustFeature extends ToggleableFeature { - - public static final Argument heightInPixels = Argument.ofType(IntegerSerializer.integer(1, 16)) - .withDefault(1); - -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/features/toggleable/ToggleableFeature.java b/oldSrc/main/java/tools/redstone/redstonetools/features/toggleable/ToggleableFeature.java deleted file mode 100644 index 2ace5531..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/features/toggleable/ToggleableFeature.java +++ /dev/null @@ -1,257 +0,0 @@ -package tools.redstone.redstonetools.features.toggleable; - -import net.fabricmc.fabric.api.client.event.lifecycle.v1.ClientTickEvents; -import net.fabricmc.fabric.api.client.keybinding.v1.KeyBindingHelper; -import net.minecraft.client.option.KeyBinding; -import net.minecraft.client.util.InputUtil; -import tools.redstone.redstonetools.features.AbstractFeature; -import tools.redstone.redstonetools.features.Feature; -import tools.redstone.redstonetools.features.feedback.Feedback; -import tools.redstone.redstonetools.features.feedback.FeedbackSender; -import tools.redstone.redstonetools.utils.ReflectionUtils; -import com.google.gson.Gson; -import com.google.gson.GsonBuilder; -import com.google.gson.JsonObject; -import com.mojang.brigadier.CommandDispatcher; -import com.mojang.brigadier.context.CommandContext; -import com.mojang.brigadier.exceptions.CommandSyntaxException; -import net.fabricmc.fabric.api.client.event.lifecycle.v1.ClientLifecycleEvents; -import net.minecraft.server.command.ServerCommandSource; -import tools.redstone.redstonetools.RedstoneToolsClient; -import tools.redstone.redstonetools.features.AbstractFeature; -import tools.redstone.redstonetools.features.arguments.Argument; -import tools.redstone.redstonetools.features.feedback.Feedback; -import tools.redstone.redstonetools.utils.ReflectionUtils; - -import java.io.BufferedReader; -import java.io.InputStreamReader; -import java.io.OutputStream; -import java.nio.charset.StandardCharsets; -import java.nio.file.Files; -import java.nio.file.Path; -import java.util.List; -import java.util.concurrent.Executor; -import java.util.concurrent.Executors; - -import java.util.ArrayList; -import java.util.List; - -import static tools.redstone.redstonetools.RedstoneToolsClient.INJECTOR; - -import static net.minecraft.server.command.CommandManager.argument; -import static net.minecraft.server.command.CommandManager.literal; - -public abstract class ToggleableFeature extends AbstractFeature { - - private static final List keyBindings = new ArrayList<>(); - - @Override - public void register() { - super.register(); - - // load user settings - // and register save hook - loadConfig(); - ClientLifecycleEvents.CLIENT_STOPPING.register(client -> { - saveConfig(); - }); - - var containsRequiredArguments = ReflectionUtils.getArguments(getClass()).stream() - .anyMatch(a -> !a.isOptional()); - if (containsRequiredArguments) { - return; - } - - var info = ReflectionUtils.getFeatureInfo(getClass()); - var keyBinding = KeyBindingHelper.registerKeyBinding(new KeyBinding( - info.name(), - InputUtil.Type.KEYSYM, - -1, - "Redstone Tools" - )); - - keyBindings.add(keyBinding); - - ClientTickEvents.END_CLIENT_TICK.register(client -> { - while (keyBinding.wasPressed()) { - assert client.player != null; - client.player.sendChatMessage("/" + info.command()); - } - }); - } - - private static final Executor IO_EXECUTOR = Executors.newSingleThreadExecutor(); - - private static final Gson GSON = new GsonBuilder() - .setPrettyPrinting() - .create(); - - private volatile boolean enabled; // volatile for thread safety - - private final List> arguments = ReflectionUtils.getArguments(getClass()); - - private final Path configFile = RedstoneToolsClient.CONFIG_DIR - .resolve("features").resolve(getID() + ".json"); - - @SuppressWarnings({ "rawtypes", "unchecked" }) - - @Override - protected void registerCommands(CommandDispatcher dispatcher, boolean dedicated) { - var baseCommand = literal(getCommand()) - .executes(this::toggle); - - // add option configurations - for (Argument argument : arguments) { - String name = argument.getName(); - baseCommand.then(literal(name) - .executes(context -> { - Object value = argument.getValue(); - return Feedback.success("Option {} of feature {} is set to: {}", name, getName(), argument.getType().serialize(value)).send(context); - }) - .then(argument("value", argument.getType()).executes(context -> { - Object value = context.getArgument("value", argument.getType().getTypeClass()); - - argument.setValue(value); - - if (!enabled) { - enable(context); - } - - IO_EXECUTOR.execute(this::saveConfig); - - return Feedback.success("Set {} to {} for feature {}", name, value, getName()).send(context); - })) - ); - } - - dispatcher.register(baseCommand); - } - - public boolean isEnabled() { - return enabled; - } - - public int toggle(CommandContext context) throws CommandSyntaxException { - return toggle(context.getSource()); - } - - public int toggle(ServerCommandSource source) throws CommandSyntaxException { - return !enabled ? enable(source) : disable(source); - } - - public void setEnabled(boolean status) { - if (status == enabled) - return; // no work to do - - if (status) { - enable(); - } else { - disable(); - } - } - - public void enable() { - enabled = true; - onEnable(); - } - - public int enable(ServerCommandSource source) throws CommandSyntaxException { - enable(); - Feedback.success("Enabled feature {}", getName()).send(source); - return 0; - } - - public int enable(CommandContext context) throws CommandSyntaxException { - return enable(context.getSource()); - } - - public void disable() { - enabled = false; - onDisable(); - } - - public int disable(ServerCommandSource source) throws CommandSyntaxException { - disable(); - Feedback.success("Disabled feature {}", getName()).send(source); - return 0; - } - - public int disable(CommandContext context) throws CommandSyntaxException { - return disable(context.getSource()); - } - - protected void onEnable() { } - protected void onDisable() { } - - // todo: right now the configuration methods are assuming every - // type is serialized to a string, this should be fixed in the future - // but for now it works because every type right now serializes to a string - // + it will probably be refactored soon - - /** Reloads the configuration from the disk. */ - @SuppressWarnings({ "rawtypes", "unchecked" }) - public void loadConfig() { - try { - boolean enabled = false; - if (Files.exists(configFile)) { - JsonObject object = GSON.fromJson(new BufferedReader( - new InputStreamReader(Files.newInputStream(configFile), StandardCharsets.UTF_8)), - JsonObject.class); - - enabled = Boolean.parseBoolean(object.get("enabled").getAsString()); - - // read options - for (Argument argument : arguments) { - if (!object.has(argument.getName())) - continue; - - String valueString = object.get(argument.getName()).getAsString(); - Object value = argument.getType().deserialize(valueString); - - argument.setValue(value); - } - } - - setEnabled(enabled); - - RedstoneToolsClient.LOGGER.info("Loaded configuration for feature " + getID() + " file(" + configFile + ")"); - } catch (Exception e) { - RedstoneToolsClient.LOGGER.error("Failed to load configuration for feature " + getID() + " file(" + configFile + ")"); - e.printStackTrace(); - } - } - - /** Saves the configuration to the disk. */ - @SuppressWarnings({ "rawtypes", "unchecked" }) - public void saveConfig() { - try { - if (!Files.exists(configFile)) { - if (!Files.exists(configFile.getParent())) - Files.createDirectories(configFile.getParent()); - Files.createFile(configFile); - } - - // serialize configuration - JsonObject jsonObject = new JsonObject(); - jsonObject.addProperty("enabled", Boolean.toString(enabled)); - for (Argument argument : arguments) { - Object value = argument.getValue(); - String valueSerialized = (String) argument.getType().serialize(value); - - jsonObject.addProperty(argument.getName(), valueSerialized); - } - - // write json document - String json = GSON.toJson(jsonObject); - OutputStream outputStream = Files.newOutputStream(configFile); - outputStream.write(json.getBytes(StandardCharsets.UTF_8)); - outputStream.close(); - - RedstoneToolsClient.LOGGER.info("Saved configuration for feature " + getID() + " file(" + configFile + ")"); - } catch (Exception e) { - RedstoneToolsClient.LOGGER.error("Failed to save configuration for feature " + getID() + " file(" + configFile + ")"); - e.printStackTrace(); - } - } - -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/macros/ClientPlayerEntityMixin.java b/oldSrc/main/java/tools/redstone/redstonetools/macros/ClientPlayerEntityMixin.java deleted file mode 100644 index ddb2e4d7..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/macros/ClientPlayerEntityMixin.java +++ /dev/null @@ -1,9 +0,0 @@ -package tools.redstone.redstonetools.macros; - -import net.minecraft.client.network.ClientPlayNetworkHandler; - -public interface ClientPlayerEntityMixin { - - void setNetworkHandler(ClientPlayNetworkHandler networkHandler); - -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/macros/KeyBindingMixin.java b/oldSrc/main/java/tools/redstone/redstonetools/macros/KeyBindingMixin.java deleted file mode 100644 index 3e0f1cda..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/macros/KeyBindingMixin.java +++ /dev/null @@ -1,12 +0,0 @@ -package tools.redstone.redstonetools.macros; - -import net.minecraft.client.option.KeyBinding; -import net.minecraft.client.util.InputUtil.Key; - -public interface KeyBindingMixin { - - void removeKeybinding(KeyBinding keyBinding); - - KeyBinding getBindingFromKey(Key key); - -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/macros/Macro.java b/oldSrc/main/java/tools/redstone/redstonetools/macros/Macro.java deleted file mode 100644 index 2e30e36e..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/macros/Macro.java +++ /dev/null @@ -1,132 +0,0 @@ -package tools.redstone.redstonetools.macros; - -import net.fabricmc.fabric.api.client.keybinding.KeyBindingRegistry; -import tools.redstone.redstonetools.macros.actions.Action; -import net.fabricmc.fabric.api.client.event.lifecycle.v1.ClientTickEvents; -import net.minecraft.client.MinecraftClient; -import net.minecraft.client.option.KeyBinding; -import net.minecraft.client.util.InputUtil; -import net.minecraft.client.util.InputUtil.Key; -import tools.redstone.redstonetools.utils.KeyBindingUtils; - -import java.util.ArrayList; -import java.util.List; - -public class Macro { - - public static Macro buildEmpty() { - return new Macro("",true,InputUtil.UNKNOWN_KEY,new ArrayList<>()); - } - - private KeyBinding keyBinding; - public String name; - private Key key; - public boolean enabled; - public List actions; - - private final Macro original; - - public Macro(String name, boolean enabled, Key key, List actions) { - this(name,enabled,key,actions,null); - keyBinding = new KeyBinding("macro." + System.nanoTime(),-1,"macros"); - registerKeyBinding(); - changeKeyBindingKeyCode(); - } - - public Macro(String name, boolean enabled, Key key, List actions, Macro original) { - this.name = name; - this.enabled = enabled; - this.key = key; - this.actions = actions; - this.original = original; - } - - public void registerKeyBinding() { - if (keyBinding == null) return; - - ClientTickEvents.END_CLIENT_TICK.register(client -> { - if (keyBinding == null || key == InputUtil.UNKNOWN_KEY) return; - - if (keyBinding.wasPressed()) { - run(); - } - }); - } - - public void run() { - if (!enabled) { - return; - } - - for (Action action : actions) { - action.run(); - } - } - - public void applyChangesToOriginal() { - assert isCopy(); - - original.name = name; - original.enabled = enabled; - original.setKey(key); - original.actions = new ArrayList<>(actions); - } - - public boolean isCopy(){ - return original != null; - } - - public boolean isCopyOf(Macro macro) { - return original == macro; - } - - public void setKey(Key key) { - this.key = key; - changeKeyBindingKeyCode(); - } - - public void changeKeyBindingKeyCode() { - - if (this.keyBinding != null) { - MinecraftClient.getInstance().options.setKeyCode(keyBinding,key); - KeyBinding.updateKeysByCode(); - } - - } - - public Key getKey(){ - return key; - } - - public Macro createCopy() { - return new Macro(name,enabled,key,new ArrayList<>(actions),this); - } - - public void unregisterKeyBinding(){ - KeyBindingUtils.removeKeyBinding(keyBinding); - } - - public boolean needsSaving() { - return !isCopy() || !original.equals(this); - } - - public boolean isEmpty() { - return name.isEmpty() && key == InputUtil.UNKNOWN_KEY && actions.isEmpty(); - } - - @Override - public boolean equals(Object obj) { - if (obj instanceof Macro macro) { - - if (actions.size() != macro.actions.size()) return false; - for (int i = 0; i < actions.size(); i++) { - if (!actions.get(i).equals(macro.actions.get(i))) return false; - } - - return macro.name.equals(name) && macro.key.equals(key) && macro.enabled == enabled; - } - - return super.equals(obj); - } - -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/macros/MacroManager.java b/oldSrc/main/java/tools/redstone/redstonetools/macros/MacroManager.java deleted file mode 100644 index 95b1f0cf..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/macros/MacroManager.java +++ /dev/null @@ -1,192 +0,0 @@ -package tools.redstone.redstonetools.macros; - -import net.minecraft.client.MinecraftClient; -import net.minecraft.client.util.InputUtil; -import tools.redstone.redstonetools.macros.actions.Action; -import tools.redstone.redstonetools.macros.actions.CommandAction; - -import javax.inject.Singleton; -import javax.json.Json; -import javax.json.JsonArray; -import javax.json.JsonObject; -import java.io.FileReader; -import java.io.FileWriter; -import java.io.IOException; -import java.nio.file.Files; -import java.nio.file.Path; -import java.util.ArrayList; -import java.util.List; - -@Singleton -public class MacroManager { - private final Path macrosFilePath; - private final List macros; - - public MacroManager() { - macrosFilePath = MinecraftClient.getInstance().runDirectory.toPath() - .resolve("config") - .resolve("redstonetools") - .resolve("macros.json"); - - - JsonArray macrosJson = null; - try { - Files.createDirectories(macrosFilePath.getParent()); - if (Files.exists(macrosFilePath)) { - var reader = Json.createReader(new FileReader(macrosFilePath.toFile())); - macrosJson = reader.readArray(); - reader.close(); - } - } catch (Exception e) { - e.printStackTrace(); - } - - if (macrosJson == null) { - macros = new ArrayList<>(); - macros.addAll(getDefaultMacros()); - } else { - macros = getMacrosFromJson(macrosJson); - } - } - - public List getMacros() { - return macros; - } - - public Macro getMacro(String name) { - for (Macro macro : macros) { - if (macro.name.equals(name)) { - return macro; - } - } - - return null; - } - - public void addMacro(Macro macro) { - macros.add(macro); - - saveChanges(); - } - - public void removeMacro(Macro macro) { - macros.remove(macro); - - saveChanges(); - } - - public void saveChanges() { - // Write %appdata%/.minecraft/config/redstonetools/macros.json - try { - Files.createDirectories(macrosFilePath.getParent()); - } catch (IOException e) { - e.printStackTrace(); - } - - var macrosJson = Json.createArrayBuilder(); - for (Macro macro : macros) { - macrosJson.add(getMacroJson(macro)); - } - - try (var writer = Json.createWriter(new FileWriter(macrosFilePath.toFile()))) { - writer.writeArray(macrosJson.build()); - } catch (Exception e) { - e.printStackTrace(); - } - } - - private JsonObject getMacroJson(Macro macro) { - var actionsJson = Json.createArrayBuilder(); - for (Action action : macro.actions) { - actionsJson.add(getActionJson(action)); - } - - return Json.createObjectBuilder() - .add("name", macro.name) - .add("enabled", macro.enabled) - .add("key", macro.getKey().getTranslationKey()) - .add("actions", actionsJson) - .build(); - } - - private JsonObject getActionJson(Action action) { - if (action instanceof CommandAction commandAction) { - return Json.createObjectBuilder() - .add("type", "command") - .add("command", commandAction.command) - .build(); - } - - throw new RuntimeException("Unknown action type: " + action.getClass().getName()); - } - - private List getDefaultMacros() { - return List.of( - createCommandMacro("redstoner", new String[] { - "/gamerule doTileDrops false", - "/gamerule doTraderSpawning false", - "/gamerule doWeatherCycle false", - "/gamerule doDaylightCycle false", - "/gamerule doMobSpawning false", - "/gamerule doContainerDrops false", - "/time set noon", - "/weather clear" - }) - ); - } - - private Macro createCommandMacro(String name, String[] commands) { - var actions = new Action[commands.length]; - for (int i = 0; i < commands.length; i++) { - actions[i] = new CommandAction(commands[i]); - } - - return new Macro(name, true, InputUtil.UNKNOWN_KEY, List.of(actions)); - } - - private List getMacrosFromJson(JsonArray macrosJson) { - List macros = new ArrayList<>(); - - for (int i = 0; i < macrosJson.size(); i++) { - macros.add(getMacroFromJson(macrosJson.getJsonObject(i))); - } - - return macros; - } - - private Macro getMacroFromJson(JsonObject macroJson) { - var name = macroJson.getString("name"); - var enabled = macroJson.getBoolean("enabled"); - var key = macroJson.getString("key"); - var actions = getActionsFromJson(macroJson.getJsonArray("actions")); - - return new Macro(name, enabled, InputUtil.fromTranslationKey(key), actions); - } - - private List getActionsFromJson(JsonArray actionsJson) { - List actions = new ArrayList<>(); - - for (int i = 0; i < actionsJson.size(); i++) { - actions.add(getActionFromJson(actionsJson.getJsonObject(i))); - } - - return actions; - } - - private Action getActionFromJson(JsonObject actionJson) { - var type = actionJson.getString("type"); - - if ("command".equals(type)) { - return new CommandAction(actionJson.getString("command")); - } - - throw new RuntimeException("Unknown action type: " + type); - } - - public void updateMacroKeys() { - for (Macro macro : macros) { - macro.changeKeyBindingKeyCode(); - } - } - -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/macros/actions/Action.java b/oldSrc/main/java/tools/redstone/redstonetools/macros/actions/Action.java deleted file mode 100644 index 5cca93f1..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/macros/actions/Action.java +++ /dev/null @@ -1,5 +0,0 @@ -package tools.redstone.redstonetools.macros.actions; - -public abstract class Action { - public abstract void run(); -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/macros/actions/CommandAction.java b/oldSrc/main/java/tools/redstone/redstonetools/macros/actions/CommandAction.java deleted file mode 100644 index 6c680e74..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/macros/actions/CommandAction.java +++ /dev/null @@ -1,29 +0,0 @@ -package tools.redstone.redstonetools.macros.actions; - -import net.minecraft.client.MinecraftClient; - -public class CommandAction extends Action { - public String command; - - public CommandAction(String command) { - this.command = command; - } - - @Override - public void run() { - var player = MinecraftClient.getInstance().player; - assert player != null; - - player.sendChatMessage(command.startsWith("/") ? command : "/" + command); - } - - @Override - public boolean equals(Object obj) { - if (obj instanceof CommandAction commandAction) { - return command.equals(commandAction.command); - } - - return super.equals(obj); - } - -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/macros/gui/MaroCommandSuggestor.java b/oldSrc/main/java/tools/redstone/redstonetools/macros/gui/MaroCommandSuggestor.java deleted file mode 100644 index 9e4b9314..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/macros/gui/MaroCommandSuggestor.java +++ /dev/null @@ -1,42 +0,0 @@ -package tools.redstone.redstonetools.macros.gui; - -import net.minecraft.client.MinecraftClient; -import net.minecraft.client.font.TextRenderer; -import net.minecraft.client.gui.screen.CommandSuggestor; -import net.minecraft.client.gui.screen.Screen; -import net.minecraft.client.gui.widget.TextFieldWidget; - -import java.util.HashMap; - -public class MaroCommandSuggestor extends CommandSuggestor { - private static final HashMap yMap = new HashMap<>(); - - - - public MaroCommandSuggestor(MinecraftClient client, Screen owner, TextFieldWidget textField, TextRenderer textRenderer, boolean slashOptional, boolean suggestingWhenEmpty, int y, int maxSuggestionSize, int color) { - super(client, owner, textField, textRenderer, slashOptional, suggestingWhenEmpty, 0, maxSuggestionSize, false, color); - yMap.put(this,y); - - } - - public void close(){ - yMap.remove(this); - } - - public static boolean instance(Object object) { - return object instanceof MaroCommandSuggestor; - } - - public static int getY(Object object){ - return yMap.get(object); - } - - @Override - public void refresh() { - if (MinecraftClient.getInstance().player == null) return; - super.refresh(); - - } - - -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/macros/gui/screen/CommandEditScreen.java b/oldSrc/main/java/tools/redstone/redstonetools/macros/gui/screen/CommandEditScreen.java deleted file mode 100644 index 4e64fd5f..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/macros/gui/screen/CommandEditScreen.java +++ /dev/null @@ -1,108 +0,0 @@ -package tools.redstone.redstonetools.macros.gui.screen; - -import tools.redstone.redstonetools.macros.gui.MaroCommandSuggestor; -import net.minecraft.client.MinecraftClient; -import net.minecraft.client.gui.screen.Screen; -import net.minecraft.client.gui.screen.option.GameOptionsScreen; -import net.minecraft.client.gui.widget.TextFieldWidget; -import net.minecraft.client.option.GameOptions; -import net.minecraft.client.util.InputUtil; -import net.minecraft.client.util.math.MatrixStack; -import net.minecraft.text.Text; - - -public class CommandEditScreen extends GameOptionsScreen { - - private final TextFieldWidget commandField; - private final MaroCommandSuggestor commandMaroCommandSuggestor; - private boolean changed = false; - - public CommandEditScreen(Screen parent, GameOptions gameOptions, TextFieldWidget commandField) { - super(parent, gameOptions, Text.of("")); - this.commandField = commandField; - client = MinecraftClient.getInstance(); - this.commandMaroCommandSuggestor = new MaroCommandSuggestor(client, parent, commandField,client.textRenderer,true,false, commandField.y -20,5,-805306368); - - commandField.setChangedListener((s) -> changed = true); - commandMaroCommandSuggestor.setWindowActive(true); - commandMaroCommandSuggestor.refresh(); - } - - @Override - public void render(MatrixStack matrices, int mouseX, int mouseY, float delta) { - parent.render(matrices, mouseX, mouseY, delta); - - this.fillGradient(matrices, 0, 0, this.width, this.height, -1072689136, -804253680); - - commandField.render(matrices, mouseX, mouseY, delta); - - commandMaroCommandSuggestor.render(matrices, mouseX, mouseY); - if (changed) { - commandMaroCommandSuggestor.refresh(); - changed = false; - } - - super.render(matrices, mouseX, mouseY, delta); - - } - - @Override - public void tick() { - super.tick(); - commandField.tick(); - } - - @Override - public void resize(MinecraftClient client, int width, int height) { - parent.resize(client,width,height); - } - - @Override - public void close() { - super.close(); - commandField.setTextFieldFocused(false); - commandField.setChangedListener(null); - commandMaroCommandSuggestor.setWindowActive(false); - commandMaroCommandSuggestor.refresh(); - commandMaroCommandSuggestor.close(); - } - - @Override - public boolean mouseClicked(double mouseX, double mouseY, int button) { - if (!commandField.mouseClicked(mouseX, mouseY, button)) { - if (!commandMaroCommandSuggestor.mouseClicked(mouseX, mouseY, button)) { - close(); - } else { - commandField.setTextFieldFocused(true); - } - return false; - } - return super.mouseClicked(mouseX, mouseY, button); - } - - @Override - public boolean mouseScrolled(double mouseX, double mouseY, double amount) { - return commandMaroCommandSuggestor.mouseScrolled(amount); - } - - @Override - public boolean charTyped(char chr, int modifiers) { - return commandField.charTyped(chr,modifiers); - } - - @Override - public boolean keyPressed(int keyCode, int scanCode, int modifiers) { - if (keyCode == InputUtil.GLFW_KEY_ESCAPE || keyCode == InputUtil.GLFW_KEY_ENTER || keyCode == InputUtil.GLFW_KEY_KP_ENTER) { - close(); - return true; - } - commandMaroCommandSuggestor.keyPressed(keyCode, scanCode, modifiers); - - return commandField.keyPressed(keyCode, scanCode, modifiers); - } - - @Override - public boolean keyReleased(int keyCode, int scanCode, int modifiers) { - return commandField.keyReleased(keyCode, scanCode, modifiers); - } -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/macros/gui/screen/MacroEditScreen.java b/oldSrc/main/java/tools/redstone/redstonetools/macros/gui/screen/MacroEditScreen.java deleted file mode 100644 index 8ad466c9..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/macros/gui/screen/MacroEditScreen.java +++ /dev/null @@ -1,259 +0,0 @@ -package tools.redstone.redstonetools.macros.gui.screen; - -import net.minecraft.client.gui.screen.ConfirmScreen; -import net.minecraft.client.gui.widget.ClickableWidget; -import net.minecraft.util.math.MathHelper; -import tools.redstone.redstonetools.macros.Macro; -import tools.redstone.redstonetools.macros.MacroManager; -import tools.redstone.redstonetools.macros.actions.Action; -import tools.redstone.redstonetools.macros.actions.CommandAction; -import tools.redstone.redstonetools.macros.gui.widget.commandlist.CommandEntry; -import tools.redstone.redstonetools.macros.gui.widget.commandlist.CommandListWidget; -import tools.redstone.redstonetools.macros.gui.widget.macrolist.MacroListWidget; -import net.minecraft.client.MinecraftClient; -import net.minecraft.client.gui.screen.Screen; -import net.minecraft.client.gui.screen.ScreenTexts; -import net.minecraft.client.gui.screen.option.GameOptionsScreen; -import net.minecraft.client.gui.widget.ButtonWidget; -import net.minecraft.client.gui.widget.TextFieldWidget; -import net.minecraft.client.option.GameOptions; -import net.minecraft.client.util.InputUtil; -import net.minecraft.client.util.InputUtil.Key; -import net.minecraft.client.util.InputUtil.Type; -import net.minecraft.client.util.math.MatrixStack; -import net.minecraft.text.LiteralText; -import net.minecraft.text.Text; -import net.minecraft.util.Formatting; -import tools.redstone.redstonetools.utils.KeyBindingUtils; - -import java.util.List; - -import static tools.redstone.redstonetools.RedstoneToolsClient.INJECTOR; - - -public class MacroEditScreen extends GameOptionsScreen { - private final MacroListWidget macroListWidget; - private final Macro macro; - - private CommandListWidget commandList; - private TextFieldWidget nameField; - private ButtonWidget doneButton; - private ButtonWidget keyBindButton; - - private boolean overlapped = false; - private boolean detectingKeycodeKey = false; - - public MacroEditScreen(Screen parent, GameOptions gameOptions, Text title, MacroListWidget macroListWidget) { - super(parent, gameOptions, title); - this.macroListWidget = macroListWidget; - this.macro = Macro.buildEmpty(); - } - - public MacroEditScreen(Screen parent, GameOptions gameOptions, Text title, MacroListWidget macroListWidget, Macro macro) { - super(parent, gameOptions, title); - this.macroListWidget = macroListWidget; - this.macro = macro.createCopy(); - } - - - @Override - public void init() { - super.init(); - overlapped = false; - nameField = new TextFieldWidget(this.textRenderer, this.width / 2 - 100, 22, 200, 20, Text.of("")); - nameField.setText(macro.name.trim()); - - doneButton = this.addDrawableChild(new ButtonWidget(this.width / 2 - 100, this.height / 4 + 144 + 5, 98, 20, Text.of("Done"), (button) -> { - String name = nameField.getText().trim(); - if (name.isEmpty()) return; - - updateMacroActions(); - - if (!macro.isCopy()) macroListWidget.addMacro(macro); - else macro.applyChangesToOriginal(); - - INJECTOR.getInstance(MacroManager.class).saveChanges(); - - client.setScreen(parent); - })); - doneButton.active = canClickDone(); - - nameField.setChangedListener(s -> { - macro.name = s.trim(); - doneButton.active = canClickDone(); - }); - addSelectableChild(nameField); - - - this.addDrawableChild(new ButtonWidget(this.width / 2 + 2, this.height / 4 + 144 + 5, 98, 20, ScreenTexts.CANCEL, (button) -> { - close(); - })); - - Key keyCode = macro.getKey(); - Text text = keyCode.getLocalizedText(); - if (keyCode == InputUtil.UNKNOWN_KEY) text = Text.of(""); - if ( KeyBindingUtils.isKeyAlreadyBound(keyCode) ) { text = new LiteralText(text.getString()).formatted(Formatting.RED); } - - keyBindButton = new ButtonWidget(this.width / 2 + 26, 55, 75, 20, text, (button) -> { - detectingKeycodeKey = true; - keyBindButton.setMessage((new LiteralText("> ")).append(keyBindButton.getMessage().shallowCopy().formatted(Formatting.YELLOW)).append(" <").formatted(Formatting.YELLOW)); - }); - if (detectingKeycodeKey) keyBindButton.onPress(); - - this.addDrawableChild(keyBindButton); - - int widgetWidth = 339; - List entries = null; - double scrollAmount = 0; - if (commandList != null) { - entries = commandList.children(); - scrollAmount = commandList.getScrollAmount(); - } - - commandList = new CommandListWidget(client, this, widgetWidth, height, 85, this.height / 4 + 144 + 5 - 10, 24); - commandList.setLeftPos(width / 2 - widgetWidth / 2); - - - if (entries != null) { - commandList.children().clear(); - for (CommandEntry entry : entries) { - entry.setOwner(commandList); - commandList.children().add(entry); - } - } else { - for (Action action : macro.actions) { - if (action instanceof CommandAction commandAction) { - commandList.addCommand(commandAction.command); - } - } - } - commandList.setScrollAmount(scrollAmount); - - this.addSelectableChild(commandList); - } - - private boolean canClickDone() { - return !nameField.getText().trim().isEmpty() && macroListWidget.canAdd(macro); - } - - @Override - public void render(MatrixStack matrices, int mouseX, int mouseY, float delta) { - if (overlapped) { - mouseX = -1; - mouseY = -1; - } - - this.renderBackgroundTexture(0); - commandList.render(matrices, mouseX, mouseY, delta); - super.render(matrices, mouseX, mouseY, delta); - - drawCenteredText(matrices, this.textRenderer, this.title, this.width / 2, 8, 16777215); - - drawCenteredText(matrices, this.textRenderer, "Key Bind", width / 2 - (99 - textRenderer.getWidth("Key Bind") / 2), 55 + textRenderer.fontHeight / 2, 16777215); - nameField.render(matrices, mouseX, mouseY, delta); - - if (nameField.getText().isEmpty() && !nameField.isFocused()) { - nameField.setSuggestion("Name"); - } else { - nameField.setSuggestion(""); - } - } - - @Override - public void tick() { - nameField.tick(); - commandList.tick(); - - super.tick(); - } - - @Override - public void resize(MinecraftClient client, int width, int height) { - super.resize(client, width, height); - if (overlapped) client.setScreen(new CommandEditScreen(this,gameOptions,commandList.getFocused().command)); - } - - - @Override - public void close(){ - if (!macro.isCopy() && macro.isEmpty()) { - super.close(); - return; - } - - updateMacroActions(); - if (macro.needsSaving()) { - client.setScreen(new ConfirmScreen(accept -> { - if (accept) client.setScreen(parent); - else client.setScreen(this); - }, Text.of("Unsaved changes"), Text.of("Are you sure you want to discard changes?"))); - } else { - super.close(); - } - } - - private void updateMacroActions() { - macro.actions.clear(); - - for (String command : commandList.getCommandList()) { - macro.actions.add(new CommandAction(command)); - } - } - - public void editCommandField(TextFieldWidget commandField) { - client.setScreen(new CommandEditScreen(this,gameOptions, commandField)); - overlapped = true; - } - - @Override - public boolean keyPressed(int keyCode, int scanCode, int modifiers) { - Key key = InputUtil.fromKeyCode(keyCode, scanCode); - if (keyCode == InputUtil.GLFW_KEY_ESCAPE) key = InputUtil.UNKNOWN_KEY; - - if (updateKeybinding(key)) return false; - if (commandList.keyPressed(keyCode, scanCode, modifiers)) return false; - if (keyCode == InputUtil.GLFW_KEY_TAB || keyCode == InputUtil.GLFW_KEY_SPACE) return false; - - return super.keyPressed(keyCode, scanCode, modifiers); - } - - @Override - public boolean keyReleased(int keyCode, int scanCode, int modifiers) { - if (commandList.keyReleased(keyCode, scanCode, modifiers)) return false; - - return super.keyReleased(keyCode, scanCode, modifiers); - } - - @Override - public boolean charTyped(char chr, int modifiers) { - if (commandList.charTyped(chr, modifiers)) return false; - - return super.charTyped(chr, modifiers); - } - - @Override - public boolean mouseClicked(double mouseX, double mouseY, int button) { - if (!commandList.isMouseOver(mouseX, mouseY)) commandList.mouseClicked(mouseX, mouseY, button); - if (updateKeybinding(Type.MOUSE.createFromCode(button))) return false; - - - return super.mouseClicked(mouseX, mouseY, button); - } - - private boolean updateKeybinding(Key key) { - if (detectingKeycodeKey) { - detectingKeycodeKey = false; - Text text = key.getLocalizedText(); - if (key == InputUtil.UNKNOWN_KEY) text = Text.of(""); - if ( KeyBindingUtils.isKeyAlreadyBound(key) ) { text = new LiteralText(text.getString()).formatted(Formatting.RED); } - - keyBindButton.setMessage(text); - macro.setKey(key); - return true; - } - - return false; - } - - -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/macros/gui/screen/MacroSelectScreen.java b/oldSrc/main/java/tools/redstone/redstonetools/macros/gui/screen/MacroSelectScreen.java deleted file mode 100644 index cab88a08..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/macros/gui/screen/MacroSelectScreen.java +++ /dev/null @@ -1,52 +0,0 @@ -package tools.redstone.redstonetools.macros.gui.screen; - -import tools.redstone.redstonetools.macros.gui.widget.macrolist.MacroEntry; -import tools.redstone.redstonetools.macros.gui.widget.macrolist.MacroListWidget; -import net.minecraft.client.gui.screen.Screen; -import net.minecraft.client.gui.screen.ScreenTexts; -import net.minecraft.client.gui.screen.option.GameOptionsScreen; -import net.minecraft.client.gui.widget.ButtonWidget; -import net.minecraft.client.option.GameOptions; -import net.minecraft.client.util.math.MatrixStack; -import net.minecraft.text.Text; - -public class MacroSelectScreen extends GameOptionsScreen { - - - private MacroListWidget macroList; - - public MacroSelectScreen(Screen parent, GameOptions gameOptions, Text title) { - super(parent, gameOptions, title); - } - - @Override - public void init() { - super.init(); - - this.macroList = new MacroListWidget(this,client); - this.addSelectableChild(this.macroList); - - this.addDrawableChild(new ButtonWidget(this.width / 2 +1, this.height - 29, 150, 20, Text.of("Create New..."), (button) -> { - this.client.setScreen(new MacroEditScreen(this,gameOptions,Text.of("New Macro"), macroList)); - })); - - this.addDrawableChild(new ButtonWidget(this.width / 2 - 151, this.height - 29, 150, 20, ScreenTexts.DONE, (button) -> { - this.client.setScreen(this.parent); - })); - } - - @Override - public void render(MatrixStack matrices, int mouseX, int mouseY, float delta) { - this.renderBackgroundTexture(0); - macroList.render(matrices, mouseX, mouseY, delta); - - drawCenteredText(matrices, this.textRenderer, this.title, this.width / 2, 8, 16777215); - super.render(matrices, mouseX, mouseY, delta); - - } - - public void openEditScreen(MacroEntry entry) { - client.setScreen(new MacroEditScreen(this,gameOptions,Text.of("Edit Macro"), macroList, entry.macro)); - } - -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/macros/gui/widget/IconButtonWidget.java b/oldSrc/main/java/tools/redstone/redstonetools/macros/gui/widget/IconButtonWidget.java deleted file mode 100644 index e6e08235..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/macros/gui/widget/IconButtonWidget.java +++ /dev/null @@ -1,35 +0,0 @@ -package tools.redstone.redstonetools.macros.gui.widget; - -import com.mojang.blaze3d.platform.GlStateManager; -import com.mojang.blaze3d.systems.RenderSystem; -import net.minecraft.client.gui.widget.ButtonWidget; -import net.minecraft.client.util.math.MatrixStack; -import net.minecraft.text.Text; -import net.minecraft.util.Identifier; - -public class IconButtonWidget extends ButtonWidget { - - public static Identifier CROSS_ICON = new Identifier("redstonetools","gui/cross.png"); - public static Identifier PENCIL_ICON = new Identifier("redstonetools","gui/pencil.png"); - - private final Identifier texture; - public IconButtonWidget(Identifier texture ,int x, int y, int width, int height, Text message, PressAction onPress) { - super(x, y, width, height, message, onPress); - this.texture = texture; - } - - public void renderButton(MatrixStack matrices, int mouseX, int mouseY, float delta) { - super.renderButton(matrices, mouseX, mouseY, delta); - - - RenderSystem.setShaderTexture(0, texture); - RenderSystem.enableDepthTest(); - - RenderSystem.setShaderColor(1.0F, 1.0F, 1.0F, this.alpha); - RenderSystem.enableBlend(); - RenderSystem.defaultBlendFunc(); - RenderSystem.blendFunc(GlStateManager.SrcFactor.SRC_ALPHA, GlStateManager.DstFactor.ONE_MINUS_SRC_ALPHA); - drawTexture(matrices, this.x, this.y, 0,0, 20, this.height, 20, 20); - } - -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/macros/gui/widget/commandlist/CommandEntry.java b/oldSrc/main/java/tools/redstone/redstonetools/macros/gui/widget/commandlist/CommandEntry.java deleted file mode 100644 index afb75e28..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/macros/gui/widget/commandlist/CommandEntry.java +++ /dev/null @@ -1,112 +0,0 @@ -package tools.redstone.redstonetools.macros.gui.widget.commandlist; - -import tools.redstone.redstonetools.macros.gui.MaroCommandSuggestor; -import tools.redstone.redstonetools.macros.gui.widget.IconButtonWidget; -import net.minecraft.client.MinecraftClient; -import net.minecraft.client.gui.widget.ButtonWidget; -import net.minecraft.client.gui.widget.EntryListWidget; -import net.minecraft.client.gui.widget.TextFieldWidget; -import net.minecraft.client.util.math.MatrixStack; -import net.minecraft.text.Text; - -public class CommandEntry extends EntryListWidget.Entry { - - - protected CommandListWidget owner; - - public final TextFieldWidget command; - protected final ButtonWidget deleteButton; - - - public CommandEntry(MinecraftClient client, CommandListWidget owner, String text) { - this.owner = owner; - - command = new TextFieldWidget(client.textRenderer, 0, 0, 300, 20, Text.of("")); - command.setMaxLength(255); - command.setText(text); - - deleteButton = new IconButtonWidget(IconButtonWidget.CROSS_ICON,0, 0, 20, 20, Text.of(""), (button) -> { - this.owner.removeCommand(this); - }); - - MaroCommandSuggestor commandMaroCommandSuggestor = new MaroCommandSuggestor(client, owner.getParent(), command,client.textRenderer,true,false, 0,0,0); - commandMaroCommandSuggestor.setWindowActive(false); - commandMaroCommandSuggestor.refresh(); - commandMaroCommandSuggestor.close(); - } - - - @Override - public void render(MatrixStack matrices, int index, int y, int x, int entryWidth, int entryHeight, int mouseX, int mouseY, boolean hovered, float tickDelta) { - command.x = owner.getParent().width/2-owner.getWidth()/2+5; - command.y = y; - command.render(matrices,mouseX,mouseY,tickDelta); - - - deleteButton.x = command.x + command.getWidth()+5; - deleteButton.y = y; - deleteButton.render(matrices,mouseX,mouseY,tickDelta); - - if (edit) { - edit = false; - owner.getParent().editCommandField(command); - } - } - - public void tick() { - command.tick(); - } - private boolean edit = false; - - public void setFocused(boolean focused){ - command.setTextFieldFocused(focused); - if (focused){ - owner.centerScrollOn(this); - edit = true; - } - owner.focusOn(this); - } - - protected String getText() { - return command.getText(); - } - - public void setOwner(CommandListWidget owner) { - this.owner = owner; - } - - @Override - public boolean mouseClicked(double mouseX, double mouseY, int button) { - if (command.mouseClicked(mouseX,mouseY,button)) { - owner.centerScrollOn(this); - edit = true; - return true; - } - deleteButton.mouseClicked(mouseX,mouseY,button); - - return super.mouseClicked(mouseX, mouseY, button); - } - - @Override - public boolean charTyped(char chr, int modifiers) { - if (command.isFocused()) return command.charTyped(chr,modifiers); - - return super.charTyped(chr, modifiers); - } - - @Override - public boolean keyPressed(int keyCode, int scanCode, int modifiers) { - if (command.isFocused()) { - return command.keyPressed(keyCode, scanCode, modifiers); - } - - return super.keyPressed(keyCode, scanCode, modifiers); - } - - @Override - public boolean keyReleased(int keyCode, int scanCode, int modifiers) { - if (command.isFocused()) return command.keyReleased(keyCode, scanCode, modifiers); - - return super.keyReleased(keyCode, scanCode, modifiers); - } -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/macros/gui/widget/commandlist/CommandEntryPlaceHolder.java b/oldSrc/main/java/tools/redstone/redstonetools/macros/gui/widget/commandlist/CommandEntryPlaceHolder.java deleted file mode 100644 index ac8103de..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/macros/gui/widget/commandlist/CommandEntryPlaceHolder.java +++ /dev/null @@ -1,23 +0,0 @@ -package tools.redstone.redstonetools.macros.gui.widget.commandlist; - -import net.minecraft.client.MinecraftClient; -import net.minecraft.client.util.math.MatrixStack; - -public class CommandEntryPlaceHolder extends CommandEntry{ - public CommandEntryPlaceHolder(MinecraftClient client, CommandListWidget owner, String text) { - super(client, owner, text); - super.deleteButton.visible = false; - } - - @Override - public void render(MatrixStack matrices, int index, int y, int x, int entryWidth, int entryHeight, int mouseX, int mouseY, boolean hovered, float tickDelta) { - command.setSuggestion("Add new command"); - if (!super.command.getText().isEmpty()) { - super.owner.addCommandFromPlaceHolder(command.getText(),this); - command.setText(""); - } - - super.render(matrices, index, y, x, entryWidth, entryHeight, mouseX, mouseY, hovered, tickDelta); - } - -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/macros/gui/widget/commandlist/CommandListWidget.java b/oldSrc/main/java/tools/redstone/redstonetools/macros/gui/widget/commandlist/CommandListWidget.java deleted file mode 100644 index a62653b3..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/macros/gui/widget/commandlist/CommandListWidget.java +++ /dev/null @@ -1,127 +0,0 @@ -package tools.redstone.redstonetools.macros.gui.widget.commandlist; - -import tools.redstone.redstonetools.macros.gui.screen.MacroEditScreen; -import net.minecraft.client.MinecraftClient; -import net.minecraft.client.gui.screen.narration.NarrationMessageBuilder; -import net.minecraft.client.gui.widget.EntryListWidget; - -import java.util.ArrayList; -import java.util.List; - -public class CommandListWidget extends EntryListWidget { - - private final MacroEditScreen parent; - - public CommandListWidget(MinecraftClient client, MacroEditScreen parent, int width, int height, int top, int bottom, int itemHeight) { - super(client, width, height, top, bottom, itemHeight); - this.parent = parent; - addEntry(new CommandEntryPlaceHolder(client,this,"")); - } - - public void tick() { - for (CommandEntry entry : children()) { - entry.tick(); - } - } - - - - public CommandEntry addCommand(String command) { - CommandEntry entry = new CommandEntry(client,this,command); - List entries = children(); - - entries.add(entries.size()-1,entry); - - return entry; - } - - protected void addCommandFromPlaceHolder(String command,CommandEntryPlaceHolder placeHolder) { - CommandEntry entry = addCommand(command); - placeHolder.setFocused(false); - - entry.command.x = placeHolder.command.x; - entry.command.y = placeHolder.command.y; - entry.setFocused(true); - } - - public void centerScrollOn(CommandEntry entry) { - super.centerScrollOn(entry); - } - - - - protected void removeCommand(CommandEntry command) { - removeEntry(command); - setScrollAmount(getScrollAmount()); - } - - protected int getScrollbarPositionX() { - return parent.width/2+this.width/2-4; - } - - public List getCommandList() { - List list = new ArrayList<>(); - - for (int i = 0; i < children().size(); i++){ - CommandEntry command = getEntry(i); - if (command instanceof CommandEntryPlaceHolder) continue; - - list.add(command.getText()); - } - - return list; - } - - @Override - public boolean charTyped(char chr, int modifiers) { - for (CommandEntry entry : children()) { - entry.charTyped(chr,modifiers); - } - - return super.charTyped(chr, modifiers); - } - - @Override - public boolean keyPressed(int keyCode, int scanCode, int modifiers) { - for (CommandEntry entry : children()) { - entry.keyPressed(keyCode, scanCode, modifiers); - } - - return super.keyPressed(keyCode, scanCode, modifiers); - } - - @Override - public boolean keyReleased(int keyCode, int scanCode, int modifiers) { - for (CommandEntry entry : children()) { - entry.keyReleased(keyCode, scanCode, modifiers); - } - - return super.keyReleased(keyCode, scanCode, modifiers); - } - - @Override - public boolean mouseClicked(double mouseX, double mouseY, int button) { - CommandEntry clickedEntry = getEntryAtPosition(mouseX,mouseY); - for (CommandEntry entry : children()) { - if (entry != clickedEntry) entry.setFocused(false); - } - - return super.mouseClicked(mouseX, mouseY, button); - } - - protected MacroEditScreen getParent() { - return parent; - } - - @Override - public int getRowWidth() { - return width; - } - - public int getWidth() { - return this.width; - } - - @Override - public void appendNarrations(NarrationMessageBuilder builder) {} -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/macros/gui/widget/macrolist/MacroEntry.java b/oldSrc/main/java/tools/redstone/redstonetools/macros/gui/widget/macrolist/MacroEntry.java deleted file mode 100644 index 443de635..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/macros/gui/widget/macrolist/MacroEntry.java +++ /dev/null @@ -1,117 +0,0 @@ -package tools.redstone.redstonetools.macros.gui.widget.macrolist; - -import tools.redstone.redstonetools.macros.Macro; -import tools.redstone.redstonetools.macros.gui.widget.IconButtonWidget; -import net.minecraft.client.gui.screen.ConfirmScreen; -import net.minecraft.client.gui.widget.*; -import net.minecraft.client.sound.PositionedSoundInstance; -import net.minecraft.client.util.math.MatrixStack; -import net.minecraft.sound.SoundEvents; -import net.minecraft.text.Text; -import net.minecraft.text.TranslatableText; - -public class MacroEntry extends AlwaysSelectedEntryListWidget.Entry{ - - private final MacroListWidget owner; - - private final CheckboxWidget buttonWidget; - private final ButtonWidget deleteButton; - private final ButtonWidget editButton; - public final Macro macro; - - - public MacroEntry(Macro macro, MacroListWidget owner) { - this.macro = macro; - this.owner = owner; - - buttonWidget = new CheckboxWidget(0, 0, 20, 20, null, macro.enabled, false); - deleteButton = new IconButtonWidget(IconButtonWidget.CROSS_ICON,0, 0, 20, 20 ,Text.of(""), (button) -> { - deleteIfConfirmed(); - }); - editButton = new IconButtonWidget(IconButtonWidget.PENCIL_ICON,0, 0, 20, 20, Text.of(""), (button) -> { - owner.parent.openEditScreen(this); - }); - } - - - public void render(MatrixStack matrices, int index, int y, int x, int entryWidth, int entryHeight, int mouseX, int mouseY, boolean hovered, float tickDelta) { - renderWidget(buttonWidget,matrices,mouseX,mouseY,tickDelta,x-30,y-2); - renderWidget(editButton,matrices,mouseX,mouseY,tickDelta,x+entryWidth,y-2); - renderWidget(deleteButton,matrices,mouseX,mouseY,tickDelta,x+entryWidth+22,y-2); - - String text = macro.name; - - if (owner.client.textRenderer.getWidth(text) > owner.getRowWidth()-2) { - while (owner.client.textRenderer.getWidth(text + "...") > owner.getRowWidth()-2) { - text = text.substring(0,text.length()-1); - } - - text += "..."; - } - - - owner.client.textRenderer.drawWithShadow(matrices, text, x, y+3,macro.enabled?16777215:8355711, true); - } - - private void renderWidget(PressableWidget widget, MatrixStack matrices, int mouseX, int mouseY, float tickDelta, int x, int y) { - widget.x = x; - widget.y = y; - widget.render(matrices,mouseX,mouseY,tickDelta); - } - - public boolean mouseClicked(double mouseX, double mouseY, int button) { - if (button == 0) { - this.onPressed(); - return true; - } else { - return false; - } - } - - public void mouseClickedInRow(double mouseX, double mouseY, int button) { - if (button != 0) return; - - if (clickWidget(buttonWidget, mouseX, mouseY)) macro.enabled = buttonWidget.isChecked(); - clickWidget(editButton,mouseX,mouseY); - clickWidget(deleteButton,mouseX,mouseY); - - - } - - - private boolean clickWidget(ClickableWidget widget, double mouseX, double mouseY) { - if (widget.isMouseOver(mouseX,mouseY)) { - owner.client.getSoundManager().play(PositionedSoundInstance.master(SoundEvents.UI_BUTTON_CLICK, 1.0F)); - widget.onClick(mouseX,mouseY); - - return true; - } - return false; - } - - private void onPressed() { - owner.setSelected(this); - } - - public Text getNarration() { - return new TranslatableText("narrator.select"); - } - - - public void delete() { - owner.removeEntry(this); - macro.unregisterKeyBinding(); - MacroListWidget.macroManager.removeMacro(this.macro); - MacroListWidget.macroManager.updateMacroKeys(); - } - - public void deleteIfConfirmed() { - owner.client.setScreen(new ConfirmScreen((confirmed) -> { - if (confirmed) { - this.delete(); - } - - owner.client.setScreen(owner.parent); - }, Text.of("Delete macro"), Text.of("Are you sure you want to delete '" + macro.name + "'?"))); - } -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/macros/gui/widget/macrolist/MacroListWidget.java b/oldSrc/main/java/tools/redstone/redstonetools/macros/gui/widget/macrolist/MacroListWidget.java deleted file mode 100644 index 333f2bf4..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/macros/gui/widget/macrolist/MacroListWidget.java +++ /dev/null @@ -1,77 +0,0 @@ -package tools.redstone.redstonetools.macros.gui.widget.macrolist; - -import tools.redstone.redstonetools.macros.Macro; -import tools.redstone.redstonetools.macros.MacroManager; -import tools.redstone.redstonetools.macros.gui.screen.MacroSelectScreen; -import net.minecraft.client.MinecraftClient; -import net.minecraft.client.gui.widget.AlwaysSelectedEntryListWidget; -import net.minecraft.client.util.math.MatrixStack; - -import static tools.redstone.redstonetools.RedstoneToolsClient.INJECTOR; - -public class MacroListWidget extends AlwaysSelectedEntryListWidget { - - protected static final MacroManager macroManager = INJECTOR.getInstance(MacroManager.class); - - protected final MacroSelectScreen parent; - protected final MinecraftClient client; - - - public MacroListWidget(MacroSelectScreen parent, MinecraftClient client) { - super(client, parent.width, parent.height, 20, parent.height - 42, 20); - this.parent = parent; - this.client = client; - - for (Macro macro : macroManager.getMacros()) { - addEntry(new MacroEntry(macro,this)); - } - - - if (this.getSelectedOrNull() != null) { - this.centerScrollOn(this.getEntry(0)); - } - } - - public void addMacro(Macro macro) { - macroManager.addMacro(macro); - addEntry(new MacroEntry(macro, this)); - } - - public boolean canAdd(Macro macro) { - Macro macroFromName = macroManager.getMacro(macro.name); - - return macroFromName == null || macro.isCopyOf(macroFromName); - } - - protected int getScrollbarPositionX() { - return super.getScrollbarPositionX() + 20; - } - - - protected void renderBackground(MatrixStack matrices) { - parent.renderBackground(matrices); - } - - protected boolean isFocused() { - return parent.getFocused() == this; - } - - @Override - public boolean mouseClicked(double mouseX, double mouseY, int button) { - MacroEntry entry = super.getEntryAtPosition(width/2,mouseY); - if (entry != null) entry.mouseClickedInRow(mouseX,mouseY,button); - - return super.mouseClicked(mouseX, mouseY, button); - } - - @Override - public int getRowWidth() { - return 120; - } - - @Override - public boolean removeEntry(MacroEntry entry){ - return super.removeEntry(entry); - } - -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/mixin/accessors/MinecraftClientAccessor.java b/oldSrc/main/java/tools/redstone/redstonetools/mixin/accessors/MinecraftClientAccessor.java deleted file mode 100644 index 6996cf54..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/mixin/accessors/MinecraftClientAccessor.java +++ /dev/null @@ -1,15 +0,0 @@ -package tools.redstone.redstonetools.mixin.accessors; - -import net.minecraft.block.entity.BlockEntity; -import net.minecraft.client.MinecraftClient; -import net.minecraft.item.ItemStack; -import org.spongepowered.asm.mixin.Mixin; -import org.spongepowered.asm.mixin.gen.Invoker; - -@Mixin(MinecraftClient.class) -public interface MinecraftClientAccessor { - - @Invoker - ItemStack invokeAddBlockEntityNbt(ItemStack stack, BlockEntity blockEntity); - -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/mixin/accessors/WorldRendererAccessor.java b/oldSrc/main/java/tools/redstone/redstonetools/mixin/accessors/WorldRendererAccessor.java deleted file mode 100644 index 88ff872a..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/mixin/accessors/WorldRendererAccessor.java +++ /dev/null @@ -1,18 +0,0 @@ -package tools.redstone.redstonetools.mixin.accessors; - -import net.minecraft.block.BlockState; -import net.minecraft.client.render.VertexConsumer; -import net.minecraft.client.render.WorldRenderer; -import net.minecraft.client.util.math.MatrixStack; -import net.minecraft.entity.Entity; -import net.minecraft.util.math.BlockPos; -import org.spongepowered.asm.mixin.Mixin; -import org.spongepowered.asm.mixin.gen.Invoker; - -@Mixin(WorldRenderer.class) -public interface WorldRendererAccessor { - - @Invoker - void invokeDrawBlockOutline(MatrixStack matrices, VertexConsumer vertexConsumer, Entity entity, double d, double e, double f, BlockPos pos, BlockState state); - -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/mixin/blocks/RedstoneHitboxMixin.java b/oldSrc/main/java/tools/redstone/redstonetools/mixin/blocks/RedstoneHitboxMixin.java deleted file mode 100644 index 663852fc..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/mixin/blocks/RedstoneHitboxMixin.java +++ /dev/null @@ -1,46 +0,0 @@ -package tools.redstone.redstonetools.mixin.blocks; - -import net.minecraft.block.Block; -import net.minecraft.block.BlockState; -import net.minecraft.block.RedstoneWireBlock; -import net.minecraft.block.ShapeContext; -import net.minecraft.util.math.BlockPos; -import net.minecraft.util.shape.VoxelShape; -import net.minecraft.world.BlockView; -import org.spongepowered.asm.mixin.*; -import org.spongepowered.asm.mixin.injection.At; -import org.spongepowered.asm.mixin.injection.Inject; -import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable; -import tools.redstone.redstonetools.RedstoneToolsClient; -import tools.redstone.redstonetools.features.toggleable.BigDustFeature; - -import java.util.HashMap; -import java.util.Map; - -@Pseudo -@Mixin(RedstoneWireBlock.class) -public class RedstoneHitboxMixin { - - private static BigDustFeature bigDustFeature; - - // use array for better performance - private static final VoxelShape[] SHAPES = new VoxelShape[16]; - - @Inject(method="getOutlineShape", at = @At("HEAD"), cancellable = true) - public void getOutlineShape(BlockState state, BlockView world, BlockPos pos, ShapeContext context, CallbackInfoReturnable cir) { - if (bigDustFeature == null) { - bigDustFeature = RedstoneToolsClient.INJECTOR.getInstance(BigDustFeature.class); - } - - if (bigDustFeature.isEnabled()) { - cir.setReturnValue(SHAPES[BigDustFeature.heightInPixels.getValue() - 1]); - } - } - - static { - for (int i = 1; i <= 16; i++) { - SHAPES[i - 1] = Block.createCuboidShape(0.0, 0.0, 0.0, 16.0, i, 16.0); - } - } - -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/mixin/features/AirPlaceClientMixin.java b/oldSrc/main/java/tools/redstone/redstonetools/mixin/features/AirPlaceClientMixin.java deleted file mode 100644 index 9236718d..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/mixin/features/AirPlaceClientMixin.java +++ /dev/null @@ -1,85 +0,0 @@ -package tools.redstone.redstonetools.mixin.features; - -import net.minecraft.client.MinecraftClient; -import net.minecraft.client.network.ClientPlayerEntity; -import net.minecraft.client.network.ClientPlayerInteractionManager; -import net.minecraft.util.hit.BlockHitResult; -import net.minecraft.util.hit.HitResult; -import net.minecraft.util.math.BlockPos; -import net.minecraft.util.math.Direction; -import org.spongepowered.asm.mixin.Mixin; -import org.spongepowered.asm.mixin.Shadow; -import org.spongepowered.asm.mixin.injection.At; -import org.spongepowered.asm.mixin.injection.Inject; -import org.spongepowered.asm.mixin.injection.callback.CallbackInfo; -import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable; -import org.spongepowered.asm.mixin.injection.callback.LocalCapture; -import tools.redstone.redstonetools.RedstoneToolsClient; -import tools.redstone.redstonetools.features.toggleable.AirPlaceFeature; -import tools.redstone.redstonetools.utils.RaycastUtils; - -@Mixin(MinecraftClient.class) -public class AirPlaceClientMixin { - private final AirPlaceFeature airPlaceFeature = RedstoneToolsClient.INJECTOR.getInstance(AirPlaceFeature.class); - - @Shadow - public HitResult crosshairTarget; - - @Inject(method = "doItemUse", at = @At(value = "HEAD"), locals = LocalCapture.CAPTURE_FAILHARD) - public void doItemUse(CallbackInfo callbackInfo) { - if (!isAirPlaceAllowed()) { - return; - } - - crosshairTarget = AirPlaceFeature.findAirPlaceBlockHit(getPlayer()); - } - - @Inject(method = "doAttack", at = @At(value = "HEAD"), locals = LocalCapture.CAPTURE_FAILHARD) - public void doAttack(CallbackInfoReturnable cir) { - if (!isAirPlaceAllowed()) { - return; - } - - // Call interactionManager directly because the block is air, with which the player cannot interact - var hit = AirPlaceFeature.findAirPlaceBlockHit(getPlayer()); - getInteractionManager().attackBlock(hit.getBlockPos(), hit.getSide()); - } - - private boolean isAirPlaceAllowed() { - // If air place is disabled - if (!airPlaceFeature.isEnabled()) { - return false; - } - - // If the hit result is already set - if (crosshairTarget != null && crosshairTarget.getType() != HitResult.Type.MISS) { - return false; - } - - // If the player or interactionManager not initialized - if (getPlayer() == null || getInteractionManager() == null) { - return false; - } - - // If air place isn't possible with the current - // player equipment and state - if (!AirPlaceFeature.canAirPlace(getPlayer())) { - return false; - } - - return true; - } - - private MinecraftClient getMinecraftClient() { - return (MinecraftClient) (Object) this; - } - - private ClientPlayerEntity getPlayer() { - return getMinecraftClient().player; - } - - private ClientPlayerInteractionManager getInteractionManager() { - return getMinecraftClient().interactionManager; - } - -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/mixin/features/AirPlaceServerMixin.java b/oldSrc/main/java/tools/redstone/redstonetools/mixin/features/AirPlaceServerMixin.java deleted file mode 100644 index 5b12380e..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/mixin/features/AirPlaceServerMixin.java +++ /dev/null @@ -1,27 +0,0 @@ -package tools.redstone.redstonetools.mixin.features; - -import net.minecraft.server.network.ServerPlayNetworkHandler; -import org.spongepowered.asm.mixin.Mixin; -import org.spongepowered.asm.mixin.injection.Constant; -import org.spongepowered.asm.mixin.injection.ModifyConstant; -import tools.redstone.redstonetools.RedstoneToolsClient; -import tools.redstone.redstonetools.features.toggleable.AirPlaceFeature; - -@Mixin(ServerPlayNetworkHandler.class) -public class AirPlaceServerMixin { - - private final AirPlaceFeature airPlaceFeature = RedstoneToolsClient.INJECTOR.getInstance(AirPlaceFeature.class); - - @ModifyConstant(method = "onPlayerInteractBlock", constant = @Constant(doubleValue = 64.0) ) - private double modifyConstant(double originalValue) { - - if (airPlaceFeature.isEnabled()) { - float reach5 = AirPlaceFeature.reach.getValue() + 5; - return reach5 * reach5; - } else { - return originalValue; - } - - } - -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/mixin/features/AutoDustMixin.java b/oldSrc/main/java/tools/redstone/redstonetools/mixin/features/AutoDustMixin.java deleted file mode 100644 index f1131970..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/mixin/features/AutoDustMixin.java +++ /dev/null @@ -1,54 +0,0 @@ -package tools.redstone.redstonetools.mixin.features; - -import net.minecraft.block.Block; -import net.minecraft.block.BlockState; -import net.minecraft.block.Blocks; -import net.minecraft.entity.LivingEntity; -import net.minecraft.entity.player.PlayerEntity; -import net.minecraft.item.ItemPlacementContext; -import net.minecraft.item.ItemStack; -import net.minecraft.item.Items; -import net.minecraft.util.Hand; -import net.minecraft.util.hit.BlockHitResult; -import net.minecraft.util.math.BlockPos; -import net.minecraft.util.math.Direction; -import net.minecraft.util.math.Vec3d; -import net.minecraft.world.World; -import org.spongepowered.asm.mixin.Mixin; -import org.spongepowered.asm.mixin.injection.At; -import org.spongepowered.asm.mixin.injection.Inject; -import org.spongepowered.asm.mixin.injection.callback.CallbackInfo; -import tools.redstone.redstonetools.RedstoneToolsClient; -import tools.redstone.redstonetools.features.toggleable.AutoDustFeature; -import tools.redstone.redstonetools.utils.ColoredBlock; - -@Mixin(Block.class) -public abstract class AutoDustMixin { - private AutoDustFeature autoDustFeature; - - private AutoDustFeature getAutoDustFeature() { - if (autoDustFeature == null) { - autoDustFeature = RedstoneToolsClient.INJECTOR.getInstance(AutoDustFeature.class); - } - - return autoDustFeature; - } - - @Inject(method = "onPlaced", at = @At("TAIL")) - private void onPlaced(World world, BlockPos pos, BlockState state, LivingEntity placer, ItemStack itemStack, CallbackInfo ci) { - if (!getAutoDustFeature().isEnabled()) { - return; - } - - var dustPos = pos.up(); - var block = world.getBlockState(pos).getBlock(); - var blockAbove = world.getBlockState(dustPos).getBlock(); - - if (!blockAbove.equals(Blocks.AIR) || ColoredBlock.fromBlock(block) == null) { - return; - } - - ItemPlacementContext context = new ItemPlacementContext((PlayerEntity) placer, Hand.MAIN_HAND,new ItemStack(Items.REDSTONE),new BlockHitResult(new Vec3d(dustPos.getX(),dustPos.getY(),dustPos.getZ()), Direction.UP, dustPos,false)); - placer.getWorld().setBlockState(dustPos, Blocks.REDSTONE_WIRE.getPlacementState(context)); - } -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/mixin/features/CopyStateMixin.java b/oldSrc/main/java/tools/redstone/redstonetools/mixin/features/CopyStateMixin.java deleted file mode 100644 index 1478b497..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/mixin/features/CopyStateMixin.java +++ /dev/null @@ -1,29 +0,0 @@ -package tools.redstone.redstonetools.mixin.features; - -import net.minecraft.block.Block; -import net.minecraft.block.BlockState; -import net.minecraft.item.BlockItem; -import net.minecraft.item.ItemPlacementContext; -import org.spongepowered.asm.mixin.Mixin; -import org.spongepowered.asm.mixin.Shadow; -import org.spongepowered.asm.mixin.injection.At; -import org.spongepowered.asm.mixin.injection.Inject; -import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable; -import tools.redstone.redstonetools.utils.BlockStateNbtUtil; - - -@Mixin(BlockItem.class) -public abstract class CopyStateMixin { - - @Shadow protected abstract boolean canPlace(ItemPlacementContext context, BlockState state); - @Shadow public abstract Block getBlock(); - - @Inject(method = "getPlacementState", at = @At("TAIL"), cancellable = true) - public void getPlacementState(ItemPlacementContext context, CallbackInfoReturnable cir) { - BlockState state = BlockStateNbtUtil.getPlacementStateOrNull(context.getStack()); - if (state != null && this.canPlace(context, state)) { - cir.setReturnValue(state); - } - } - -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/mixin/features/ItemBindMixin.java b/oldSrc/main/java/tools/redstone/redstonetools/mixin/features/ItemBindMixin.java deleted file mode 100644 index ee194cba..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/mixin/features/ItemBindMixin.java +++ /dev/null @@ -1,78 +0,0 @@ -package tools.redstone.redstonetools.mixin.features; - -import net.minecraft.client.MinecraftClient; -import net.minecraft.client.network.ClientPlayerEntity; -import net.minecraft.entity.Entity; -import net.minecraft.entity.player.PlayerEntity; -import net.minecraft.item.ItemStack; -import net.minecraft.item.ItemUsageContext; -import net.minecraft.nbt.NbtCompound; -import net.minecraft.nbt.NbtString; -import net.minecraft.util.ActionResult; -import net.minecraft.util.Hand; -import net.minecraft.util.TypedActionResult; -import net.minecraft.world.World; -import org.jetbrains.annotations.Nullable; -import org.spongepowered.asm.mixin.Mixin; -import org.spongepowered.asm.mixin.Shadow; -import org.spongepowered.asm.mixin.injection.At; -import org.spongepowered.asm.mixin.injection.Inject; -import org.spongepowered.asm.mixin.injection.callback.CallbackInfo; -import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable; -import tools.redstone.redstonetools.features.commands.ItemBindFeature; -import tools.redstone.redstonetools.features.feedback.Feedback; -import tools.redstone.redstonetools.features.feedback.FeedbackSender; - -import static tools.redstone.redstonetools.RedstoneToolsClient.INJECTOR; - - -public abstract class ItemBindMixin { - - @Mixin(ItemStack.class) - private abstract static class ItemStackMixin { - - @Shadow - public abstract @Nullable NbtCompound getNbt(); - - @Inject(method = "use", at = @At("HEAD"), cancellable = true) - public void checkCommandNBT(World world, PlayerEntity user, Hand hand, CallbackInfoReturnable> cir) { - if (tryToExecuteNBTCommand(hand, world)) { - cir.setReturnValue(TypedActionResult.pass((ItemStack) ((Object) this))); - } - } - - @Inject(method = "useOnBlock", at = @At("HEAD"), cancellable = true) - public void checkCommandNBT(ItemUsageContext context, CallbackInfoReturnable cir) { - if (tryToExecuteNBTCommand(context.getHand(), context.getWorld())) { - cir.setReturnValue(ActionResult.PASS); - } - } - - private boolean tryToExecuteNBTCommand(Hand hand, World world) { - if (hand == Hand.OFF_HAND || world.isClient) return false; - NbtCompound nbt = getNbt(); - if (nbt == null || !nbt.contains("command")) return false; - NbtString command = (NbtString) nbt.get("command"); - MinecraftClient.getInstance().player.sendChatMessage(command.asString()); - - return true; - } - } - - @Mixin(ClientPlayerEntity.class) - private abstract static class PlayerMixin { - - @Inject(method = "sendChatMessage", at = @At("HEAD"), cancellable = true) - public void injectCommand(String message, CallbackInfo ci) { - if (!message.startsWith("/") || !ItemBindFeature.waitingForCommand) return; - - Feedback addCommandFeedback = ItemBindFeature.addCommand(message); - if (addCommandFeedback != null) { - INJECTOR.getInstance(FeedbackSender.class).sendFeedback(((Entity) ((Object)this)).getCommandSource(),addCommandFeedback); - ci.cancel(); - } - } - } - - -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/mixin/gamerules/DoContainerDropsMixin.java b/oldSrc/main/java/tools/redstone/redstonetools/mixin/gamerules/DoContainerDropsMixin.java deleted file mode 100644 index 48280e65..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/mixin/gamerules/DoContainerDropsMixin.java +++ /dev/null @@ -1,20 +0,0 @@ -package tools.redstone.redstonetools.mixin.gamerules; - -import net.minecraft.inventory.Inventory; -import net.minecraft.util.ItemScatterer; -import net.minecraft.util.math.BlockPos; -import net.minecraft.world.World; -import org.spongepowered.asm.mixin.Mixin; -import org.spongepowered.asm.mixin.injection.At; -import org.spongepowered.asm.mixin.injection.Inject; -import org.spongepowered.asm.mixin.injection.callback.CallbackInfo; - -import static tools.redstone.redstonetools.RedstoneToolsGameRules.DO_CONTAINER_DROPS; - -@Mixin(ItemScatterer.class) -public class DoContainerDropsMixin { - @Inject(method = "spawn(Lnet/minecraft/world/World;Lnet/minecraft/util/math/BlockPos;Lnet/minecraft/inventory/Inventory;)V", at = @At("HEAD"), cancellable = true) - private static void spawn(World world, BlockPos pos, Inventory inventory, CallbackInfo ci) { - if (!world.getGameRules().getBoolean(DO_CONTAINER_DROPS)) ci.cancel(); - } -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/mixin/macros/AddMacroButtonMixin.java b/oldSrc/main/java/tools/redstone/redstonetools/mixin/macros/AddMacroButtonMixin.java deleted file mode 100644 index df394185..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/mixin/macros/AddMacroButtonMixin.java +++ /dev/null @@ -1,27 +0,0 @@ -package tools.redstone.redstonetools.mixin.macros; - -import net.minecraft.client.gui.screen.Screen; -import net.minecraft.client.gui.screen.option.ControlsOptionsScreen; -import net.minecraft.client.gui.screen.option.GameOptionsScreen; -import net.minecraft.client.gui.widget.ButtonWidget; -import net.minecraft.client.option.GameOptions; -import net.minecraft.text.Text; -import org.spongepowered.asm.mixin.Mixin; -import org.spongepowered.asm.mixin.injection.At; -import org.spongepowered.asm.mixin.injection.Inject; -import org.spongepowered.asm.mixin.injection.callback.CallbackInfo; -import tools.redstone.redstonetools.macros.gui.screen.MacroSelectScreen; - -@Mixin(ControlsOptionsScreen.class) -public class AddMacroButtonMixin extends GameOptionsScreen { - public AddMacroButtonMixin(Screen parent, GameOptions gameOptions, Text title) { - super(parent, gameOptions, title); - } - - @Inject(method = "init", at = @At("TAIL")) - public void init(CallbackInfo ci) { - this.addDrawableChild(new ButtonWidget(this.width / 2 + 5, this.height / 6 + 36, 150, 20, Text.of("Macros..."), (button) -> { - this.client.setScreen(new MacroSelectScreen(this,super.gameOptions,Text.of("Macros"))); - })); - } -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/mixin/macros/InitializeMacroManagerMixin.java b/oldSrc/main/java/tools/redstone/redstonetools/mixin/macros/InitializeMacroManagerMixin.java deleted file mode 100644 index ea9ae3ab..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/mixin/macros/InitializeMacroManagerMixin.java +++ /dev/null @@ -1,18 +0,0 @@ -package tools.redstone.redstonetools.mixin.macros; - -import net.minecraft.client.MinecraftClient; -import net.minecraft.client.RunArgs; -import org.spongepowered.asm.mixin.Mixin; -import org.spongepowered.asm.mixin.injection.At; -import org.spongepowered.asm.mixin.injection.Inject; -import org.spongepowered.asm.mixin.injection.callback.CallbackInfo; -import tools.redstone.redstonetools.RedstoneToolsClient; -import tools.redstone.redstonetools.macros.MacroManager; - -@Mixin(MinecraftClient.class) -public class InitializeMacroManagerMixin { - @Inject(method = "", at = @At("TAIL")) - public void registerMacros(RunArgs args, CallbackInfo ci){ - RedstoneToolsClient.INJECTOR.getInstance(MacroManager.class);// should register macro keybinds - } -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/mixin/macros/KeyBindingMixinImpl.java b/oldSrc/main/java/tools/redstone/redstonetools/mixin/macros/KeyBindingMixinImpl.java deleted file mode 100644 index 8ac71b89..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/mixin/macros/KeyBindingMixinImpl.java +++ /dev/null @@ -1,30 +0,0 @@ -package tools.redstone.redstonetools.mixin.macros; - -import net.minecraft.client.option.KeyBinding; -import net.minecraft.client.util.InputUtil; -import org.spongepowered.asm.mixin.Final; -import org.spongepowered.asm.mixin.Mixin; -import org.spongepowered.asm.mixin.Shadow; -import tools.redstone.redstonetools.macros.KeyBindingMixin; - -import java.util.Map; - -@Mixin(KeyBinding.class) -public class KeyBindingMixinImpl implements KeyBindingMixin { - - @Shadow @Final private static Map KEYS_BY_ID; - - @Shadow @Final private static Map KEY_TO_BINDINGS; - - @Override - public void removeKeybinding(KeyBinding keyBinding) { - KEYS_BY_ID.entrySet().removeIf(entry -> entry.getValue().equals(this)); - KEY_TO_BINDINGS.entrySet().removeIf(entry -> entry.getValue().equals(this)); - } - - @Override - public KeyBinding getBindingFromKey(InputUtil.Key key) { - return KEY_TO_BINDINGS.get(key); - } - -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/mixin/macros/autocomplete/ClientPlayerEntityMixinImpl.java b/oldSrc/main/java/tools/redstone/redstonetools/mixin/macros/autocomplete/ClientPlayerEntityMixinImpl.java deleted file mode 100644 index bab50f77..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/mixin/macros/autocomplete/ClientPlayerEntityMixinImpl.java +++ /dev/null @@ -1,22 +0,0 @@ -package tools.redstone.redstonetools.mixin.macros.autocomplete; - -import net.minecraft.client.network.ClientPlayNetworkHandler; -import net.minecraft.client.network.ClientPlayerEntity; -import org.spongepowered.asm.mixin.Final; -import org.spongepowered.asm.mixin.Mixin; -import org.spongepowered.asm.mixin.Mutable; -import org.spongepowered.asm.mixin.Shadow; -import tools.redstone.redstonetools.macros.ClientPlayerEntityMixin; - -@Mixin(ClientPlayerEntity.class) -public class ClientPlayerEntityMixinImpl implements ClientPlayerEntityMixin { - - @Mutable - @Shadow @Final public ClientPlayNetworkHandler networkHandler; - - - public void setNetworkHandler(ClientPlayNetworkHandler networkHandler) { - this.networkHandler = networkHandler; - } - -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/mixin/macros/autocomplete/CommandSuggestorMixin.java b/oldSrc/main/java/tools/redstone/redstonetools/mixin/macros/autocomplete/CommandSuggestorMixin.java deleted file mode 100644 index c88c08b4..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/mixin/macros/autocomplete/CommandSuggestorMixin.java +++ /dev/null @@ -1,71 +0,0 @@ -package tools.redstone.redstonetools.mixin.macros.autocomplete; - -import com.mojang.brigadier.suggestion.Suggestions; -import net.minecraft.client.gui.screen.CommandSuggestor; -import net.minecraft.client.gui.widget.TextFieldWidget; -import net.minecraft.client.util.math.MatrixStack; -import org.jetbrains.annotations.Nullable; -import org.spongepowered.asm.mixin.Final; -import org.spongepowered.asm.mixin.Mixin; -import org.spongepowered.asm.mixin.Shadow; -import org.spongepowered.asm.mixin.injection.At; -import org.spongepowered.asm.mixin.injection.Inject; -import org.spongepowered.asm.mixin.injection.ModifyVariable; -import org.spongepowered.asm.mixin.injection.callback.CallbackInfo; -import tools.redstone.redstonetools.macros.gui.MaroCommandSuggestor; - -import java.util.concurrent.CompletableFuture; - - -@Mixin(CommandSuggestor.class) -public class CommandSuggestorMixin{ - - @Shadow @Final - TextFieldWidget textField; - @Shadow private @Nullable CompletableFuture pendingSuggestions; - @Shadow @Final - int maxSuggestionSize; - - - @ModifyVariable(method = "showSuggestions", at = @At("STORE"), ordinal = 1) - public int suggestionWindXPos(int j){ - if (MaroCommandSuggestor.instance(this)) { - Suggestions suggestions = this.pendingSuggestions.join(); - return this.textField.getCharacterX(suggestions.getRange().getStart())+4; - } - return j; - } - - @ModifyVariable(method = "showSuggestions", at = @At("STORE"), ordinal = 2) - public int suggestionWindYPos(int k){ - if (MaroCommandSuggestor.instance(this)) { - Suggestions suggestions = this.pendingSuggestions.join(); - - int y = MaroCommandSuggestor.getY(this)-2; - return y +20 - Math.min(suggestions.getList().size(), this.maxSuggestionSize) * 12; - } - return k; - } - - - private int i = 0; - - @Inject(method = "render", at = @At("HEAD")) - public void render(MatrixStack matrices, int mouseX, int mouseY, CallbackInfo ci){ - i = 0; - } - - @ModifyVariable(method = "render", at = @At("STORE"), ordinal = 3) - public int messageYPos(int j) { - if (MaroCommandSuggestor.instance(this)) { - int y = MaroCommandSuggestor.getY(this); - i++; - return y - 12*(i-1)+43; - } - return j; - } - - - - -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/mixin/update/CheckUpdateMixin.java b/oldSrc/main/java/tools/redstone/redstonetools/mixin/update/CheckUpdateMixin.java deleted file mode 100644 index d2642ae4..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/mixin/update/CheckUpdateMixin.java +++ /dev/null @@ -1,91 +0,0 @@ -package tools.redstone.redstonetools.mixin.update; - -import com.google.gson.Gson; -import com.google.gson.JsonObject; -import net.minecraft.client.gui.screen.Screen; -import net.minecraft.client.gui.screen.TitleScreen; -import net.minecraft.client.gui.widget.PressableTextWidget; -import net.minecraft.text.*; -import net.minecraft.util.Util; -import org.spongepowered.asm.mixin.Mixin; -import org.spongepowered.asm.mixin.injection.At; -import org.spongepowered.asm.mixin.injection.Inject; -import org.spongepowered.asm.mixin.injection.callback.CallbackInfo; -import tools.redstone.redstonetools.RedstoneToolsClient; - -import java.net.URI; -import java.net.http.HttpClient; -import java.net.http.HttpRequest; -import java.net.http.HttpResponse; - -import static tools.redstone.redstonetools.RedstoneToolsClient.LOGGER; -import static tools.redstone.redstonetools.RedstoneToolsClient.MOD_VERSION; - -@Mixin(TitleScreen.class) -public class CheckUpdateMixin extends Screen { - private static boolean updateChecked = false; - - private static MutableText updateStatus = (MutableText) Text.of("Redstone Tools Version: " + MOD_VERSION + "(Bug found, report on Github)"); - private static URI uri; - public CheckUpdateMixin() { - super(Text.of("UpdateText(Bug found, report on Github)")); - } - - @Inject(method = "init", at = @At("TAIL")) - public void checkUpdate(CallbackInfo ci) { - if (updateChecked) - return; - - try { - LOGGER.info("Checking for updates..."); - - HttpClient client = HttpClient.newBuilder() - .build(); - HttpRequest request = HttpRequest.newBuilder() - .uri(URI.create("https://api.github.com/repositories/597142955/releases/latest")) - .GET() - .build(); - - HttpResponse response = client.send(request, HttpResponse.BodyHandlers.ofString()); - String responseBody = response.body(); - - if (response.statusCode() < 200 || 299 < response.statusCode()) { - LOGGER.error("Got status code " + response.statusCode() + " while trying to check for updates"); - return; - } - - Gson gson = new Gson(); - JsonObject release = gson.fromJson(responseBody, JsonObject.class); - uri = new URI(release.get("html_url").getAsString()); - String newVersion = release.get("tag_name").getAsString(); - - LOGGER.info("Found latest version: " + newVersion); - if (newVersion.contains("alpha") || newVersion.contains("beta")) { - LOGGER.info("Not showing an update popup for alpha or beta release, current version: " + MOD_VERSION + ", new version: " + newVersion); - return; - } - - Style underline = Style.EMPTY; - if (RedstoneToolsClient.MOD_VERSION.equals(newVersion)) { - LOGGER.info("Already up to date, current version: " + MOD_VERSION); - updateStatus = (MutableText) Text.of("Redstone Tools " + MOD_VERSION); - } else { - LOGGER.info("Found newer version, current version: " + RedstoneToolsClient.MOD_VERSION + ", new version: " + newVersion); - updateStatus = (MutableText) Text.of("Redstone Tools " + MOD_VERSION + " ("); - updateStatus.append(Text.of("Click to Update").getWithStyle(underline.withUnderline(true)).get(0)); - updateStatus.append(")"); - } - - } catch (Exception e) { - LOGGER.warn("Failed to check for RedstoneTools updates"); - e.printStackTrace(); - } finally { - updateChecked = true; - } - } - - @Inject(method="init", at = @At("HEAD")) - public void updateTextInjection(CallbackInfo ci){ - this.addDrawableChild(new PressableTextWidget(4,4, textRenderer.getWidth(updateStatus), textRenderer.fontHeight,updateStatus,button -> {Util.getOperatingSystem().open(uri);},textRenderer)); - } -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/utils/BlockColor.java b/oldSrc/main/java/tools/redstone/redstonetools/utils/BlockColor.java deleted file mode 100644 index 62dee464..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/utils/BlockColor.java +++ /dev/null @@ -1,50 +0,0 @@ -package tools.redstone.redstonetools.utils; - -import net.minecraft.block.Block; - -import java.util.Arrays; - -public enum BlockColor { - WHITE("white"), - ORANGE("orange"), - MAGENTA("magenta"), - LIGHT_BLUE("light_blue"), - YELLOW("yellow"), - LIME("lime"), - PINK("pink"), - GRAY("gray"), - LIGHT_GRAY("light_gray"), - CYAN("cyan"), - PURPLE("purple"), - BLUE("blue"), - BROWN("brown"), - GREEN("green"), - RED("red"), - BLACK("black"); - - private final String name; - - BlockColor(String name) { - this.name = name; - } - - public static BlockColor fromString(String name) { - return Arrays.stream(BlockColor.values()) - .filter(color -> color.name.equals(name)) - .findFirst() - .orElseThrow(); - } - - public static BlockColor fromBlock(Block block) { - var coloredBlock = ColoredBlock.fromBlock(block); - - return coloredBlock == null - ? BlockColor.WHITE - : coloredBlock.color; - } - - @Override - public String toString() { - return name; - } -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/utils/BlockInfo.java b/oldSrc/main/java/tools/redstone/redstonetools/utils/BlockInfo.java deleted file mode 100644 index 3c1997f6..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/utils/BlockInfo.java +++ /dev/null @@ -1,20 +0,0 @@ -package tools.redstone.redstonetools.utils; - -import net.minecraft.block.Block; -import net.minecraft.block.BlockState; -import net.minecraft.block.entity.BlockEntity; -import net.minecraft.util.math.BlockPos; - -public class BlockInfo { - public final Block block; - public final BlockPos pos; - public final BlockState state; - public final BlockEntity entity; - - public BlockInfo(Block block, BlockPos pos, BlockState state, BlockEntity entity) { - this.block = block; - this.pos = pos; - this.state = state; - this.entity = entity; - } -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/utils/BlockStateNbtUtil.java b/oldSrc/main/java/tools/redstone/redstonetools/utils/BlockStateNbtUtil.java deleted file mode 100644 index fcef4e28..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/utils/BlockStateNbtUtil.java +++ /dev/null @@ -1,181 +0,0 @@ -package tools.redstone.redstonetools.utils; - -import net.minecraft.block.Block; -import net.minecraft.block.BlockState; -import net.minecraft.item.BlockItem; -import net.minecraft.item.ItemStack; -import net.minecraft.nbt.NbtCompound; -import net.minecraft.nbt.NbtElement; -import net.minecraft.nbt.NbtList; -import net.minecraft.server.world.ServerWorld; -import net.minecraft.state.property.Property; -import net.minecraft.util.Identifier; -import net.minecraft.util.registry.Registry; - -import java.util.Objects; - -/** - * Utilities for block state (de)serialization into NBT tags. - */ -public final class BlockStateNbtUtil { - - private BlockStateNbtUtil() { - } - - /** - * Serializes the given block state into an NBT compound. - * - * @param state The state. - * @return The NBT tag or null if the block state is null. - */ - @SuppressWarnings({ "unchecked", "rawtypes" }) - public static NbtCompound toNBT(BlockState state) { - if (state == null) { - return null; - } - - NbtCompound root = new NbtCompound(); - root.putString("Id", Registry.BLOCK.getId(state.getBlock()).toString()); - - // serialize properties - if (!state.getProperties().isEmpty()) { - NbtList properties = new NbtList(); - for (Property property : state.getProperties()) { - // todo: maybe compress this? to optimize for memory - NbtCompound propertyTag = new NbtCompound(); - propertyTag.putString("K", property.getName()); - propertyTag.putString("V", property.name(state.get(property))); - properties.add(propertyTag); - } - - root.put("Properties", properties); - } - - return root; - } - - /** - * Attempts to deserialize a block state from the given NBT tag. - * - * @param compound The NBT tag. - * @return The block state or null if the tag is null/empty. - */ - @SuppressWarnings({ "unchecked", "rawtypes" }) - public static BlockState fromNBT(NbtCompound compound) { - if (compound == null || compound.isEmpty()) { - return null; - } - - // find the block - // we use new Identifier(...) here to allow it to throw exceptions - // instead of getting a cryptic NPE - Identifier identifier = new Identifier(compound.getString("Id")); - Block block = Registry.BLOCK.get(identifier); - - // deserialize properties - BlockState state = block.getDefaultState(); - NbtList propertiesTag = compound.getList("Properties", NbtElement.COMPOUND_TYPE); - if (propertiesTag != null) { - for (NbtElement element : propertiesTag) { - // this cast is checked, as we require the COMPOUND type - // when getting the list - NbtCompound propertyTag = (NbtCompound) element; - - Property property = block.getStateManager().getProperty(propertyTag.getString("K")); - if (property == null) - continue; - - state = state.with(property, (Comparable) property.parse(propertyTag.getString("V")).get()); - } - } - - return state; - } - - /** - * Attempts to deserialize a block state from the given NBT tag, - * or returns the given default if the tag is null/empty. - * - * @param compound The NBT tag. - * @param def The default. - * @return The block state or {@code def} if the tag is null/empty. - */ - public static BlockState fromNBT(NbtCompound compound, BlockState def) { - BlockState state = fromNBT(compound); - return state == null ? def : state; - } - - /** - * The key for the exact placement state in an items NBT. - */ - public static final String EXACT_STATE_KEY = "ExactBlockState"; - - /** - * Modifies the given item stack to add the exact block state - * placement data. The item stack should place the exact given - * block state when attempted. - * - * @param stack The input stack. - * @param state The block state to assign. - */ - public static void putPlacement(ItemStack stack, BlockState state) { - Objects.requireNonNull(stack); - stack.getOrCreateNbt().put(EXACT_STATE_KEY, toNBT(state)); - } - - /** - * Creates an item stack which should place the exact given - * block state when attempted. - * - * The created item stack has a count of 1 by default. - * - * @param state The placement state. - * @return The item stack. - */ - public static ItemStack createPlacementStack(BlockState state) { - ItemStack stack = new ItemStack(state.getBlock()); - putPlacement(stack, state); - return stack; - } - - /** - * Tries to get the exact placement state for the given - * item stack. If it is unable to determine the exact - * block state it will return null. - * - * @param stack The item stack. - * @return The block state or null. - */ - public static BlockState getPlacementStateOrNull(ItemStack stack) { - NbtCompound nbt = stack.getNbt(); - if (nbt == null || !nbt.contains(EXACT_STATE_KEY)) { - return null; - } - - return fromNBT(nbt.getCompound(EXACT_STATE_KEY)); - } - - /** - * Tries to get the exact placement state for the given - * item stack. If it is unable to determine the exact - * block state it will return the blocks default state - * if the item is a {@link BlockItem}, or null otherwise. - * - * @param stack The item stack. - * @return The block state or null. - */ - public static BlockState getPlacementState(ItemStack stack) { - NbtCompound nbt = stack.getNbt(); - if (nbt == null || !nbt.contains(EXACT_STATE_KEY)) { - if (stack.getItem() instanceof BlockItem blockItem) - return blockItem.getBlock().getDefaultState(); - return null; - } - - BlockState def = stack.getItem() instanceof BlockItem blockItem ? - blockItem.getBlock().getDefaultState() : - null; - return fromNBT(nbt.getCompound(EXACT_STATE_KEY), def); - } - -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/utils/ColoredBlock.java b/oldSrc/main/java/tools/redstone/redstonetools/utils/ColoredBlock.java deleted file mode 100644 index 266ab358..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/utils/ColoredBlock.java +++ /dev/null @@ -1,85 +0,0 @@ -package tools.redstone.redstonetools.utils; - -import net.minecraft.block.Block; -import net.minecraft.util.Identifier; -import net.minecraft.util.registry.Registry; -import org.jetbrains.annotations.NotNull; - -import java.util.HashMap; -import java.util.regex.Pattern; - -public class ColoredBlock { - private static final Pattern COLORED_BLOCK_REGEX = Pattern.compile( - "^minecraft:(\\w+?)_(wool|stained_glass|concrete_powder|concrete|glazed_terracotta|terracotta)$" - ); - - private static final HashMap COLORLESS_BLOCKS = new HashMap<>() {{ - put("minecraft:glass", new ColoredBlock("minecraft:%s_stained_glass", BlockColor.WHITE)); - put("minecraft:terracotta", new ColoredBlock("minecraft:%s_terracotta", BlockColor.WHITE)); - }}; - - private static final HashMap COLORED_BLOCK_CACHE = new HashMap<>() {{ - putAll(COLORLESS_BLOCKS); - }}; - - private final String blockIdFormat; - public final BlockColor color; - - public ColoredBlock(String blockIdFormat, BlockColor color) { - this.blockIdFormat = blockIdFormat; - this.color = color; - } - - public ColoredBlock withColor(BlockColor color) { - return new ColoredBlock(blockIdFormat, color); - } - - public static ColoredBlock fromBlockId(String blockId) { - if (COLORED_BLOCK_CACHE.containsKey(blockId)) { - return COLORED_BLOCK_CACHE.get(blockId); - } - - var matcher = COLORED_BLOCK_REGEX.matcher(blockId); - if (!matcher.matches()) { - return null; - } - - var color = matcher.group(1); - var blockType = matcher.group(2); - - var coloredBlock = new ColoredBlock("minecraft:%s_" + blockType, BlockColor.fromString(color)); - - COLORED_BLOCK_CACHE.put(blockId, coloredBlock); - - return coloredBlock; - } - - public String toBlockId() { - return String.format(blockIdFormat, color); - } - - public static ColoredBlock fromBlock(@NotNull Block block) { - var blockId = Registry.BLOCK.getId(block).toString(); - if (COLORED_BLOCK_CACHE.containsKey(blockId)) { - return COLORED_BLOCK_CACHE.get(blockId); - } - - var coloredBlock = fromBlockId(blockId); - - // The reason we only cache nulls here and not in the fromBlockId method is because the fromBlockId method would - // also cache invalid block ids (literally any string) which would make the cache massive. This method however - // only accepts actual blocks which means that the cache will never grow bigger than the amount of mc blocks. - COLORED_BLOCK_CACHE.put(blockId, coloredBlock); - - return coloredBlock; - } - - public Block toBlock() { - return Registry.BLOCK.get(Identifier.tryParse(toBlockId())); - } - - @Override - public String toString() { - return toBlockId(); - } -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/utils/ColoredBlockType.java b/oldSrc/main/java/tools/redstone/redstonetools/utils/ColoredBlockType.java deleted file mode 100644 index 701447c7..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/utils/ColoredBlockType.java +++ /dev/null @@ -1,39 +0,0 @@ -package tools.redstone.redstonetools.utils; - -import net.minecraft.block.Block; -import net.minecraft.util.Identifier; -import net.minecraft.util.registry.Registry; - -public enum ColoredBlockType { - // TODO: Merge some things with the ColoredBlock class so we dont have to repeat the formats and stuff - WOOL("wool", "minecraft:%s_wool"), - GLASS("glass", "minecraft:%s_stained_glass"), - CONCRETE("concrete", "minecraft:%s_concrete"), - TERRACOTTA("terracotta", "minecraft:%s_terracotta"); - - private final String displayName; - private final String blockIdFormat; - - ColoredBlockType(String displayName, String blockIdFormat) { - this.displayName = displayName; - this.blockIdFormat = blockIdFormat; - } - - @Override - public String toString() { - return displayName; - } - - public ColoredBlock withColor(BlockColor color) { - return ColoredBlock.fromBlock(toBlock()) - .withColor(color); - } - - public String toBlockId() { - return String.format(blockIdFormat, BlockColor.WHITE); - } - - public Block toBlock() { - return Registry.BLOCK.get(Identifier.tryParse(toBlockId())); - } -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/utils/CommandSourceUtils.java b/oldSrc/main/java/tools/redstone/redstonetools/utils/CommandSourceUtils.java deleted file mode 100644 index fd0b5c4a..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/utils/CommandSourceUtils.java +++ /dev/null @@ -1,12 +0,0 @@ -package tools.redstone.redstonetools.utils; - -import net.minecraft.server.command.ServerCommandSource; - -public class CommandSourceUtils { - private CommandSourceUtils() { - } - - public static void executeCommand(ServerCommandSource source, String command) { - source.getServer().getCommandManager().execute(source, command); - } -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/utils/CommandUtils.java b/oldSrc/main/java/tools/redstone/redstonetools/utils/CommandUtils.java deleted file mode 100644 index 5d42ef6f..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/utils/CommandUtils.java +++ /dev/null @@ -1,59 +0,0 @@ -package tools.redstone.redstonetools.utils; - -import com.mojang.brigadier.builder.LiteralArgumentBuilder; -import tools.redstone.redstonetools.features.arguments.Argument; -import com.mojang.brigadier.Command; -import com.mojang.brigadier.CommandDispatcher; -import com.mojang.brigadier.builder.ArgumentBuilder; -import net.minecraft.server.command.CommandManager; -import net.minecraft.server.command.ServerCommandSource; - -import java.util.ArrayList; -import java.util.Collections; -import java.util.List; - -public class CommandUtils { - private CommandUtils() { } - - public static LiteralArgumentBuilder build(String name, List> arguments, Command executor) { - var base = CommandManager.literal(name); - - if (arguments.stream().allMatch(Argument::isOptional)) { - base.executes(executor); - } - - if (!arguments.isEmpty()) { - base.then(createArgumentChain(arguments.stream() - .sorted((a, b) -> Boolean.compare(a.isOptional(), b.isOptional())) - .toList(), executor)); - } - - return base; - } - - public static void register(String name, List> arguments, Command executor, CommandDispatcher dispatcher, boolean dedicated) { - var base = build(name, arguments, executor); - dispatcher.register(base); - } - - private static ArgumentBuilder createArgumentChain(List> arguments, Command executor) { - var reversedArguments = new ArrayList<>(arguments); - Collections.reverse(reversedArguments); - - ArgumentBuilder argument = null; - for (var arg : reversedArguments) { - if (argument == null) { - argument = CommandManager.argument(arg.getName(), arg.getType()).executes(executor); - } else { - argument = CommandManager.argument(arg.getName(), arg.getType()).then(argument); - - // If the argument is optional or if this is the last required argument it should run the executor - if (arg.isOptional() || reversedArguments.get(reversedArguments.indexOf(arg) - 1).isOptional()) { - argument.executes(executor); - } - } - } - - return argument; - } -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/utils/DependencyLookup.java b/oldSrc/main/java/tools/redstone/redstonetools/utils/DependencyLookup.java deleted file mode 100644 index a316d3b8..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/utils/DependencyLookup.java +++ /dev/null @@ -1,25 +0,0 @@ -package tools.redstone.redstonetools.utils; - -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - -public class DependencyLookup { - private static final Logger LOGGER = - LoggerFactory.getLogger(DependencyLookup.class); - public static final boolean WORLDEDIT_PRESENT = - require("com.sk89q.worldedit.WorldEdit"); - - private static boolean require(String... classNames) { - for (String className : classNames) { - try { - Class.forName(className); - } catch (ClassNotFoundException e) { - return false; - } catch (Throwable t) { - LOGGER.warn("Unexpected error while checking for dependency {}", className, t); - return false; - } - } - return true; - } -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/utils/DirectionArgument.java b/oldSrc/main/java/tools/redstone/redstonetools/utils/DirectionArgument.java deleted file mode 100644 index 3bc66d24..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/utils/DirectionArgument.java +++ /dev/null @@ -1,24 +0,0 @@ -package tools.redstone.redstonetools.utils; - -public enum DirectionArgument { - ME, - FORWARD, - BACK, - NORTH, - EAST, - SOUTH, - WEST, - NORTHEAST, - NORTHWEST, - SOUTHEAST, - SOUTHWEST, - UP, - DOWN, - LEFT, - RIGHT; - - @Override - public String toString() { - return this.name().toLowerCase(); - } -} \ No newline at end of file diff --git a/oldSrc/main/java/tools/redstone/redstonetools/utils/DirectionUtils.java b/oldSrc/main/java/tools/redstone/redstonetools/utils/DirectionUtils.java deleted file mode 100644 index 2eb14654..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/utils/DirectionUtils.java +++ /dev/null @@ -1,115 +0,0 @@ -package tools.redstone.redstonetools.utils; - - -import com.sk89q.worldedit.math.BlockVector3; -import com.sk89q.worldedit.util.Direction; -import net.minecraft.command.CommandException; -import net.minecraft.text.Text; -import org.jetbrains.annotations.NotNull; - -public class DirectionUtils { - public static Direction firstOrdinal(Direction playerFacing) { - return switch (playerFacing) { - case EAST_NORTHEAST, NORTH_NORTHEAST -> Direction.NORTHEAST; - case NORTH_NORTHWEST, WEST_NORTHWEST -> Direction.NORTHWEST; - case EAST_SOUTHEAST, SOUTH_SOUTHEAST -> Direction.SOUTHEAST; - case SOUTH_SOUTHWEST, WEST_SOUTHWEST -> Direction.SOUTHWEST; - default -> playerFacing; - }; - } - - public static DirectionArgument relativeToAbsolute(DirectionArgument direction, Direction playerFacing) { - return switch (direction) { - case ME, FORWARD -> switch (firstOrdinal(playerFacing)) { - case UP -> DirectionArgument.UP; - case DOWN -> DirectionArgument.DOWN; - case NORTH -> DirectionArgument.NORTH; - case EAST -> DirectionArgument.EAST; - case SOUTH -> DirectionArgument.SOUTH; - case WEST -> DirectionArgument.WEST; - case NORTHEAST -> DirectionArgument.NORTHEAST; - case NORTHWEST -> DirectionArgument.NORTHWEST; - case SOUTHWEST -> DirectionArgument.SOUTHWEST; - case SOUTHEAST -> DirectionArgument.SOUTHEAST; - default -> null; - }; - case LEFT -> switch (firstOrdinal(playerFacing)) { - case UP, DOWN -> throw new CommandException(Text.of("Can't determine direction")); - case NORTH -> DirectionArgument.WEST; - case EAST -> DirectionArgument.NORTH; - case SOUTH -> DirectionArgument.EAST; - case WEST -> DirectionArgument.SOUTH; - case NORTHWEST -> DirectionArgument.SOUTHWEST; - case NORTHEAST -> DirectionArgument.NORTHWEST; - case SOUTHEAST -> DirectionArgument.NORTHEAST; - case SOUTHWEST -> DirectionArgument.SOUTHEAST; - default -> null; - }; - case RIGHT -> switch (firstOrdinal(playerFacing)) { - case UP, DOWN -> throw new CommandException(Text.of("Can't determine direction")); - case NORTH -> DirectionArgument.EAST; - case EAST -> DirectionArgument.SOUTH; - case SOUTH -> DirectionArgument.WEST; - case WEST -> DirectionArgument.NORTH; - case NORTHEAST -> DirectionArgument.SOUTHEAST; - case NORTHWEST -> DirectionArgument.NORTHEAST; - case SOUTHWEST -> DirectionArgument.NORTHWEST; - case SOUTHEAST -> DirectionArgument.SOUTHWEST; - default -> null; - }; - case BACK -> switch (firstOrdinal(playerFacing)) { - case UP -> DirectionArgument.DOWN; - case DOWN -> DirectionArgument.UP; - case NORTH -> DirectionArgument.SOUTH; - case EAST -> DirectionArgument.WEST; - case SOUTH -> DirectionArgument.NORTH; - case WEST -> DirectionArgument.EAST; - case NORTHWEST -> DirectionArgument.SOUTHEAST; - case NORTHEAST -> DirectionArgument.SOUTHWEST; - case SOUTHEAST -> DirectionArgument.NORTHWEST; - case SOUTHWEST -> DirectionArgument.NORTHEAST; - default -> null; - }; - default -> direction; - }; - } - - // big evil match direction function, there might be a better way to do this but i don't know how - @NotNull - public static Direction matchDirection(DirectionArgument direction, Direction playerFacing) throws CommandException { - var absoluteDirection = relativeToAbsolute(direction, playerFacing); - return switch (absoluteDirection) { - case NORTH -> Direction.NORTH; - case EAST -> Direction.EAST; - case SOUTH -> Direction.SOUTH; - case WEST -> Direction.WEST; - case NORTHEAST -> Direction.NORTHEAST; - case NORTHWEST -> Direction.NORTHWEST; - case SOUTHEAST -> Direction.SOUTHEAST; - case SOUTHWEST -> Direction.SOUTHWEST; - case UP -> Direction.UP; - case DOWN -> Direction.DOWN; - default -> { - assert false; - yield null; - } - }; - } - - // so many switch cases - public static BlockVector3 directionToBlock(Direction direction) { - return switch (direction) { - case NORTH -> BlockVector3.at(0, 0, -1); - case EAST -> BlockVector3.at(1, 0, 0); - case SOUTH -> BlockVector3.at(0, 0, 1); - case WEST -> BlockVector3.at(-1, 0, 0); - case UP -> BlockVector3.at(0, 1, 0); - case DOWN -> BlockVector3.at(0, -1, 0); - case NORTHEAST -> BlockVector3.at(1, 0, -1); - case NORTHWEST -> BlockVector3.at(-1, 0, -1); - case SOUTHEAST -> BlockVector3.at(1, 0, 1); - case SOUTHWEST -> BlockVector3.at(-1, 0, 1); - default -> null; - }; - } -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/utils/ItemUtils.java b/oldSrc/main/java/tools/redstone/redstonetools/utils/ItemUtils.java deleted file mode 100644 index 652b9081..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/utils/ItemUtils.java +++ /dev/null @@ -1,68 +0,0 @@ -package tools.redstone.redstonetools.utils; - -import net.minecraft.block.BlockState; -import net.minecraft.block.Blocks; -import net.minecraft.client.network.ClientPlayerEntity; -import net.minecraft.entity.player.PlayerEntity; -import net.minecraft.item.*; -import net.minecraft.util.registry.Registry; -import net.minecraft.world.BlockStateRaycastContext; -import net.minecraft.world.RaycastContext; - -import net.minecraft.item.ItemStack; -import net.minecraft.nbt.NbtCompound; -import net.minecraft.nbt.NbtList; -import net.minecraft.nbt.NbtString; - -public class ItemUtils { - - private ItemUtils(){ - } - - public static void addExtraNBTText(ItemStack itemStack, String text) { - NbtCompound displayNbt = itemStack.getSubNbt("display"); - NbtList loreList = new NbtList(); - - if (displayNbt == null) { - displayNbt = new NbtCompound(); - } else { - loreList = (NbtList) displayNbt.get("Lore"); - } - String lore = "\"(+"+text +")\""; - - if (loreList != null && !loreList.contains(NbtString.of(lore))) loreList.add(NbtString.of(lore)); - displayNbt.put("Lore", loreList); - itemStack.setSubNbt("display", displayNbt); - } - - public static boolean isEmpty(ItemStack itemStack) { - return itemStack == null || itemStack.getItem() == Items.AIR || itemStack.getCount() == 0; - } - - public static ItemStack getMainItem(PlayerEntity player) { - ItemStack stack = player.getMainHandStack(); - return isEmpty(stack) ? player.getOffHandStack() : stack; - } - - public static BlockState getPlacementState(ClientPlayerEntity player, ItemStack stack, float reach) { - Item type = stack.getItem(); - if (!(type instanceof BlockItem blockItem)) - return null; - return blockItem.getBlock().getPlacementState(new ItemPlacementContext( - player, - player.getActiveHand(), - stack, - RaycastUtils.rayCastFromEye(player, reach) - )); - } - - public static BlockState getUseState(ClientPlayerEntity player, ItemStack stack, float reach) { - if (stack == null || stack.getItem() == Items.AIR) - return null; - BlockState state = getPlacementState(player, stack, reach); - if (state == null) - state = Blocks.BEDROCK.getDefaultState(); - return state; - } - -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/utils/KeyBindingUtils.java b/oldSrc/main/java/tools/redstone/redstonetools/utils/KeyBindingUtils.java deleted file mode 100644 index 56e752eb..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/utils/KeyBindingUtils.java +++ /dev/null @@ -1,19 +0,0 @@ -package tools.redstone.redstonetools.utils; - -import net.minecraft.client.MinecraftClient; -import net.minecraft.client.option.KeyBinding; -import net.minecraft.client.util.InputUtil.Key; -import tools.redstone.redstonetools.macros.KeyBindingMixin; - -public class KeyBindingUtils { - - public static void removeKeyBinding(KeyBinding keyBinding) { - ((KeyBindingMixin)keyBinding).removeKeybinding(keyBinding); - } - - public static boolean isKeyAlreadyBound(Key key) { - KeyBinding foundKeyBinding = ( (KeyBindingMixin)MinecraftClient.getInstance().options.attackKey ).getBindingFromKey(key); - return foundKeyBinding != null; - } - -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/utils/NumberArg.java b/oldSrc/main/java/tools/redstone/redstonetools/utils/NumberArg.java deleted file mode 100644 index 130ddfeb..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/utils/NumberArg.java +++ /dev/null @@ -1,62 +0,0 @@ -package tools.redstone.redstonetools.utils; - -import org.jetbrains.annotations.NotNull; - -import java.math.BigInteger; - -public class NumberArg implements Comparable { - public final BigInteger numValue; - - public final Integer originalBase; - - public NumberArg(String num, int base){ - this.numValue = new BigInteger(num, base); - this.originalBase = base; - } - - public BigInteger getNum(){ - return this.numValue; - } - public Integer getBase(){ - return this.originalBase; - } - - /** - * Returns the number in a string format without a base prefix. - * @return Formatted String - */ - public String toString(){ - return this.toString(this.originalBase); - } - - /** - * Returns the number in a string format converted to another radix and without a base prefix. - * @param radix The Radix to turn use on the number - * @return Formatted String - */ - public String toString(int radix){ - return this.numValue.toString(radix); - } - - /** - * Returns the number in a string format with a base prefix. - * @return Formatted String - */ - public String toPrefixedString(){ - return toPrefixedString(this.originalBase); - } - - /** - * Returns the number in a string format converted to another radix and with a base prefix. - * @param radix The Radix to turn use on the number - * @return Formatted String - */ - public String toPrefixedString(int radix){ - return NumberBase.formatNumber(this.numValue.toString(radix),radix); - } - - @Override - public int compareTo(@NotNull NumberArg o) { - return this.numValue.compareTo(o.numValue); - } -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/utils/NumberBase.java b/oldSrc/main/java/tools/redstone/redstonetools/utils/NumberBase.java deleted file mode 100644 index bb8c57ff..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/utils/NumberBase.java +++ /dev/null @@ -1,101 +0,0 @@ -package tools.redstone.redstonetools.utils; - -import java.util.Arrays; -import java.util.Optional; - -public enum NumberBase { - BINARY(2,'b'), - OCTAL(8,'o'), - DECIMAL(10,'d'), - HEXADECIMAL(16,'x'); - - private final int base; - - private final char prefixChar; - - NumberBase(int base,char prefixChar) { - this.base = base; - this.prefixChar = prefixChar; - } - - public int toInt() { - return base; - } - - public char getPrefixChar() {return prefixChar;} - - public String getPrefix(){ - return "0" + prefixChar; - } - - @Override - public String toString() { - return super.toString().toLowerCase(); - } - - /** - * Returns an Optional for a NumberBase. Returns empty Optional if not found. - * @param string Search input for the NumberBase - * @return Optional for a NumberBase - */ - public static Optional fromString(String string) { - return Arrays.stream(values()) - .filter(b -> b.toString().equalsIgnoreCase(string)) - .findFirst(); - } - - /** - * Returns an Optional for a NumberBase. Returns empty Optional if not found. - * @param i Search input for the NumberBase - * @return Optional for a NumberBase - */ - public static Optional fromInt(int i) { - return Arrays.stream(values()) - .filter(b -> b.toInt() == i) - .findFirst(); - } - - /** - * Returns an Optional for a NumberBase. Returns empty Optional if not found. - * @param c Search input for the NumberBase - * @return Optional for a NumberBase - */ - public static Optional fromCharacter(char c) { - return Arrays.stream(values()) - .filter(b -> b.getPrefixChar() == c) - .findFirst(); - } - - /** - * Returns an Optional for a NumberBase. Returns empty Optional if not found. - * @param prefix Search input for the NumberBase - * @return Optional for a NumberBase - */ - public static Optional fromPrefix(String prefix) { - return Arrays.stream(values()) - .filter(b -> b.getPrefix().equalsIgnoreCase(prefix)) - .findFirst(); - } - - /** - * Returns a formatted String that includes the base and the number prefix together - * @param num Number to be formatted - * @param base Base to be paired with the number - * @return Formatted String - */ - public static String formatNumber(String num, int base) { - String negsign = ""; - if(Integer.parseInt(num,base) < 0){ - num = num.substring(1); - negsign = "-"; - } - num = num.toUpperCase(); - return negsign + switch (base) { - case 2 -> "0b" + num; - case 8 -> "0o" + num; - case 10 -> "0d" + num; - case 16 -> "0x" + num; - default -> num + "_" + base; - }; - } -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/utils/PositionUtils.java b/oldSrc/main/java/tools/redstone/redstonetools/utils/PositionUtils.java deleted file mode 100644 index 9f57a527..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/utils/PositionUtils.java +++ /dev/null @@ -1,13 +0,0 @@ -package tools.redstone.redstonetools.utils; - -import net.minecraft.util.math.BlockPos; -import net.minecraft.util.math.Vec3d; - -public class PositionUtils { - private PositionUtils() { - } - - public static Vec3d getBottomPositionOfBlock(BlockPos position) { - return Vec3d.ofCenter(position).subtract(0, 0.5, 0); - } -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/utils/RaycastUtils.java b/oldSrc/main/java/tools/redstone/redstonetools/utils/RaycastUtils.java deleted file mode 100644 index abaf26a2..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/utils/RaycastUtils.java +++ /dev/null @@ -1,28 +0,0 @@ -package tools.redstone.redstonetools.utils; - -import net.minecraft.entity.player.PlayerEntity; -import net.minecraft.util.hit.BlockHitResult; -import net.minecraft.world.RaycastContext; - -public class RaycastUtils { - private RaycastUtils() { - } - - public static BlockHitResult getBlockHitNeighbor(BlockHitResult hit) { - var sideOffset = hit.getSide().getUnitVector(); - - var newBlockPos = hit.getBlockPos().add(sideOffset.getX(), sideOffset.getY(), sideOffset.getZ()); - - return hit.withBlockPos(newBlockPos); - } - - public static BlockHitResult rayCastFromEye(PlayerEntity player, float reach) { - return player.getWorld().raycast(new RaycastContext( - player.getEyePos(), - player.getEyePos().add(player.getRotationVector().multiply(reach)), - RaycastContext.ShapeType.COLLIDER, - RaycastContext.FluidHandling.NONE, - player - )); - } -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/utils/RedstoneUtils.java b/oldSrc/main/java/tools/redstone/redstonetools/utils/RedstoneUtils.java deleted file mode 100644 index bc4dc74d..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/utils/RedstoneUtils.java +++ /dev/null @@ -1,12 +0,0 @@ -package tools.redstone.redstonetools.utils; - -public class RedstoneUtils { - private RedstoneUtils() { - - } - - public static int signalStrengthToNonStackableItemCount(int signalStrength, int containerSlots) { - // Formula copied from https://minecraft.fandom.com/wiki/Redstone_Comparator - return Math.max(signalStrength, (int) Math.ceil((containerSlots / 14.0) * (signalStrength - 1))); - } -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/utils/ReflectionUtils.java b/oldSrc/main/java/tools/redstone/redstonetools/utils/ReflectionUtils.java deleted file mode 100644 index e80d7ceb..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/utils/ReflectionUtils.java +++ /dev/null @@ -1,153 +0,0 @@ -package tools.redstone.redstonetools.utils; - -import org.apache.commons.io.IOUtils; -import org.apache.logging.log4j.LogManager; -import org.apache.logging.log4j.Logger; -import org.jetbrains.annotations.Nullable; -import rip.hippo.inject.DoctorModule; -import sun.misc.Unsafe; -import tools.redstone.redstonetools.features.AbstractFeature; -import tools.redstone.redstonetools.features.Feature; -import tools.redstone.redstonetools.features.arguments.Argument; - -import java.lang.invoke.MethodHandles; -import java.lang.reflect.Field; -import java.io.IOException; -import java.lang.reflect.Modifier; -import java.net.URL; -import java.util.*; -import java.util.stream.Collectors; - -public class ReflectionUtils { - private static final Logger LOGGER = LogManager.getLogger(); - private static DoctorModule[] modules; - private static Set features; - - private ReflectionUtils() { - throw new IllegalStateException("Utility class"); - } - - private static final MethodHandles.Lookup INTERNAL_LOOKUP; - private static final Unsafe unsafe; - - static { - try { - Field f = Unsafe.class.getDeclaredField("theUnsafe"); - f.setAccessible(true); - unsafe = (Unsafe) f.get(null); - } catch (Throwable t) { - t.printStackTrace(); - throw new ExceptionInInitializerError(t); - } - - try { - // get lookup - Field field = MethodHandles.Lookup.class.getDeclaredField("IMPL_LOOKUP"); - MethodHandles.publicLookup(); - INTERNAL_LOOKUP = (MethodHandles.Lookup) - unsafe.getObject( - unsafe.staticFieldBase(field), - unsafe.staticFieldOffset(field) - ); - } catch (Exception e) { - e.printStackTrace(); - throw new ExceptionInInitializerError(e); - } - } - - public static MethodHandles.Lookup getInternalLookup() { - return INTERNAL_LOOKUP; - } - - public static DoctorModule[] getModules() { - if (modules == null) { - try { - modules = serviceLoad(DoctorModule.class) - .toArray(DoctorModule[]::new); - } catch (IOException e) { - throw new RuntimeException("Failed to load modules", e); - } - } - return modules; - } - - public static Set getFeatures() { - if (features == null) { - try { - features = serviceLoad(AbstractFeature.class); - } catch (IOException e) { - throw new RuntimeException("Failed to load features", e); - } - } - return features; - } - - private static Set serviceLoad(Class clazz) throws IOException { - ClassLoader cl = ReflectionUtils.class.getClassLoader(); - Enumeration serviceFiles = cl.getResources("META-INF/services/" + clazz.getName()); - Set classNames = new HashSet<>(); - while (serviceFiles.hasMoreElements()) { - URL serviceFile = serviceFiles.nextElement(); - try (var reader = serviceFile.openStream()) { - classNames.addAll(IOUtils.readLines(reader, "UTF-8")); - } - } - return classNames.stream() - .filter(it -> !it.isEmpty() && !it.isBlank()) - .map(ReflectionUtils::loadClass) - .filter(Objects::nonNull) - .filter(clazz::isAssignableFrom) - .map(it -> { - try { - return it.getDeclaredConstructor().newInstance(); - } catch (ReflectiveOperationException e) { - throw new RuntimeException("Failed to instantiate " + it, e); - } - }) - .map(clazz::cast) - .collect(Collectors.toSet()); - } - - @SuppressWarnings("unchecked") - private static @Nullable Class loadClass(String className) { - try { - return (Class) Class.forName(className); - } catch (ClassNotFoundException e) { - throw new RuntimeException("Failed to load class " + className, e); - } catch (NoClassDefFoundError e) { - LOGGER.warn("Failed to load class {}, required {}", className, e.getMessage()); - } - return null; - } - - public static List> getArguments(Class featureClass) { - return Arrays.stream(featureClass.getFields()) - .filter(field -> Argument.class.isAssignableFrom(field.getType())) - .map(field -> { - if (!Modifier.isPublic(field.getModifiers()) - || !Modifier.isStatic(field.getModifiers()) - || !Modifier.isFinal(field.getModifiers())) { - throw new RuntimeException("Field " + field.getName() + " of feature " + featureClass.getName() + " is not public static final"); - } - - try { - var argument = (Argument) field.get(null); - - return argument.ensureNamed(field.getName()); - } catch (IllegalAccessException e) { - throw new RuntimeException("Failed to get value of field " + field.getName(), e); - } - }) - .collect(Collectors.toList()); - } - - public static Feature getFeatureInfo(Class featureClass) { - var feature = featureClass.getAnnotation(Feature.class); - - if (feature == null) { - throw new RuntimeException("No feature annotation found for feature " + featureClass.getName()); - } - - return feature; - } -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/utils/SignalBlock.java b/oldSrc/main/java/tools/redstone/redstonetools/utils/SignalBlock.java deleted file mode 100644 index aa83bc12..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/utils/SignalBlock.java +++ /dev/null @@ -1,48 +0,0 @@ -package tools.redstone.redstonetools.utils; - -import net.minecraft.block.Block; -import net.minecraft.block.Blocks; -import net.minecraft.item.ItemStack; - -public enum SignalBlock { - COMPOSTER(Blocks.COMPOSTER, SignalBlockSupplier.composter()), - BARREL(Blocks.BARREL, SignalBlockSupplier.container(27)), - CHEST(Blocks.CHEST, SignalBlockSupplier.container(27)), - SHULKER_BOX(Blocks.SHULKER_BOX, SignalBlockSupplier.container(27)), - DISPENSER(Blocks.DISPENSER, SignalBlockSupplier.container(9)), - DROPPER(Blocks.DROPPER, SignalBlockSupplier.container(9)), - HOPPER(Blocks.HOPPER, SignalBlockSupplier.container(5)), - BREWING_STAND(Blocks.BREWING_STAND, SignalBlockSupplier.container(5)), - FURNACE(Blocks.FURNACE, SignalBlockSupplier.container(3)), - SMOKER(Blocks.SMOKER, SignalBlockSupplier.container(3)), - BLAST_FURNACE(Blocks.BLAST_FURNACE, SignalBlockSupplier.container(3)), - COMMAND_BLOCK(Blocks.COMMAND_BLOCK, SignalBlockSupplier.commandBlock()), - AUTO(null, null); - - private final Block block; - private final SignalBlockSupplier supplier; - - SignalBlock(Block block, SignalBlockSupplier supplier) { - this.block = block; - this.supplier = supplier; - } - - public static SignalBlock getBestBlock(int signal) { - return signal < 1780 - ? BARREL - : COMMAND_BLOCK; - } - - public ItemStack getItemStack(int signal) { - if (block == null || supplier == null) - return getBestBlock(signal).getItemStack(signal); - - return supplier.getItemStack(block, signal); - } - - @Override - public String toString() { - return this.name().toLowerCase(); - } - -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/utils/SignalBlockSupplier.java b/oldSrc/main/java/tools/redstone/redstonetools/utils/SignalBlockSupplier.java deleted file mode 100644 index 0b0d2558..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/utils/SignalBlockSupplier.java +++ /dev/null @@ -1,131 +0,0 @@ -package tools.redstone.redstonetools.utils; - -import net.minecraft.block.Block; -import net.minecraft.enchantment.Enchantment; -import net.minecraft.item.Item; -import net.minecraft.item.ItemStack; -import net.minecraft.item.Items; -import net.minecraft.nbt.NbtCompound; -import net.minecraft.nbt.NbtList; -import net.minecraft.text.LiteralText; -import net.minecraft.text.MutableText; -import net.minecraft.util.Formatting; -import net.minecraft.util.math.MathHelper; -import net.minecraft.util.registry.Registry; - -@FunctionalInterface -public interface SignalBlockSupplier { - - NbtCompound createNbt(int signalStrength); - - default ItemStack getItemStack(Block block, int signalStrength) { - ItemStack item = new ItemStack(block); - setCompoundNbt(item, this.createNbt(signalStrength)); - setItemName(item, signalStrength); - return item; - } - - static SignalBlockSupplier container(int slots) { - return signalStrength -> { - if (isInvalidSignalStrength(signalStrength, 1779)) - throw new IllegalArgumentException("Container signal must be 0-1779"); - - NbtCompound tags = new NbtCompound(); - NbtList itemsTag = new NbtList(); - - Item item = getBestItem(signalStrength, slots); - int stackSize = getStackSize(signalStrength, item); - int itemsNeeded = Math.max(0, signalStrength == 1 - ? 1 - : (int) Math.ceil(slots * (signalStrength - 1) / 14D * item.getMaxCount())); - String itemId = Registry.ITEM.getId(item).toString(); - - // Check that the calculated number of items is correct. - // This is to prevent problems with items that have a maximum stack size of 1 but stackSize > 1. - // TODO: This can be improved by removing an item and adding stackable items up to the desired signal strength. - // Even with the improvement, this will still fail for inventories with no available slots. - if (calculateComparatorOutput(itemsNeeded, slots, item.getMaxCount()) != signalStrength) - throw new IllegalStateException("This signal strength cannot be achieved with the selected container"); - - for (int slot = 0, count = itemsNeeded; count > 0; slot++, count -= stackSize) { - NbtCompound slotTag = new NbtCompound(); - slotTag.putByte("Slot", (byte) slot); - slotTag.putString("id", itemId); - slotTag.putByte("Count", (byte) Math.min(stackSize, count)); - itemsTag.add(slotTag); - } - - NbtCompound tag = new NbtCompound(); - tag.put("Items", itemsTag); - tags.put("BlockEntityTag", tag); - - return tags; - }; - } - - static SignalBlockSupplier composter() { - return signalStrength -> { - if (signalStrength == 7 || isInvalidSignalStrength(signalStrength, 8)) - throw new IllegalArgumentException("Composter signal must be 0-6 or 8"); - - NbtCompound tags = new NbtCompound(); - NbtCompound tag = new NbtCompound(); - tag.putInt("level", signalStrength); - tags.put("BlockStateTag", tag); - return tags; - }; - } - - static SignalBlockSupplier commandBlock() { - return signalStrength -> { - if (isInvalidSignalStrength(signalStrength, Integer.MAX_VALUE)) - throw new IllegalArgumentException("Command block signal must be positive"); - - NbtCompound tags = new NbtCompound(); - NbtCompound tag = new NbtCompound(); - tag.putInt("SuccessCount", signalStrength); - tags.put("BlockEntityTag", tag); - return tags; - }; - } - - private static boolean isInvalidSignalStrength(int signalStrength, int maxSignalStrength) { - return signalStrength < 0 || signalStrength > maxSignalStrength; - } - - private static int calculateComparatorOutput(int items, int slots, int item$getMaxCount) { - float f = (float) items / (float) item$getMaxCount; - return MathHelper.floor((f /= (float)slots) * 14.0f) + (items > 0 ? 1 : 0); - } - - private static Item getBestItem(int signalStrength, int slots) { - if (signalStrength > 15) - return Items.WHITE_SHULKER_BOX; - else if (slots >= 15) - return Items.WOODEN_SHOVEL; - else - return Items.STICK; - } - - private static int getStackSize(int signalStrength, Item item) { - if (signalStrength > 897) - return 127; - else if (signalStrength > 15) - return 64; - else - return item.getMaxCount(); - } - - private static void setCompoundNbt(ItemStack item, NbtCompound nbt) { - nbt.putBoolean("HideFlags", true); - item.setNbt(nbt); - item.addEnchantment(Enchantment.byRawId(0), 0); - } - - private static void setItemName(ItemStack item, int signalStrength) { - MutableText text = new LiteralText(String.valueOf(signalStrength)); - text.setStyle(text.getStyle().withColor(Formatting.RED)); - item.setCustomName(text); - } - -} diff --git a/oldSrc/main/java/tools/redstone/redstonetools/utils/WorldEditUtils.java b/oldSrc/main/java/tools/redstone/redstonetools/utils/WorldEditUtils.java deleted file mode 100644 index 29e8ece7..00000000 --- a/oldSrc/main/java/tools/redstone/redstonetools/utils/WorldEditUtils.java +++ /dev/null @@ -1,69 +0,0 @@ -package tools.redstone.redstonetools.utils; - -import tools.redstone.redstonetools.features.feedback.Feedback; -import com.mojang.datafixers.util.Either; -import com.sk89q.worldedit.IncompleteRegionException; -import com.sk89q.worldedit.WorldEdit; -import com.sk89q.worldedit.fabric.FabricAdapter; -import com.sk89q.worldedit.math.BlockVector3; -import com.sk89q.worldedit.regions.CuboidRegion; -import com.sk89q.worldedit.regions.Region; -import net.minecraft.server.network.ServerPlayerEntity; - -import java.util.function.Consumer; - -public class WorldEditUtils { - /** - * Execute a function for each block in - * the provided region. - * - * Iterates the bounding box of the region - * and checks if the position is contained - * for each block. - * - * TODO: maybe make an async version of this somehow - * - * @param region The region. - * @param consumer The function to run. - */ - public static void forEachBlockInRegion(Region region, - Consumer consumer) { - if (!DependencyLookup.WORLDEDIT_PRESENT) { - throw new IllegalStateException("WorldEdit is not loaded."); - } - - CuboidRegion bb = region.getBoundingBox(); - BlockVector3 min = bb.getMinimumPoint(); - BlockVector3 max = bb.getMaximumPoint(); - for (int x = min.getBlockX(); x <= max.getBlockX(); x++) { - for (int y = min.getBlockY(); y <= max.getBlockY(); y++) { - for (int z = min.getBlockZ(); z <= max.getBlockZ(); z++) { - BlockVector3 vec = BlockVector3.at(x, y, z); - if (!region.contains(vec)) - continue; - consumer.accept(vec); - } - } - } - } - - public static Either getSelection(ServerPlayerEntity player) { - if (!DependencyLookup.WORLDEDIT_PRESENT) { - throw new IllegalStateException("WorldEdit is not loaded."); - } - - var actor = FabricAdapter.adaptPlayer(player); - - var localSession = WorldEdit.getInstance() - .getSessionManager() - .get(actor); - - var selectionWorld = localSession.getSelectionWorld(); - - try { - return Either.left(localSession.getSelection(selectionWorld)); - } catch (IncompleteRegionException ex) { - return Either.right(Feedback.invalidUsage("Please make a selection with WorldEdit first")); - } - } -} diff --git a/oldSrc/main/resources/assets/redstonetools/gui/cross.png b/oldSrc/main/resources/assets/redstonetools/gui/cross.png deleted file mode 100644 index 16d1e189d1f0afaeaaf177a1112af9506cbfbb4d..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 3361 zcmeAS@N?(olHy`uVBq!ia0vp^A|TAc1|)ksWqBDG7^PApJkvZqwHP>nVmv?rW(G#6 zIz}WmGn5UIV}r7pfNUv7RVUo-hI$(q0Qwb)1^R}11|TPb6;|bz z0KE%!Kouy;^uWq;3-m!=Nl65H2d2Kj%DE^tu_V7JBtJjLRtZ}KD=B~sv~sOT&M8ev zbt}rx4N5HcDoD3gGE~wBdR`yudk_;IjCKm6U^E0qLtr!nMnhmU1V%$(t!zn_2m*bw2}}XeT{g978Ppw_ZNY+iW1KZ-NZ?8%L7r}3&PshpXfXieEi(7 zOX!oz6Mc6x!p?jNh`NSt>AcjfMc`x)&RjCF|hMqBelw&oc;UHx3vIVCg!0Dp!$D*ylh diff --git a/oldSrc/main/resources/assets/redstonetools/gui/pencil.png b/oldSrc/main/resources/assets/redstonetools/gui/pencil.png deleted file mode 100644 index 3c5f841d3f7314b97d387a76f22e9c47b2058d4f..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 3328 zcmeAS@N?(olHy`uVBq!ia0vp^A|TAc1|)ksWqBDG7^PApJkvZqwHP>nVmv?rW(G#6 zIz}WmGn5UIV}r7pfNUv7RQL70(Y)*K0-*rv>oh>{3jAFJg2T)o7U{G?R9irfN_E(RO>ih{)C z?9>v4q}24xJX@vryZ0+8WTx0Eg`4^s_!c;)W@LI)6{QAO`Gq7`WhYyvDB0U7*i={n z4aiL`NmQuF&B-gas<2f8n`;GRgM{^!6u?SKvTc+T80u|c0O(gF7U&!58GxJ!R#=r= z0`xA_0ac(V(*rBZEzk#fB_$E)9hmw8E9aur#FG4?ko^1{TP17}tfT-k(8{$UIj1xw z)vYK$Hz={(t03K0$xulj=y`pp??Fs>Fxn}Mg3%Bd4S~@R7!85Z5Eu=Ckrx7phFEGI zusKo=Y-Z)J*8L1@qOI_BaSXBWKYGcLk42G#<-og?f35!IanIz;G_*F&nwj!@iION^ zOoiq3A0JHqvwCZ~o>$4to|PN0aZ1qM>K9@e8|N7R=9JWPoRegD)i*cc0K=pu9X{N*8o|0J>k`Jw?nA+DVa3>gdz{~1_p85oW+FsuiPGcd^ime~WO*h_-^g8zd7gOoS3 z8&HU|z$3Dlfr0NZ2s0kfUy;JVz?R|Z;uum9_x8@|E?sva*1)gc|NozCI;JMg#Wdv< z&+bWUGcD)&-PmHW|F7KCrV}DA%M^@QCu(;1IHqtZ1q;j^Y(i)3RZisF|G3UCv44d^ z^T%#3BPuigwK-P2|M*`1&vW)QJAhV*ii@Ufc(kaACoCpp!oe<}g%O2;j%?a`S|<{Y zy0S`=rRYmH`@_BL?`HzB!hnej(r&h5rz`=D-_&KB-Tju*oRC|mf{KHIVP`lLXekE#?*UE znEzp$`~Sa;ylm>WU>8X7_*H@3WFj%=3)qzz1{N>D?!J&va0%>_1qUB20sGCd`JgAn zw`|Rm<-iW7n?dm!9Kcw*{c*qihvf%v%YD4pJUK1^6o!6Pj-bG`c*zP1^#@DDML^L( zXGxFd5BHkOW%hi3Aj|&#$MS+p?p#GjJmob{2&&gEQE;F0Wnz;|A+-es9R==Hf4Juk zwsrn5R+5U0pB5bZ^X)5cAN;S)12U!A|L-D_%9%Y9E#KvURzq{o@_%k5Y5(I2%-sj8 z`N4L7m#cY|zmAmh?#ywB_G|x`MM)_se|9(hY1wX@Wb;3qlp^)nQH7tzB>9h|$e>y& eueJaGKlZst!mb>ZKhFfJqdZ;xT-G@yGywoi@u5xt diff --git a/oldSrc/main/resources/assets/redstonetools/lang/en_au.json b/oldSrc/main/resources/assets/redstonetools/lang/en_au.json deleted file mode 100644 index 214f29cd..00000000 --- a/oldSrc/main/resources/assets/redstonetools/lang/en_au.json +++ /dev/null @@ -1,6 +0,0 @@ -{ - "gamerule.doContainerDrops": "Do container drops", - "gamerule.doContainerDrops.description": "Controls resource drops from containers", - "gamerule.doBlockUpdatesAfterEdit": "Do block updates after edit", - "gamerule.doBlockUpdatesAfterEdit.description": "Force update blocks after editing them in WorldEdit" -} \ No newline at end of file diff --git a/oldSrc/main/resources/assets/redstonetools/lang/en_ca.json b/oldSrc/main/resources/assets/redstonetools/lang/en_ca.json deleted file mode 100644 index 214f29cd..00000000 --- a/oldSrc/main/resources/assets/redstonetools/lang/en_ca.json +++ /dev/null @@ -1,6 +0,0 @@ -{ - "gamerule.doContainerDrops": "Do container drops", - "gamerule.doContainerDrops.description": "Controls resource drops from containers", - "gamerule.doBlockUpdatesAfterEdit": "Do block updates after edit", - "gamerule.doBlockUpdatesAfterEdit.description": "Force update blocks after editing them in WorldEdit" -} \ No newline at end of file diff --git a/oldSrc/main/resources/assets/redstonetools/lang/en_gb.json b/oldSrc/main/resources/assets/redstonetools/lang/en_gb.json deleted file mode 100644 index 214f29cd..00000000 --- a/oldSrc/main/resources/assets/redstonetools/lang/en_gb.json +++ /dev/null @@ -1,6 +0,0 @@ -{ - "gamerule.doContainerDrops": "Do container drops", - "gamerule.doContainerDrops.description": "Controls resource drops from containers", - "gamerule.doBlockUpdatesAfterEdit": "Do block updates after edit", - "gamerule.doBlockUpdatesAfterEdit.description": "Force update blocks after editing them in WorldEdit" -} \ No newline at end of file diff --git a/oldSrc/main/resources/assets/redstonetools/lang/en_nz.json b/oldSrc/main/resources/assets/redstonetools/lang/en_nz.json deleted file mode 100644 index 214f29cd..00000000 --- a/oldSrc/main/resources/assets/redstonetools/lang/en_nz.json +++ /dev/null @@ -1,6 +0,0 @@ -{ - "gamerule.doContainerDrops": "Do container drops", - "gamerule.doContainerDrops.description": "Controls resource drops from containers", - "gamerule.doBlockUpdatesAfterEdit": "Do block updates after edit", - "gamerule.doBlockUpdatesAfterEdit.description": "Force update blocks after editing them in WorldEdit" -} \ No newline at end of file diff --git a/oldSrc/main/resources/assets/redstonetools/lang/en_us.json b/oldSrc/main/resources/assets/redstonetools/lang/en_us.json deleted file mode 100644 index 214f29cd..00000000 --- a/oldSrc/main/resources/assets/redstonetools/lang/en_us.json +++ /dev/null @@ -1,6 +0,0 @@ -{ - "gamerule.doContainerDrops": "Do container drops", - "gamerule.doContainerDrops.description": "Controls resource drops from containers", - "gamerule.doBlockUpdatesAfterEdit": "Do block updates after edit", - "gamerule.doBlockUpdatesAfterEdit.description": "Force update blocks after editing them in WorldEdit" -} \ No newline at end of file diff --git a/oldSrc/main/resources/fabric.mod.json b/oldSrc/main/resources/fabric.mod.json deleted file mode 100644 index 03be2633..00000000 --- a/oldSrc/main/resources/fabric.mod.json +++ /dev/null @@ -1,43 +0,0 @@ -{ - "schemaVersion": 1, - "id": "redstonetools", - "version": "${version}", - - "name": "Redstone Tools", - "description": "A Redstone Quality of Life mod. To improve efficiency and productivity.", - "contact": { - "sources": "https://github.com/RedstoneTools/redstone-tools", - "issues": "https://github.com/RedstoneTools/redstone-tools/issues", - "discord": "https://discord.gg/nXWmrAsJQ8" - }, - "custom": { - "modmenu": { - "links": { - "modmenu.discord": "https://discord.gg/nXWmrAsJQ8" - } - } - }, - - "license": "GPL-3.0", - "icon": "assets/redstonetools/icon.png", - - "environment": "*", - "entrypoints": { - "client": [ - "tools.redstone.redstonetools.RedstoneToolsClient" - ] - }, - "mixins": [ - "redstonetools.mixins.json" - ], - - "depends": { - "fabricloader": ">=0.15.0", - "fabric": "*", - "minecraft": "~1.20.4", - "java": ">=17" - }, - "recommends": { - "worldedit": "*" - } -} diff --git a/oldSrc/main/resources/redstonetools.mixins.json b/oldSrc/main/resources/redstonetools.mixins.json deleted file mode 100644 index e896d6b0..00000000 --- a/oldSrc/main/resources/redstonetools.mixins.json +++ /dev/null @@ -1,29 +0,0 @@ -{ - "required": true, - "minVersion": "0.8", - "package": "tools.redstone.redstonetools.mixin", - "compatibilityLevel": "JAVA_17", - "injectors": { - "defaultRequire": 1 - }, - "mixins": [ - "blocks.RedstoneHitboxMixin", - "features.AirPlaceServerMixin", - "features.AutoDustMixin", - "features.CopyStateMixin", - "features.ItemBindMixin$ItemStackMixin", - "gamerules.DoContainerDropsMixin", - ], - "client": [ - "accessors.MinecraftClientAccessor", - "accessors.WorldRendererAccessor", - "features.AirPlaceClientMixin", - "features.ItemBindMixin$PlayerMixin", - "macros.AddMacroButtonMixin", - "macros.InitializeMacroManagerMixin", - "macros.KeyBindingMixinImpl", - "macros.autocomplete.ClientPlayerEntityMixinImpl", - "macros.autocomplete.CommandSuggestorMixin", - "update.CheckUpdateMixin" - ] -} From 9c965509fbaea451c53c75523a90ad9376fec98e Mon Sep 17 00:00:00 2001 From: Quie_ Date: Sat, 30 Dec 2023 21:32:13 -0500 Subject: [PATCH 03/29] AbstractFeature and a few related classes were updated based on Fabric's 1.19 documentation. https://fabricmc.net/2022/06/07/119.html --- .../redstone/redstonetools/features/AbstractFeature.java | 6 ++++-- .../redstonetools/features/commands/CommandFeature.java | 9 +++++---- .../features/toggleable/ToggleableFeature.java | 4 +++- .../tools/redstone/redstonetools/utils/CommandUtils.java | 6 ++++-- 4 files changed, 16 insertions(+), 9 deletions(-) diff --git a/src/main/java/tools/redstone/redstonetools/features/AbstractFeature.java b/src/main/java/tools/redstone/redstonetools/features/AbstractFeature.java index e8e6f1af..68e56df3 100644 --- a/src/main/java/tools/redstone/redstonetools/features/AbstractFeature.java +++ b/src/main/java/tools/redstone/redstonetools/features/AbstractFeature.java @@ -1,7 +1,9 @@ package tools.redstone.redstonetools.features; import com.mojang.brigadier.CommandDispatcher; -import net.fabricmc.fabric.api.command.v1.CommandRegistrationCallback; +import net.fabricmc.fabric.api.command.v2.CommandRegistrationCallback; +import net.minecraft.command.CommandRegistryAccess; +import net.minecraft.server.command.CommandManager.RegistrationEnvironment; import net.minecraft.server.command.ServerCommandSource; public abstract class AbstractFeature { @@ -55,6 +57,6 @@ public void register() { CommandRegistrationCallback.EVENT.register(this::registerCommands); } - protected abstract void registerCommands(CommandDispatcher dispatcher, boolean dedicated); + protected abstract void registerCommands(CommandDispatcher dispatcher, CommandRegistryAccess registryAccess, RegistrationEnvironment environment); } diff --git a/src/main/java/tools/redstone/redstonetools/features/commands/CommandFeature.java b/src/main/java/tools/redstone/redstonetools/features/commands/CommandFeature.java index af19cb21..1358a33e 100644 --- a/src/main/java/tools/redstone/redstonetools/features/commands/CommandFeature.java +++ b/src/main/java/tools/redstone/redstonetools/features/commands/CommandFeature.java @@ -4,6 +4,8 @@ import net.fabricmc.fabric.api.client.keybinding.v1.KeyBindingHelper; import net.minecraft.client.option.KeyBinding; import net.minecraft.client.util.InputUtil; +import net.minecraft.command.CommandRegistryAccess; +import net.minecraft.server.command.CommandManager; import tools.redstone.redstonetools.features.AbstractFeature; import tools.redstone.redstonetools.features.Feature; import tools.redstone.redstonetools.features.arguments.Argument; @@ -20,8 +22,6 @@ import static tools.redstone.redstonetools.RedstoneToolsClient.INJECTOR; -import Z; - public abstract class CommandFeature extends AbstractFeature { private static final List keyBindings = new ArrayList<>(); @@ -55,7 +55,7 @@ public void register() { } @Override - protected void registerCommands(CommandDispatcher dispatcher, boolean dedicated) { + protected void registerCommands(CommandDispatcher dispatcher, CommandRegistryAccess registryAccess, CommandManager.RegistrationEnvironment environment) { var info = ReflectionUtils.getFeatureInfo(getClass()); var arguments = ReflectionUtils.getArguments(getClass()); @@ -75,7 +75,8 @@ protected void registerCommands(CommandDispatcher dispatche return feedback.getType().getCode(); }, dispatcher, - dedicated); + registryAccess, + environment); } protected abstract Feedback execute(ServerCommandSource source) throws CommandSyntaxException; diff --git a/src/main/java/tools/redstone/redstonetools/features/toggleable/ToggleableFeature.java b/src/main/java/tools/redstone/redstonetools/features/toggleable/ToggleableFeature.java index 4d104471..0cd189a5 100644 --- a/src/main/java/tools/redstone/redstonetools/features/toggleable/ToggleableFeature.java +++ b/src/main/java/tools/redstone/redstonetools/features/toggleable/ToggleableFeature.java @@ -4,6 +4,8 @@ import net.fabricmc.fabric.api.client.keybinding.v1.KeyBindingHelper; import net.minecraft.client.option.KeyBinding; import net.minecraft.client.util.InputUtil; +import net.minecraft.command.CommandRegistryAccess; +import net.minecraft.server.command.CommandManager.RegistrationEnvironment; import tools.redstone.redstonetools.features.AbstractFeature; import tools.redstone.redstonetools.features.Feature; import tools.redstone.redstonetools.features.feedback.Feedback; @@ -99,7 +101,7 @@ public void register() { @SuppressWarnings({ "rawtypes", "unchecked" }) @Override - protected void registerCommands(CommandDispatcher dispatcher, boolean dedicated) { + protected void registerCommands(CommandDispatcher dispatcher, CommandRegistryAccess registryAccess, RegistrationEnvironment environment) { var baseCommand = literal(getCommand()) .executes(this::toggle); diff --git a/src/main/java/tools/redstone/redstonetools/utils/CommandUtils.java b/src/main/java/tools/redstone/redstonetools/utils/CommandUtils.java index 5d42ef6f..7b0c0106 100644 --- a/src/main/java/tools/redstone/redstonetools/utils/CommandUtils.java +++ b/src/main/java/tools/redstone/redstonetools/utils/CommandUtils.java @@ -1,11 +1,13 @@ package tools.redstone.redstonetools.utils; import com.mojang.brigadier.builder.LiteralArgumentBuilder; +import net.minecraft.command.CommandRegistryAccess; +import net.minecraft.server.command.CommandManager; import tools.redstone.redstonetools.features.arguments.Argument; import com.mojang.brigadier.Command; import com.mojang.brigadier.CommandDispatcher; import com.mojang.brigadier.builder.ArgumentBuilder; -import net.minecraft.server.command.CommandManager; +import net.minecraft.server.command.CommandManager.RegistrationEnvironment; import net.minecraft.server.command.ServerCommandSource; import java.util.ArrayList; @@ -31,7 +33,7 @@ public static LiteralArgumentBuilder build(String name, Lis return base; } - public static void register(String name, List> arguments, Command executor, CommandDispatcher dispatcher, boolean dedicated) { + public static void register(String name, List> arguments, Command executor, CommandDispatcher dispatcher, CommandRegistryAccess registryAccess, RegistrationEnvironment environment) { var base = build(name, arguments, executor); dispatcher.register(base); } From dc84b76ec130b66929a8ff173bf8a02c6fed28d1 Mon Sep 17 00:00:00 2001 From: Quie_ Date: Sat, 30 Dec 2023 22:13:20 -0500 Subject: [PATCH 04/29] Mistakenly deleted the resources folder with oldSrc, added back. --- src/main/resources/assets/gui/cross.png | Bin 0 -> 3361 bytes src/main/resources/assets/gui/pencil.png | Bin 0 -> 3328 bytes src/main/resources/assets/icon.png | Bin 0 -> 1799 bytes src/main/resources/assets/lang/en_au.json | 6 +++ src/main/resources/assets/lang/en_ca.json | 6 +++ src/main/resources/assets/lang/en_gb.json | 6 +++ src/main/resources/assets/lang/en_nz.json | 6 +++ src/main/resources/assets/lang/en_us.json | 6 +++ src/main/resources/fabric.mod.json | 43 +++++++++++++++++++ src/main/resources/redstonetools.mixins.json | 29 +++++++++++++ 10 files changed, 102 insertions(+) create mode 100644 src/main/resources/assets/gui/cross.png create mode 100644 src/main/resources/assets/gui/pencil.png create mode 100644 src/main/resources/assets/icon.png create mode 100644 src/main/resources/assets/lang/en_au.json create mode 100644 src/main/resources/assets/lang/en_ca.json create mode 100644 src/main/resources/assets/lang/en_gb.json create mode 100644 src/main/resources/assets/lang/en_nz.json create mode 100644 src/main/resources/assets/lang/en_us.json create mode 100644 src/main/resources/fabric.mod.json create mode 100644 src/main/resources/redstonetools.mixins.json diff --git a/src/main/resources/assets/gui/cross.png b/src/main/resources/assets/gui/cross.png new file mode 100644 index 0000000000000000000000000000000000000000..16d1e189d1f0afaeaaf177a1112af9506cbfbb4d GIT binary patch literal 3361 zcmeAS@N?(olHy`uVBq!ia0vp^A|TAc1|)ksWqBDG7^PApJkvZqwHP>nVmv?rW(G#6 zIz}WmGn5UIV}r7pfNUv7RVUo-hI$(q0Qwb)1^R}11|TPb6;|bz z0KE%!Kouy;^uWq;3-m!=Nl65H2d2Kj%DE^tu_V7JBtJjLRtZ}KD=B~sv~sOT&M8ev zbt}rx4N5HcDoD3gGE~wBdR`yudk_;IjCKm6U^E0qLtr!nMnhmU1V%$(t!zn_2m*bw2}}XeT{g978Ppw_ZNY+iW1KZ-NZ?8%L7r}3&PshpXfXieEi(7 zOX!oz6Mc6x!p?jNh`NSt>AcjfMc`x)&RjCF|hMqBelw&oc;UHx3vIVCg!0Dp!$D*ylh literal 0 HcmV?d00001 diff --git a/src/main/resources/assets/gui/pencil.png b/src/main/resources/assets/gui/pencil.png new file mode 100644 index 0000000000000000000000000000000000000000..3c5f841d3f7314b97d387a76f22e9c47b2058d4f GIT binary patch literal 3328 zcmeAS@N?(olHy`uVBq!ia0vp^A|TAc1|)ksWqBDG7^PApJkvZqwHP>nVmv?rW(G#6 zIz}WmGn5UIV}r7pfNUv7RQL70(Y)*K0-*rv>oh>{3jAFJg2T)o7U{G?R9irfN_E(RO>ih{)C z?9>v4q}24xJX@vryZ0+8WTx0Eg`4^s_!c;)W@LI)6{QAO`Gq7`WhYyvDB0U7*i={n z4aiL`NmQuF&B-gas<2f8n`;GRgM{^!6u?SKvTc+T80u|c0O(gF7U&!58GxJ!R#=r= z0`xA_0ac(V(*rBZEzk#fB_$E)9hmw8E9aur#FG4?ko^1{TP17}tfT-k(8{$UIj1xw z)vYK$Hz={(t03K0$xulj=y`pp??Fs>Fxn}Mg3%Bd4S~@R7!85Z5Eu=Ckrx7phFEGI zusKo=Y-Z)J*8L1@qOI_BaSXBWKYGcLk42G#<-og?f35!IanIz;G_*F&nwj!@iION^ zOoiq3A0JHqvwCZ~o>$4to|PN0aZ1qM>K9@e8|N7R=9JWPoRegD)i*cc0K=pu9X{N*8o|0J>k`Jw?nA+DVa3>gdz{~1_p85oW+FsuiPGcd^ime~WO*h_-^g8zd7gOoS3 z8&HU|z$3Dlfr0NZ2s0kfUy;JVz?R|Z;uum9_x8@|E?sva*1)gc|NozCI;JMg#Wdv< z&+bWUGcD)&-PmHW|F7KCrV}DA%M^@QCu(;1IHqtZ1q;j^Y(i)3RZisF|G3UCv44d^ z^T%#3BPuigwK-P2|M*`1&vW)QJAhV*ii@Ufc(kaACoCpp!oe<}g%O2;j%?a`S|<{Y zy0S`=rRYmH`@_BL?`HzB!hnej(r&h5rz`=D-_&KB-Tju*oRC|mf{KHIVP`lLXekE#?*UE znEzp$`~Sa;ylm>WU>8X7_*H@3WFj%=3)qzz1{N>D?!J&va0%>_1qUB20sGCd`JgAn zw`|Rm<-iW7n?dm!9Kcw*{c*qihvf%v%YD4pJUK1^6o!6Pj-bG`c*zP1^#@DDML^L( zXGxFd5BHkOW%hi3Aj|&#$MS+p?p#GjJmob{2&&gEQE;F0Wnz;|A+-es9R==Hf4Juk zwsrn5R+5U0pB5bZ^X)5cAN;S)12U!A|L-D_%9%Y9E#KvURzq{o@_%k5Y5(I2%-sj8 z`N4L7m#cY|zmAmh?#ywB_G|x`MM)_se|9(hY1wX@Wb;3qlp^)nQH7tzB>9h|$e>y& eueJaGKlZst!mb>ZKhFfJqdZ;xT-G@yGywoi@u5xt literal 0 HcmV?d00001 diff --git a/src/main/resources/assets/lang/en_au.json b/src/main/resources/assets/lang/en_au.json new file mode 100644 index 00000000..214f29cd --- /dev/null +++ b/src/main/resources/assets/lang/en_au.json @@ -0,0 +1,6 @@ +{ + "gamerule.doContainerDrops": "Do container drops", + "gamerule.doContainerDrops.description": "Controls resource drops from containers", + "gamerule.doBlockUpdatesAfterEdit": "Do block updates after edit", + "gamerule.doBlockUpdatesAfterEdit.description": "Force update blocks after editing them in WorldEdit" +} \ No newline at end of file diff --git a/src/main/resources/assets/lang/en_ca.json b/src/main/resources/assets/lang/en_ca.json new file mode 100644 index 00000000..214f29cd --- /dev/null +++ b/src/main/resources/assets/lang/en_ca.json @@ -0,0 +1,6 @@ +{ + "gamerule.doContainerDrops": "Do container drops", + "gamerule.doContainerDrops.description": "Controls resource drops from containers", + "gamerule.doBlockUpdatesAfterEdit": "Do block updates after edit", + "gamerule.doBlockUpdatesAfterEdit.description": "Force update blocks after editing them in WorldEdit" +} \ No newline at end of file diff --git a/src/main/resources/assets/lang/en_gb.json b/src/main/resources/assets/lang/en_gb.json new file mode 100644 index 00000000..214f29cd --- /dev/null +++ b/src/main/resources/assets/lang/en_gb.json @@ -0,0 +1,6 @@ +{ + "gamerule.doContainerDrops": "Do container drops", + "gamerule.doContainerDrops.description": "Controls resource drops from containers", + "gamerule.doBlockUpdatesAfterEdit": "Do block updates after edit", + "gamerule.doBlockUpdatesAfterEdit.description": "Force update blocks after editing them in WorldEdit" +} \ No newline at end of file diff --git a/src/main/resources/assets/lang/en_nz.json b/src/main/resources/assets/lang/en_nz.json new file mode 100644 index 00000000..214f29cd --- /dev/null +++ b/src/main/resources/assets/lang/en_nz.json @@ -0,0 +1,6 @@ +{ + "gamerule.doContainerDrops": "Do container drops", + "gamerule.doContainerDrops.description": "Controls resource drops from containers", + "gamerule.doBlockUpdatesAfterEdit": "Do block updates after edit", + "gamerule.doBlockUpdatesAfterEdit.description": "Force update blocks after editing them in WorldEdit" +} \ No newline at end of file diff --git a/src/main/resources/assets/lang/en_us.json b/src/main/resources/assets/lang/en_us.json new file mode 100644 index 00000000..214f29cd --- /dev/null +++ b/src/main/resources/assets/lang/en_us.json @@ -0,0 +1,6 @@ +{ + "gamerule.doContainerDrops": "Do container drops", + "gamerule.doContainerDrops.description": "Controls resource drops from containers", + "gamerule.doBlockUpdatesAfterEdit": "Do block updates after edit", + "gamerule.doBlockUpdatesAfterEdit.description": "Force update blocks after editing them in WorldEdit" +} \ No newline at end of file diff --git a/src/main/resources/fabric.mod.json b/src/main/resources/fabric.mod.json new file mode 100644 index 00000000..626947a0 --- /dev/null +++ b/src/main/resources/fabric.mod.json @@ -0,0 +1,43 @@ +{ + "schemaVersion": 1, + "id": "redstonetools", + "version": "${version}", + + "name": "Redstone Tools", + "description": "A Redstone Quality of Life mod. To improve efficiency and productivity.", + "contact": { + "sources": "https://github.com/RedstoneTools/redstone-tools", + "issues": "https://github.com/RedstoneTools/redstone-tools/issues", + "discord": "https://discord.gg/nXWmrAsJQ8" + }, + "custom": { + "modmenu": { + "links": { + "modmenu.discord": "https://discord.gg/nXWmrAsJQ8" + } + } + }, + + "license": "GPL-3.0", + "icon": "assets/redstonetools/icon.png", + + "environment": "*", + "entrypoints": { + "client": [ + "tools.redstone.redstonetools.RedstoneToolsClient" + ] + }, + "mixins": [ + "redstonetools.mixins.json" + ], + + "depends": { + "fabricloader": ">=0.15.0", + "fabric": "*", + "minecraft": "~1.20.4", + "java": ">=17" + }, + "recommends": { + "worldedit": "*" + } +} \ No newline at end of file diff --git a/src/main/resources/redstonetools.mixins.json b/src/main/resources/redstonetools.mixins.json new file mode 100644 index 00000000..1dc47957 --- /dev/null +++ b/src/main/resources/redstonetools.mixins.json @@ -0,0 +1,29 @@ +{ + "required": true, + "minVersion": "0.8", + "package": "tools.redstone.redstonetools.mixin", + "compatibilityLevel": "JAVA_17", + "injectors": { + "defaultRequire": 1 + }, + "mixins": [ + "blocks.RedstoneHitboxMixin", + "features.AirPlaceServerMixin", + "features.AutoDustMixin", + "features.CopyStateMixin", + "features.ItemBindMixin$ItemStackMixin", + "gamerules.DoContainerDropsMixin" + ], + "client": [ + "accessors.MinecraftClientAccessor", + "accessors.WorldRendererAccessor", + "features.AirPlaceClientMixin", + "features.ItemBindMixin$PlayerMixin", + "macros.AddMacroButtonMixin", + "macros.InitializeMacroManagerMixin", + "macros.KeyBindingMixinImpl", + "macros.autocomplete.ClientPlayerEntityMixinImpl", + "macros.autocomplete.CommandSuggestorMixin", + "update.CheckUpdateMixin" + ] +} \ No newline at end of file From af6f921930c9aafe7888ae399529294a60218cf0 Mon Sep 17 00:00:00 2001 From: rugmj Date: Sun, 31 Dec 2023 13:28:54 +0000 Subject: [PATCH 05/29] adds registry access to CommandFeature --- .../features/commands/CommandFeature.java | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/src/main/java/tools/redstone/redstonetools/features/commands/CommandFeature.java b/src/main/java/tools/redstone/redstonetools/features/commands/CommandFeature.java index 1358a33e..b4ee8347 100644 --- a/src/main/java/tools/redstone/redstonetools/features/commands/CommandFeature.java +++ b/src/main/java/tools/redstone/redstonetools/features/commands/CommandFeature.java @@ -5,6 +5,7 @@ import net.minecraft.client.option.KeyBinding; import net.minecraft.client.util.InputUtil; import net.minecraft.command.CommandRegistryAccess; +import net.minecraft.registry.BuiltinRegistries; import net.minecraft.server.command.CommandManager; import tools.redstone.redstonetools.features.AbstractFeature; import tools.redstone.redstonetools.features.Feature; @@ -22,9 +23,10 @@ import static tools.redstone.redstonetools.RedstoneToolsClient.INJECTOR; - public abstract class CommandFeature extends AbstractFeature { private static final List keyBindings = new ArrayList<>(); + protected static final CommandRegistryAccess REGISTRY_ACCESS = CommandManager + .createRegistryAccess(BuiltinRegistries.createWrapperLookup()); @Override public void register() { @@ -41,8 +43,7 @@ public void register() { info.name(), InputUtil.Type.KEYSYM, -1, - "Redstone Tools" - )); + "Redstone Tools")); keyBindings.add(keyBinding); @@ -55,7 +56,8 @@ public void register() { } @Override - protected void registerCommands(CommandDispatcher dispatcher, CommandRegistryAccess registryAccess, CommandManager.RegistrationEnvironment environment) { + protected void registerCommands(CommandDispatcher dispatcher, + CommandRegistryAccess registryAccess, CommandManager.RegistrationEnvironment environment) { var info = ReflectionUtils.getFeatureInfo(getClass()); var arguments = ReflectionUtils.getArguments(getClass()); From f2401b4d8a7643bbddbed400422074105970b40b Mon Sep 17 00:00:00 2001 From: rugmj Date: Sun, 31 Dec 2023 13:30:06 +0000 Subject: [PATCH 06/29] fixes block state argument serialiser --- .../BlockStateArgumentSerializer.java | 21 ++++++++++--------- 1 file changed, 11 insertions(+), 10 deletions(-) diff --git a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/BlockStateArgumentSerializer.java b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/BlockStateArgumentSerializer.java index a211c650..b16446ce 100644 --- a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/BlockStateArgumentSerializer.java +++ b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/BlockStateArgumentSerializer.java @@ -1,24 +1,25 @@ package tools.redstone.redstonetools.features.arguments.serializers; -import Z; import com.mojang.brigadier.StringReader; import com.mojang.brigadier.exceptions.CommandSyntaxException; -import net.minecraft.block.Block; -import net.minecraft.block.BlockState; +import net.minecraft.command.CommandRegistryAccess; import net.minecraft.command.argument.BlockStateArgument; import net.minecraft.command.argument.BlockStateArgumentType; -import net.minecraft.registry.Registry; -import net.minecraft.state.property.Property; +import net.minecraft.registry.Registries; public class BlockStateArgumentSerializer extends BrigadierSerializer { - private static final BlockStateArgumentSerializer INSTANCE = new BlockStateArgumentSerializer(); + private static BlockStateArgumentSerializer INSTANCE; - private BlockStateArgumentSerializer() { - super(BlockStateArgument.class, BlockStateArgumentType.blockState()); + private BlockStateArgumentSerializer(CommandRegistryAccess registryAccess) { + super(BlockStateArgument.class, BlockStateArgumentType.blockState(registryAccess)); } - public static BlockStateArgumentSerializer blockState() { + public static BlockStateArgumentSerializer blockState(CommandRegistryAccess registryAccess) { + if (INSTANCE == null) { + INSTANCE = new BlockStateArgumentSerializer(registryAccess); + } + return INSTANCE; } @@ -37,7 +38,7 @@ public String serialize(BlockStateArgument value) { var block = state.getBlock(); var builder = new StringBuilder() - .append(Registry.BLOCK.getId(block)); + .append(Registries.BLOCK.getId(block)); if (state.getProperties().size() == 0) { return builder.toString(); From 43c21b8c0844b72a1d8f1c33c0a8276b2aeb6c9a Mon Sep 17 00:00:00 2001 From: rugmj Date: Sun, 31 Dec 2023 13:31:29 +0000 Subject: [PATCH 07/29] updates blockreadfeature --- .../features/commands/BinaryBlockReadFeature.java | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-) diff --git a/src/main/java/tools/redstone/redstonetools/features/commands/BinaryBlockReadFeature.java b/src/main/java/tools/redstone/redstonetools/features/commands/BinaryBlockReadFeature.java index 4d324c13..332f97de 100644 --- a/src/main/java/tools/redstone/redstonetools/features/commands/BinaryBlockReadFeature.java +++ b/src/main/java/tools/redstone/redstonetools/features/commands/BinaryBlockReadFeature.java @@ -26,22 +26,19 @@ import static tools.redstone.redstonetools.features.arguments.serializers.IntegerSerializer.integer; import static tools.redstone.redstonetools.features.arguments.serializers.NumberBaseSerializer.numberBase; -import Z; - @AutoService(AbstractFeature.class) @Feature(name = "Binary Block Read", description = "Interprets your WorldEdit selection as a binary number.", command = "/read", worldedit = true) public class BinaryBlockReadFeature extends CommandFeature { private static final BlockStateArgument LIT_LAMP_ARG = new BlockStateArgument( Blocks.REDSTONE_LAMP.getDefaultState().with(RedstoneLampBlock.LIT, true), Collections.singleton(RedstoneLampBlock.LIT), - null - ); + null); public static final Argument offset = Argument .ofType(integer(1)) .withDefault(2); public static final Argument onBlock = Argument - .ofType(blockState()) + .ofType(blockState(REGISTRY_ACCESS)) .withDefault(LIT_LAMP_ARG); public static final Argument toBase = Argument .ofType(numberBase()) @@ -105,4 +102,4 @@ protected Feedback execute(ServerCommandSource source) throws CommandSyntaxExcep return Feedback.success("{}.", output); } -} \ No newline at end of file +} From 087b033c04aa7e845bf2834c8a4ea89cbddef591 Mon Sep 17 00:00:00 2001 From: rugmj Date: Sun, 31 Dec 2023 13:39:32 +0000 Subject: [PATCH 08/29] updates command sender in commandfeature --- .../redstonetools/features/commands/CommandFeature.java | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/main/java/tools/redstone/redstonetools/features/commands/CommandFeature.java b/src/main/java/tools/redstone/redstonetools/features/commands/CommandFeature.java index b4ee8347..0a3ee81a 100644 --- a/src/main/java/tools/redstone/redstonetools/features/commands/CommandFeature.java +++ b/src/main/java/tools/redstone/redstonetools/features/commands/CommandFeature.java @@ -17,6 +17,7 @@ import com.mojang.brigadier.CommandDispatcher; import com.mojang.brigadier.exceptions.CommandSyntaxException; import net.minecraft.server.command.ServerCommandSource; +import net.minecraft.text.Text; import java.util.ArrayList; import java.util.List; @@ -50,7 +51,7 @@ public void register() { ClientTickEvents.END_CLIENT_TICK.register(client -> { while (keyBinding.wasPressed()) { assert client.player != null; - client.player.sendChatMessage("/" + info.command()); + client.player.sendMessage(Text.literal("/" + info.command())); } }); } From f71fc098f2f92c1fdbd8edb8c7f7f3af3cee6d87 Mon Sep 17 00:00:00 2001 From: rugmj Date: Sun, 31 Dec 2023 13:56:18 +0000 Subject: [PATCH 09/29] removes weird import leftover from mappings updater --- .../serializers/IntLikeSerializer.java | 20 +++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/IntLikeSerializer.java b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/IntLikeSerializer.java index 5619d8a5..987d7df1 100644 --- a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/IntLikeSerializer.java +++ b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/IntLikeSerializer.java @@ -1,6 +1,5 @@ package tools.redstone.redstonetools.features.arguments.serializers; -import ; import com.mojang.brigadier.StringReader; import com.mojang.brigadier.context.CommandContext; import com.mojang.brigadier.exceptions.CommandSyntaxException; @@ -59,23 +58,24 @@ private T deserializeUnchecked(String serialized) { return tryParse(serialized); } - if(serialized.charAt(0) == '-' && serialized.chars().filter(ch -> ch == '-').count() == 1){ + if (serialized.charAt(0) == '-' && serialized.chars().filter(ch -> ch == '-').count() == 1) { isNegative = true; - serialized = serialized.replace("-",""); + serialized = serialized.replace("-", ""); } if (serialized.charAt(0) == '0') { - if(serialized.length() > 1) { + if (serialized.length() > 1) { var prefixedBase = serialized.substring(0, 2); var number = serialized.substring(2); var numberBase = NumberBase.fromPrefix(prefixedBase).orElse(null); if (numberBase != null) { - return isNegative ? tryParse("-" + number, numberBase.toInt()) : tryParse(number, numberBase.toInt()); + return isNegative ? tryParse("-" + number, numberBase.toInt()) + : tryParse(number, numberBase.toInt()); } } else { - return tryParse(serialized,10); + return tryParse(serialized, 10); } } @@ -94,10 +94,10 @@ private T deserializeUnchecked(String serialized) { throw new IllegalArgumentException("Invalid base '" + parts[1] + "'."); } - return isNegative ? tryParse("-"+number, base) : tryParse(number, base); + return isNegative ? tryParse("-" + number, base) : tryParse(number, base); } - return isNegative ? tryParse("-"+serialized) : tryParse(serialized); + return isNegative ? tryParse("-" + serialized) : tryParse(serialized); } private T tryParse(String string) { @@ -107,8 +107,8 @@ private T tryParse(String string) { private T tryParse(String string, int radix) { return tryParseOptional(string, radix) .orElseThrow(() -> new IllegalArgumentException(radix == 10 - ? "Invalid number '" + string + "'." - : "Invalid base " + radix + " number '" + string + "'.")); + ? "Invalid number '" + string + "'." + : "Invalid base " + radix + " number '" + string + "'.")); } protected abstract Optional tryParseOptional(String string, int radix); From 3ebf2ee96bbd446b160a4a8c7d4b23eb20f0c724 Mon Sep 17 00:00:00 2001 From: rugmj Date: Sun, 31 Dec 2023 14:08:53 +0000 Subject: [PATCH 10/29] removes all weird imports left over --- .../commands/MinSelectionFeature.java | 2 - .../features/commands/QuickTpFeature.java | 2 - .../features/commands/RStackFeature.java | 6 +-- .../toggleable/ToggleableFeature.java | 40 ++++++++++--------- .../redstonetools/macros/MacroManager.java | 6 +-- 5 files changed, 24 insertions(+), 32 deletions(-) diff --git a/src/main/java/tools/redstone/redstonetools/features/commands/MinSelectionFeature.java b/src/main/java/tools/redstone/redstonetools/features/commands/MinSelectionFeature.java index b97f7acf..b5ee5452 100644 --- a/src/main/java/tools/redstone/redstonetools/features/commands/MinSelectionFeature.java +++ b/src/main/java/tools/redstone/redstonetools/features/commands/MinSelectionFeature.java @@ -1,6 +1,5 @@ package tools.redstone.redstonetools.features.commands; -import Z; import com.google.auto.service.AutoService; import tools.redstone.redstonetools.features.AbstractFeature; import tools.redstone.redstonetools.features.Feature; @@ -58,7 +57,6 @@ protected Feedback execute(ServerCommandSource source) throws CommandSyntaxExcep if (isEmpty) { return Feedback.invalidUsage("Cannot minimize empty selections."); } - minimiseSelection(selectionWorld, selection); diff --git a/src/main/java/tools/redstone/redstonetools/features/commands/QuickTpFeature.java b/src/main/java/tools/redstone/redstonetools/features/commands/QuickTpFeature.java index a0d9ef9f..46ffbf0e 100644 --- a/src/main/java/tools/redstone/redstonetools/features/commands/QuickTpFeature.java +++ b/src/main/java/tools/redstone/redstonetools/features/commands/QuickTpFeature.java @@ -18,8 +18,6 @@ import static tools.redstone.redstonetools.features.arguments.serializers.BoolSerializer.bool; import static tools.redstone.redstonetools.features.arguments.serializers.FloatSerializer.floatArg; -import D; - @AutoService(AbstractFeature.class) @Feature(name = "Quick TP", description = "Teleports you in the direction you are looking.", command = "quicktp") public class QuickTpFeature extends CommandFeature { diff --git a/src/main/java/tools/redstone/redstonetools/features/commands/RStackFeature.java b/src/main/java/tools/redstone/redstonetools/features/commands/RStackFeature.java index f92d302a..77364d75 100644 --- a/src/main/java/tools/redstone/redstonetools/features/commands/RStackFeature.java +++ b/src/main/java/tools/redstone/redstonetools/features/commands/RStackFeature.java @@ -30,8 +30,6 @@ import static tools.redstone.redstonetools.utils.DirectionUtils.directionToBlock; import static tools.redstone.redstonetools.utils.DirectionUtils.matchDirection; -import I; - @AutoService(AbstractFeature.class) @Feature(name = "RStack", description = "Stacks with custom distance", command = "/rstack", worldedit = true) public class RStackFeature extends CommandFeature { @@ -83,15 +81,13 @@ public Mask2D toMask2D() { var stackVector = directionToBlock(stackDirection); - try (var editSession = localSession.createEditSession(actor)) { for (var i = 1; i <= count.getValue(); i++) { var copy = new ForwardExtentCopy( editSession, selection, editSession, - selection.getMinimumPoint().add(stackVector.multiply(i * offset.getValue())) - ); + selection.getMinimumPoint().add(stackVector.multiply(i * offset.getValue()))); copy.setSourceMask(airFilter); Operations.complete(copy); } diff --git a/src/main/java/tools/redstone/redstonetools/features/toggleable/ToggleableFeature.java b/src/main/java/tools/redstone/redstonetools/features/toggleable/ToggleableFeature.java index 0cd189a5..2e80d9ff 100644 --- a/src/main/java/tools/redstone/redstonetools/features/toggleable/ToggleableFeature.java +++ b/src/main/java/tools/redstone/redstonetools/features/toggleable/ToggleableFeature.java @@ -41,8 +41,6 @@ import static tools.redstone.redstonetools.RedstoneToolsClient.INJECTOR; -import Z; - import static net.minecraft.server.command.CommandManager.argument; import static net.minecraft.server.command.CommandManager.literal; @@ -53,14 +51,14 @@ public abstract class ToggleableFeature extends AbstractFeature { @Override public void register() { super.register(); - + // load user settings // and register save hook loadConfig(); ClientLifecycleEvents.CLIENT_STOPPING.register(client -> { saveConfig(); }); - + var containsRequiredArguments = ReflectionUtils.getArguments(getClass()).stream() .anyMatch(a -> !a.isOptional()); if (containsRequiredArguments) { @@ -72,8 +70,7 @@ public void register() { info.name(), InputUtil.Type.KEYSYM, -1, - "Redstone Tools" - )); + "Redstone Tools")); keyBindings.add(keyBinding); @@ -101,7 +98,8 @@ public void register() { @SuppressWarnings({ "rawtypes", "unchecked" }) @Override - protected void registerCommands(CommandDispatcher dispatcher, CommandRegistryAccess registryAccess, RegistrationEnvironment environment) { + protected void registerCommands(CommandDispatcher dispatcher, + CommandRegistryAccess registryAccess, RegistrationEnvironment environment) { var baseCommand = literal(getCommand()) .executes(this::toggle); @@ -111,7 +109,8 @@ protected void registerCommands(CommandDispatcher dispatche baseCommand.then(literal(name) .executes(context -> { Object value = argument.getValue(); - return Feedback.success("Option {} of feature {} is set to: {}", name, getName(), argument.getType().serialize(value)).send(context); + return Feedback.success("Option {} of feature {} is set to: {}", name, getName(), + argument.getType().serialize(value)).send(context); }) .then(argument("value", argument.getType()).executes(context -> { Object value = context.getArgument("value", argument.getType().getTypeClass()); @@ -125,8 +124,7 @@ protected void registerCommands(CommandDispatcher dispatche IO_EXECUTOR.execute(this::saveConfig); return Feedback.success("Set {} to {} for feature {}", name, value, getName()).send(context); - })) - ); + }))); } dispatcher.register(baseCommand); @@ -185,13 +183,16 @@ public int disable(CommandContext context) throws CommandSy return disable(context.getSource()); } - protected void onEnable() { } - protected void onDisable() { } + protected void onEnable() { + } + + protected void onDisable() { + } // todo: right now the configuration methods are assuming every - // type is serialized to a string, this should be fixed in the future - // but for now it works because every type right now serializes to a string - // + it will probably be refactored soon + // type is serialized to a string, this should be fixed in the future + // but for now it works because every type right now serializes to a string + // + it will probably be refactored soon /** Reloads the configuration from the disk. */ @SuppressWarnings({ "rawtypes", "unchecked" }) @@ -219,9 +220,11 @@ public void loadConfig() { setEnabled(enabled); - RedstoneToolsClient.LOGGER.info("Loaded configuration for feature " + getID() + " file(" + configFile + ")"); + RedstoneToolsClient.LOGGER + .info("Loaded configuration for feature " + getID() + " file(" + configFile + ")"); } catch (Exception e) { - RedstoneToolsClient.LOGGER.error("Failed to load configuration for feature " + getID() + " file(" + configFile + ")"); + RedstoneToolsClient.LOGGER + .error("Failed to load configuration for feature " + getID() + " file(" + configFile + ")"); e.printStackTrace(); } } @@ -254,7 +257,8 @@ public void saveConfig() { RedstoneToolsClient.LOGGER.info("Saved configuration for feature " + getID() + " file(" + configFile + ")"); } catch (Exception e) { - RedstoneToolsClient.LOGGER.error("Failed to save configuration for feature " + getID() + " file(" + configFile + ")"); + RedstoneToolsClient.LOGGER + .error("Failed to save configuration for feature " + getID() + " file(" + configFile + ")"); e.printStackTrace(); } } diff --git a/src/main/java/tools/redstone/redstonetools/macros/MacroManager.java b/src/main/java/tools/redstone/redstonetools/macros/MacroManager.java index 1701fcfe..e3d02869 100644 --- a/src/main/java/tools/redstone/redstonetools/macros/MacroManager.java +++ b/src/main/java/tools/redstone/redstonetools/macros/MacroManager.java @@ -12,8 +12,6 @@ import javax.json.JsonObject; import javax.json.JsonReader; import javax.json.JsonWriter; -import ; -import Z; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; @@ -33,7 +31,6 @@ public MacroManager() { .resolve("redstonetools") .resolve("macros.json"); - JsonArray macrosJson = null; try { Files.createDirectories(macrosFilePath.getParent()); @@ -136,8 +133,7 @@ private List getDefaultMacros() { "/gamerule doContainerDrops false", "/time set noon", "/weather clear" - }) - ); + })); } private Macro createCommandMacro(String name, String[] commands) { From 181d951a79d2070a7c283e7c6b712d2cced29c86 Mon Sep 17 00:00:00 2001 From: rugmj Date: Sun, 31 Dec 2023 15:24:10 +0000 Subject: [PATCH 11/29] updates all utils --- .../utils/BlockStateNbtUtil.java | 12 +++---- .../redstonetools/utils/ColoredBlock.java | 36 +++++++++++-------- .../utils/CommandSourceUtils.java | 6 ++-- .../redstonetools/utils/DirectionUtils.java | 11 +++--- .../redstonetools/utils/RaycastUtils.java | 13 ++++--- .../utils/SignalBlockSupplier.java | 18 ++++++---- .../redstonetools/utils/WorldEditUtils.java | 7 ++-- 7 files changed, 55 insertions(+), 48 deletions(-) diff --git a/src/main/java/tools/redstone/redstonetools/utils/BlockStateNbtUtil.java b/src/main/java/tools/redstone/redstonetools/utils/BlockStateNbtUtil.java index 8938af04..da560228 100644 --- a/src/main/java/tools/redstone/redstonetools/utils/BlockStateNbtUtil.java +++ b/src/main/java/tools/redstone/redstonetools/utils/BlockStateNbtUtil.java @@ -7,7 +7,7 @@ import net.minecraft.nbt.NbtCompound; import net.minecraft.nbt.NbtElement; import net.minecraft.nbt.NbtList; -import net.minecraft.registry.Registry; +import net.minecraft.registry.Registries; import net.minecraft.server.world.ServerWorld; import net.minecraft.state.property.Property; import net.minecraft.util.Identifier; @@ -34,7 +34,7 @@ public static NbtCompound toNBT(BlockState state) { } NbtCompound root = new NbtCompound(); - root.putString("Id", Registry.BLOCK.getId(state.getBlock()).toString()); + root.putString("Id", Registries.BLOCK.getId(state.getBlock()).toString()); // serialize properties if (!state.getProperties().isEmpty()) { @@ -69,7 +69,7 @@ public static BlockState fromNBT(NbtCompound compound) { // we use new Identifier(...) here to allow it to throw exceptions // instead of getting a cryptic NPE Identifier identifier = new Identifier(compound.getString("Id")); - Block block = Registry.BLOCK.get(identifier); + Block block = Registries.BLOCK.get(identifier); // deserialize properties BlockState state = block.getDefaultState(); @@ -96,7 +96,7 @@ public static BlockState fromNBT(NbtCompound compound) { * or returns the given default if the tag is null/empty. * * @param compound The NBT tag. - * @param def The default. + * @param def The default. * @return The block state or {@code def} if the tag is null/empty. */ public static BlockState fromNBT(NbtCompound compound, BlockState def) { @@ -171,9 +171,7 @@ public static BlockState getPlacementState(ItemStack stack) { return null; } - BlockState def = stack.getItem() instanceof BlockItem blockItem ? - blockItem.getBlock().getDefaultState() : - null; + BlockState def = stack.getItem() instanceof BlockItem blockItem ? blockItem.getBlock().getDefaultState() : null; return fromNBT(nbt.getCompound(EXACT_STATE_KEY), def); } diff --git a/src/main/java/tools/redstone/redstonetools/utils/ColoredBlock.java b/src/main/java/tools/redstone/redstonetools/utils/ColoredBlock.java index da288a52..c672df25 100644 --- a/src/main/java/tools/redstone/redstonetools/utils/ColoredBlock.java +++ b/src/main/java/tools/redstone/redstonetools/utils/ColoredBlock.java @@ -1,7 +1,7 @@ package tools.redstone.redstonetools.utils; import net.minecraft.block.Block; -import net.minecraft.registry.Registry; +import net.minecraft.registry.Registries; import net.minecraft.util.Identifier; import org.jetbrains.annotations.NotNull; @@ -11,17 +11,20 @@ public class ColoredBlock { private static final Pattern COLORED_BLOCK_REGEX = Pattern.compile( - "^minecraft:(\\w+?)_(wool|stained_glass|concrete_powder|concrete|glazed_terracotta|terracotta)$" - ); + "^minecraft:(\\w+?)_(wool|stained_glass|concrete_powder|concrete|glazed_terracotta|terracotta)$"); - private static final HashMap COLORLESS_BLOCKS = new HashMap<>() {{ - put("minecraft:glass", new ColoredBlock("minecraft:%s_stained_glass", BlockColor.WHITE)); - put("minecraft:terracotta", new ColoredBlock("minecraft:%s_terracotta", BlockColor.WHITE)); - }}; + private static final HashMap COLORLESS_BLOCKS = new HashMap<>() { + { + put("minecraft:glass", new ColoredBlock("minecraft:%s_stained_glass", BlockColor.WHITE)); + put("minecraft:terracotta", new ColoredBlock("minecraft:%s_terracotta", BlockColor.WHITE)); + } + }; - private static final HashMap COLORED_BLOCK_CACHE = new HashMap<>() {{ - putAll(COLORLESS_BLOCKS); - }}; + private static final HashMap COLORED_BLOCK_CACHE = new HashMap<>() { + { + putAll(COLORLESS_BLOCKS); + } + }; private final String blockIdFormat; public final BlockColor color; @@ -60,23 +63,26 @@ public String toBlockId() { } public static ColoredBlock fromBlock(@NotNull Block block) { - var blockId = Registry.BLOCK.getId(block).toString(); + var blockId = Registries.BLOCK.getId(block).toString(); if (COLORED_BLOCK_CACHE.containsKey(blockId)) { return COLORED_BLOCK_CACHE.get(blockId); } var coloredBlock = fromBlockId(blockId); - // The reason we only cache nulls here and not in the fromBlockId method is because the fromBlockId method would - // also cache invalid block ids (literally any string) which would make the cache massive. This method however - // only accepts actual blocks which means that the cache will never grow bigger than the amount of mc blocks. + // The reason we only cache nulls here and not in the fromBlockId method is + // because the fromBlockId method would + // also cache invalid block ids (literally any string) which would make the + // cache massive. This method however + // only accepts actual blocks which means that the cache will never grow bigger + // than the amount of mc blocks. COLORED_BLOCK_CACHE.put(blockId, coloredBlock); return coloredBlock; } public Block toBlock() { - return Registry.BLOCK.get(Identifier.tryParse(toBlockId())); + return Registries.BLOCK.get(Identifier.tryParse(toBlockId())); } @Override diff --git a/src/main/java/tools/redstone/redstonetools/utils/CommandSourceUtils.java b/src/main/java/tools/redstone/redstonetools/utils/CommandSourceUtils.java index fd0b5c4a..939da18a 100644 --- a/src/main/java/tools/redstone/redstonetools/utils/CommandSourceUtils.java +++ b/src/main/java/tools/redstone/redstonetools/utils/CommandSourceUtils.java @@ -1,12 +1,14 @@ package tools.redstone.redstonetools.utils; +import com.mojang.brigadier.exceptions.CommandSyntaxException; + import net.minecraft.server.command.ServerCommandSource; public class CommandSourceUtils { private CommandSourceUtils() { } - public static void executeCommand(ServerCommandSource source, String command) { - source.getServer().getCommandManager().execute(source, command); + public static void executeCommand(ServerCommandSource source, String command) throws CommandSyntaxException { + source.getServer().getCommandManager().getDispatcher().execute(command, source); } } diff --git a/src/main/java/tools/redstone/redstonetools/utils/DirectionUtils.java b/src/main/java/tools/redstone/redstonetools/utils/DirectionUtils.java index 2eb14654..8fbcbe3b 100644 --- a/src/main/java/tools/redstone/redstonetools/utils/DirectionUtils.java +++ b/src/main/java/tools/redstone/redstonetools/utils/DirectionUtils.java @@ -1,9 +1,8 @@ package tools.redstone.redstonetools.utils; - +import com.mojang.brigadier.exceptions.SimpleCommandExceptionType; import com.sk89q.worldedit.math.BlockVector3; import com.sk89q.worldedit.util.Direction; -import net.minecraft.command.CommandException; import net.minecraft.text.Text; import org.jetbrains.annotations.NotNull; @@ -17,7 +16,7 @@ public static Direction firstOrdinal(Direction playerFacing) { default -> playerFacing; }; } - + public static DirectionArgument relativeToAbsolute(DirectionArgument direction, Direction playerFacing) { return switch (direction) { case ME, FORWARD -> switch (firstOrdinal(playerFacing)) { @@ -74,9 +73,11 @@ public static DirectionArgument relativeToAbsolute(DirectionArgument direction, }; } - // big evil match direction function, there might be a better way to do this but i don't know how + // big evil match direction function, there might be a better way to do this but + // i don't know how @NotNull - public static Direction matchDirection(DirectionArgument direction, Direction playerFacing) throws CommandException { + public static Direction matchDirection(DirectionArgument direction, Direction playerFacing) + throws CommandException { var absoluteDirection = relativeToAbsolute(direction, playerFacing); return switch (absoluteDirection) { case NORTH -> Direction.NORTH; diff --git a/src/main/java/tools/redstone/redstonetools/utils/RaycastUtils.java b/src/main/java/tools/redstone/redstonetools/utils/RaycastUtils.java index 7286b95d..468ba44a 100644 --- a/src/main/java/tools/redstone/redstonetools/utils/RaycastUtils.java +++ b/src/main/java/tools/redstone/redstonetools/utils/RaycastUtils.java @@ -1,9 +1,9 @@ package tools.redstone.redstonetools.utils; +import org.joml.Vector3f; + import net.minecraft.entity.player.PlayerEntity; import net.minecraft.util.hit.BlockHitResult; -import net.minecraft.util.math.BlockPos; -import net.minecraft.util.math.Vec3f; import net.minecraft.world.RaycastContext; public class RaycastUtils { @@ -11,20 +11,19 @@ private RaycastUtils() { } public static BlockHitResult getBlockHitNeighbor(BlockHitResult hit) { - var sideOffset = hit.getSide().getUnitVector(); + Vector3f sideOffset = hit.getSide().getUnitVector(); - var newBlockPos = hit.getBlockPos().add(sideOffset.getX(), sideOffset.getY(), sideOffset.getZ()); + var newBlockPos = hit.getBlockPos().add((int) sideOffset.x(), (int) sideOffset.y(), (int) sideOffset.z()); return hit.withBlockPos(newBlockPos); } public static BlockHitResult rayCastFromEye(PlayerEntity player, float reach) { - return player.method_48926().raycast(new RaycastContext( + return player.getWorld().raycast(new RaycastContext( player.getEyePos(), player.getEyePos().add(player.getRotationVector().multiply(reach)), RaycastContext.ShapeType.COLLIDER, RaycastContext.FluidHandling.NONE, - player - )); + player)); } } diff --git a/src/main/java/tools/redstone/redstonetools/utils/SignalBlockSupplier.java b/src/main/java/tools/redstone/redstonetools/utils/SignalBlockSupplier.java index 4f34f8e1..0e42015c 100644 --- a/src/main/java/tools/redstone/redstonetools/utils/SignalBlockSupplier.java +++ b/src/main/java/tools/redstone/redstonetools/utils/SignalBlockSupplier.java @@ -7,9 +7,10 @@ import net.minecraft.item.Items; import net.minecraft.nbt.NbtCompound; import net.minecraft.nbt.NbtList; +import net.minecraft.registry.Registries; import net.minecraft.registry.Registry; -import net.minecraft.text.LiteralText; import net.minecraft.text.MutableText; +import net.minecraft.text.Text; import net.minecraft.util.Formatting; import net.minecraft.util.math.MathHelper; @@ -38,12 +39,15 @@ static SignalBlockSupplier container(int slots) { int itemsNeeded = Math.max(0, signalStrength == 1 ? 1 : (int) Math.ceil(slots * (signalStrength - 1) / 14D * item.getMaxCount())); - String itemId = Registry.ITEM.getId(item).toString(); + String itemId = Registries.ITEM.getId(item).toString(); // Check that the calculated number of items is correct. - // This is to prevent problems with items that have a maximum stack size of 1 but stackSize > 1. - // TODO: This can be improved by removing an item and adding stackable items up to the desired signal strength. - // Even with the improvement, this will still fail for inventories with no available slots. + // This is to prevent problems with items that have a maximum stack size of 1 + // but stackSize > 1. + // TODO: This can be improved by removing an item and adding stackable items up + // to the desired signal strength. + // Even with the improvement, this will still fail for inventories with no + // available slots. if (calculateComparatorOutput(itemsNeeded, slots, item.getMaxCount()) != signalStrength) throw new IllegalStateException("This signal strength cannot be achieved with the selected container"); @@ -95,7 +99,7 @@ private static boolean isInvalidSignalStrength(int signalStrength, int maxSignal private static int calculateComparatorOutput(int items, int slots, int item$getMaxCount) { float f = (float) items / (float) item$getMaxCount; - return MathHelper.floor((f /= (float)slots) * 14.0f) + (items > 0 ? 1 : 0); + return MathHelper.floor((f /= (float) slots) * 14.0f) + (items > 0 ? 1 : 0); } private static Item getBestItem(int signalStrength, int slots) { @@ -123,7 +127,7 @@ private static void setCompoundNbt(ItemStack item, NbtCompound nbt) { } private static void setItemName(ItemStack item, int signalStrength) { - MutableText text = new LiteralText(String.valueOf(signalStrength)); + MutableText text = Text.literal(String.valueOf(signalStrength)); text.setStyle(text.getStyle().withColor(Formatting.RED)); item.setCustomName(text); } diff --git a/src/main/java/tools/redstone/redstonetools/utils/WorldEditUtils.java b/src/main/java/tools/redstone/redstonetools/utils/WorldEditUtils.java index 6f2588d9..99e9566e 100644 --- a/src/main/java/tools/redstone/redstonetools/utils/WorldEditUtils.java +++ b/src/main/java/tools/redstone/redstonetools/utils/WorldEditUtils.java @@ -3,14 +3,11 @@ import tools.redstone.redstonetools.features.feedback.Feedback; import com.mojang.datafixers.util.Either; import com.sk89q.worldedit.IncompleteRegionException; -import com.sk89q.worldedit.LocalSession; import com.sk89q.worldedit.WorldEdit; import com.sk89q.worldedit.fabric.FabricAdapter; -import com.sk89q.worldedit.fabric.FabricPlayer; import com.sk89q.worldedit.math.BlockVector3; import com.sk89q.worldedit.regions.CuboidRegion; import com.sk89q.worldedit.regions.Region; -import com.sk89q.worldedit.world.World; import net.minecraft.server.network.ServerPlayerEntity; import java.util.function.Consumer; @@ -26,11 +23,11 @@ public class WorldEditUtils { * * TODO: maybe make an async version of this somehow * - * @param region The region. + * @param region The region. * @param consumer The function to run. */ public static void forEachBlockInRegion(Region region, - Consumer consumer) { + Consumer consumer) { if (!DependencyLookup.WORLDEDIT_PRESENT) { throw new IllegalStateException("WorldEdit is not loaded."); } From 5abac363bf1e1c461c764157dc3525de30b096fe Mon Sep 17 00:00:00 2001 From: Quie_ Date: Sun, 31 Dec 2023 13:48:14 -0500 Subject: [PATCH 12/29] Deleted random ununsed imports and fixed all the LiteralText erros (now denoted with Text.literal or Text.of) --- .../BlockStateArgumentSerializer.java | 1 - .../serializers/IntLikeSerializer.java | 1 - .../commands/BinaryBlockReadFeature.java | 2 +- .../features/commands/MinSelectionFeature.java | 2 +- .../features/commands/QuickTpFeature.java | 2 +- .../features/commands/RStackFeature.java | 17 +++++------------ .../features/feedback/FeedbackSender.java | 8 +++++--- .../features/toggleable/ToggleableFeature.java | 2 -- .../redstonetools/macros/MacroManager.java | 3 +-- .../macros/gui/screen/MacroEditScreen.java | 5 ++--- .../gui/widget/commandlist/CommandEntry.java | 6 ++++++ .../accessors/MinecraftClientAccessor.java | 4 ++-- .../redstonetools/utils/DirectionUtils.java | 8 +++----- .../utils/SignalBlockSupplier.java | 5 +++-- 14 files changed, 30 insertions(+), 36 deletions(-) diff --git a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/BlockStateArgumentSerializer.java b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/BlockStateArgumentSerializer.java index a211c650..96231923 100644 --- a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/BlockStateArgumentSerializer.java +++ b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/BlockStateArgumentSerializer.java @@ -1,6 +1,5 @@ package tools.redstone.redstonetools.features.arguments.serializers; -import Z; import com.mojang.brigadier.StringReader; import com.mojang.brigadier.exceptions.CommandSyntaxException; import net.minecraft.block.Block; diff --git a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/IntLikeSerializer.java b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/IntLikeSerializer.java index 5619d8a5..0cfc6974 100644 --- a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/IntLikeSerializer.java +++ b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/IntLikeSerializer.java @@ -1,6 +1,5 @@ package tools.redstone.redstonetools.features.arguments.serializers; -import ; import com.mojang.brigadier.StringReader; import com.mojang.brigadier.context.CommandContext; import com.mojang.brigadier.exceptions.CommandSyntaxException; diff --git a/src/main/java/tools/redstone/redstonetools/features/commands/BinaryBlockReadFeature.java b/src/main/java/tools/redstone/redstonetools/features/commands/BinaryBlockReadFeature.java index 4d324c13..06875d91 100644 --- a/src/main/java/tools/redstone/redstonetools/features/commands/BinaryBlockReadFeature.java +++ b/src/main/java/tools/redstone/redstonetools/features/commands/BinaryBlockReadFeature.java @@ -26,7 +26,7 @@ import static tools.redstone.redstonetools.features.arguments.serializers.IntegerSerializer.integer; import static tools.redstone.redstonetools.features.arguments.serializers.NumberBaseSerializer.numberBase; -import Z; + @AutoService(AbstractFeature.class) @Feature(name = "Binary Block Read", description = "Interprets your WorldEdit selection as a binary number.", command = "/read", worldedit = true) diff --git a/src/main/java/tools/redstone/redstonetools/features/commands/MinSelectionFeature.java b/src/main/java/tools/redstone/redstonetools/features/commands/MinSelectionFeature.java index b97f7acf..4094b637 100644 --- a/src/main/java/tools/redstone/redstonetools/features/commands/MinSelectionFeature.java +++ b/src/main/java/tools/redstone/redstonetools/features/commands/MinSelectionFeature.java @@ -1,6 +1,6 @@ package tools.redstone.redstonetools.features.commands; -import Z; + import com.google.auto.service.AutoService; import tools.redstone.redstonetools.features.AbstractFeature; import tools.redstone.redstonetools.features.Feature; diff --git a/src/main/java/tools/redstone/redstonetools/features/commands/QuickTpFeature.java b/src/main/java/tools/redstone/redstonetools/features/commands/QuickTpFeature.java index a0d9ef9f..d5882195 100644 --- a/src/main/java/tools/redstone/redstonetools/features/commands/QuickTpFeature.java +++ b/src/main/java/tools/redstone/redstonetools/features/commands/QuickTpFeature.java @@ -18,7 +18,7 @@ import static tools.redstone.redstonetools.features.arguments.serializers.BoolSerializer.bool; import static tools.redstone.redstonetools.features.arguments.serializers.FloatSerializer.floatArg; -import D; + @AutoService(AbstractFeature.class) @Feature(name = "Quick TP", description = "Teleports you in the direction you are looking.", command = "quicktp") diff --git a/src/main/java/tools/redstone/redstonetools/features/commands/RStackFeature.java b/src/main/java/tools/redstone/redstonetools/features/commands/RStackFeature.java index f92d302a..1dc7a170 100644 --- a/src/main/java/tools/redstone/redstonetools/features/commands/RStackFeature.java +++ b/src/main/java/tools/redstone/redstonetools/features/commands/RStackFeature.java @@ -1,37 +1,30 @@ package tools.redstone.redstonetools.features.commands; import com.google.auto.service.AutoService; -import tools.redstone.redstonetools.features.AbstractFeature; -import tools.redstone.redstonetools.features.Feature; -import tools.redstone.redstonetools.features.arguments.Argument; -import tools.redstone.redstonetools.features.feedback.Feedback; -import tools.redstone.redstonetools.utils.DirectionArgument; import com.mojang.brigadier.exceptions.CommandSyntaxException; -import com.sk89q.worldedit.EditSession; import com.sk89q.worldedit.IncompleteRegionException; -import com.sk89q.worldedit.LocalSession; import com.sk89q.worldedit.WorldEdit; import com.sk89q.worldedit.WorldEditException; import com.sk89q.worldedit.fabric.FabricAdapter; -import com.sk89q.worldedit.fabric.FabricPlayer; import com.sk89q.worldedit.function.mask.Mask; import com.sk89q.worldedit.function.mask.Mask2D; import com.sk89q.worldedit.function.operation.ForwardExtentCopy; import com.sk89q.worldedit.function.operation.Operations; import com.sk89q.worldedit.math.BlockVector3; import com.sk89q.worldedit.regions.Region; -import com.sk89q.worldedit.util.Direction; -import com.sk89q.worldedit.world.World; import net.minecraft.server.command.ServerCommandSource; import org.jetbrains.annotations.Nullable; +import tools.redstone.redstonetools.features.AbstractFeature; +import tools.redstone.redstonetools.features.Feature; +import tools.redstone.redstonetools.features.arguments.Argument; +import tools.redstone.redstonetools.features.feedback.Feedback; +import tools.redstone.redstonetools.utils.DirectionArgument; import static tools.redstone.redstonetools.features.arguments.serializers.DirectionSerializer.direction; import static tools.redstone.redstonetools.features.arguments.serializers.IntegerSerializer.integer; import static tools.redstone.redstonetools.utils.DirectionUtils.directionToBlock; import static tools.redstone.redstonetools.utils.DirectionUtils.matchDirection; -import I; - @AutoService(AbstractFeature.class) @Feature(name = "RStack", description = "Stacks with custom distance", command = "/rstack", worldedit = true) public class RStackFeature extends CommandFeature { diff --git a/src/main/java/tools/redstone/redstonetools/features/feedback/FeedbackSender.java b/src/main/java/tools/redstone/redstonetools/features/feedback/FeedbackSender.java index efd5a156..9528ab5a 100644 --- a/src/main/java/tools/redstone/redstonetools/features/feedback/FeedbackSender.java +++ b/src/main/java/tools/redstone/redstonetools/features/feedback/FeedbackSender.java @@ -1,9 +1,10 @@ package tools.redstone.redstonetools.features.feedback; import net.minecraft.server.command.ServerCommandSource; -import net.minecraft.text.LiteralText; +import net.minecraft.text.Text; import javax.inject.Singleton; +import java.util.function.Supplier; @Singleton public class FeedbackSender extends AbstractFeedbackSender { @@ -12,8 +13,9 @@ public void sendFeedback(ServerCommandSource source, Feedback feedback) { if (feedback.getType() == FeedbackType.NONE) { return; } + Supplier feedbackSupplier = () -> Text.literal(feedback.getMessage()) + .formatted(feedback.getFormatting()); - source.sendFeedback(new LiteralText(feedback.getMessage()) - .formatted(feedback.getFormatting()), false); + source.sendFeedback(feedbackSupplier, false); } } diff --git a/src/main/java/tools/redstone/redstonetools/features/toggleable/ToggleableFeature.java b/src/main/java/tools/redstone/redstonetools/features/toggleable/ToggleableFeature.java index 0cd189a5..acca0071 100644 --- a/src/main/java/tools/redstone/redstonetools/features/toggleable/ToggleableFeature.java +++ b/src/main/java/tools/redstone/redstonetools/features/toggleable/ToggleableFeature.java @@ -41,8 +41,6 @@ import static tools.redstone.redstonetools.RedstoneToolsClient.INJECTOR; -import Z; - import static net.minecraft.server.command.CommandManager.argument; import static net.minecraft.server.command.CommandManager.literal; diff --git a/src/main/java/tools/redstone/redstonetools/macros/MacroManager.java b/src/main/java/tools/redstone/redstonetools/macros/MacroManager.java index 1701fcfe..d666f9ec 100644 --- a/src/main/java/tools/redstone/redstonetools/macros/MacroManager.java +++ b/src/main/java/tools/redstone/redstonetools/macros/MacroManager.java @@ -12,8 +12,7 @@ import javax.json.JsonObject; import javax.json.JsonReader; import javax.json.JsonWriter; -import ; -import Z; + import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; diff --git a/src/main/java/tools/redstone/redstonetools/macros/gui/screen/MacroEditScreen.java b/src/main/java/tools/redstone/redstonetools/macros/gui/screen/MacroEditScreen.java index 0e7ac2b2..6918d673 100644 --- a/src/main/java/tools/redstone/redstonetools/macros/gui/screen/MacroEditScreen.java +++ b/src/main/java/tools/redstone/redstonetools/macros/gui/screen/MacroEditScreen.java @@ -21,7 +21,6 @@ import net.minecraft.client.util.InputUtil.Type; import net.minecraft.client.util.math.MatrixStack; import net.minecraft.screen.ScreenTexts; -import net.minecraft.text.LiteralText; import net.minecraft.text.Text; import net.minecraft.util.Formatting; import tools.redstone.redstonetools.utils.KeyBindingUtils; @@ -92,11 +91,11 @@ public void init() { Key keyCode = macro.getKey(); Text text = keyCode.getLocalizedText(); if (keyCode == InputUtil.UNKNOWN_KEY) text = Text.of(""); - if ( KeyBindingUtils.isKeyAlreadyBound(keyCode) ) { text = new LiteralText(text.getString()).formatted(Formatting.RED); } + if ( KeyBindingUtils.isKeyAlreadyBound(keyCode) ) { text = Text.literal(text.getString()).formatted(Formatting.RED); } keyBindButton = new ButtonWidget(this.width / 2 + 26, 55, 75, 20, text, (button) -> { detectingKeycodeKey = true; - keyBindButton.setMessage((new LiteralText("> ")).append(keyBindButton.getMessage().copy().formatted(Formatting.YELLOW)).append(" <").formatted(Formatting.YELLOW)); + keyBindButton.setMessage((Text.literal("> ")).append(keyBindButton.getMessage().copy().formatted(Formatting.YELLOW)).append(" <").formatted(Formatting.YELLOW)); }); if (detectingKeycodeKey) keyBindButton.onPress(); diff --git a/src/main/java/tools/redstone/redstonetools/macros/gui/widget/commandlist/CommandEntry.java b/src/main/java/tools/redstone/redstonetools/macros/gui/widget/commandlist/CommandEntry.java index bdc9c0da..5258f904 100644 --- a/src/main/java/tools/redstone/redstonetools/macros/gui/widget/commandlist/CommandEntry.java +++ b/src/main/java/tools/redstone/redstonetools/macros/gui/widget/commandlist/CommandEntry.java @@ -1,5 +1,6 @@ package tools.redstone.redstonetools.macros.gui.widget.commandlist; +import net.minecraft.client.gui.DrawContext; import tools.redstone.redstonetools.macros.gui.MacroCommandSuggestor; import tools.redstone.redstonetools.macros.gui.widget.IconButtonWidget; import net.minecraft.client.MinecraftClient; @@ -67,6 +68,11 @@ public void setFocused(boolean focused){ owner.focusOn(this); } + @Override + public void render(DrawContext context, int index, int y, int x, int entryWidth, int entryHeight, int mouseX, int mouseY, boolean hovered, float tickDelta) { + return; + } + protected String getText() { return command.getText(); } diff --git a/src/main/java/tools/redstone/redstonetools/mixin/accessors/MinecraftClientAccessor.java b/src/main/java/tools/redstone/redstonetools/mixin/accessors/MinecraftClientAccessor.java index 6996cf54..17ff6b16 100644 --- a/src/main/java/tools/redstone/redstonetools/mixin/accessors/MinecraftClientAccessor.java +++ b/src/main/java/tools/redstone/redstonetools/mixin/accessors/MinecraftClientAccessor.java @@ -9,7 +9,7 @@ @Mixin(MinecraftClient.class) public interface MinecraftClientAccessor { - @Invoker - ItemStack invokeAddBlockEntityNbt(ItemStack stack, BlockEntity blockEntity); + @Invoker("addBlockEntityNbt") + void invokeAddBlockEntityNbt(ItemStack stack, BlockEntity blockEntity); } diff --git a/src/main/java/tools/redstone/redstonetools/utils/DirectionUtils.java b/src/main/java/tools/redstone/redstonetools/utils/DirectionUtils.java index 2eb14654..4ecc2fdb 100644 --- a/src/main/java/tools/redstone/redstonetools/utils/DirectionUtils.java +++ b/src/main/java/tools/redstone/redstonetools/utils/DirectionUtils.java @@ -3,8 +3,6 @@ import com.sk89q.worldedit.math.BlockVector3; import com.sk89q.worldedit.util.Direction; -import net.minecraft.command.CommandException; -import net.minecraft.text.Text; import org.jetbrains.annotations.NotNull; public class DirectionUtils { @@ -34,7 +32,7 @@ public static DirectionArgument relativeToAbsolute(DirectionArgument direction, default -> null; }; case LEFT -> switch (firstOrdinal(playerFacing)) { - case UP, DOWN -> throw new CommandException(Text.of("Can't determine direction")); + //case UP, DOWN -> throw new CommandException(Text.of("Can't determine direction")); case NORTH -> DirectionArgument.WEST; case EAST -> DirectionArgument.NORTH; case SOUTH -> DirectionArgument.EAST; @@ -46,7 +44,7 @@ public static DirectionArgument relativeToAbsolute(DirectionArgument direction, default -> null; }; case RIGHT -> switch (firstOrdinal(playerFacing)) { - case UP, DOWN -> throw new CommandException(Text.of("Can't determine direction")); + //case UP, DOWN -> throw new CommandException(Text.of("Can't determine direction")); case NORTH -> DirectionArgument.EAST; case EAST -> DirectionArgument.SOUTH; case SOUTH -> DirectionArgument.WEST; @@ -76,7 +74,7 @@ public static DirectionArgument relativeToAbsolute(DirectionArgument direction, // big evil match direction function, there might be a better way to do this but i don't know how @NotNull - public static Direction matchDirection(DirectionArgument direction, Direction playerFacing) throws CommandException { + public static Direction matchDirection(DirectionArgument direction, Direction playerFacing) { var absoluteDirection = relativeToAbsolute(direction, playerFacing); return switch (absoluteDirection) { case NORTH -> Direction.NORTH; diff --git a/src/main/java/tools/redstone/redstonetools/utils/SignalBlockSupplier.java b/src/main/java/tools/redstone/redstonetools/utils/SignalBlockSupplier.java index 4f34f8e1..d7ff3ead 100644 --- a/src/main/java/tools/redstone/redstonetools/utils/SignalBlockSupplier.java +++ b/src/main/java/tools/redstone/redstonetools/utils/SignalBlockSupplier.java @@ -8,8 +8,9 @@ import net.minecraft.nbt.NbtCompound; import net.minecraft.nbt.NbtList; import net.minecraft.registry.Registry; -import net.minecraft.text.LiteralText; +import net.minecraft.text.Text; import net.minecraft.text.MutableText; +import net.minecraft.text.Text; import net.minecraft.util.Formatting; import net.minecraft.util.math.MathHelper; @@ -123,7 +124,7 @@ private static void setCompoundNbt(ItemStack item, NbtCompound nbt) { } private static void setItemName(ItemStack item, int signalStrength) { - MutableText text = new LiteralText(String.valueOf(signalStrength)); + MutableText text = Text.literal(String.valueOf(signalStrength)); text.setStyle(text.getStyle().withColor(Formatting.RED)); item.setCustomName(text); } From a71f6254e9287b9949c2297e2bdb04084dca08f5 Mon Sep 17 00:00:00 2001 From: rugmj Date: Tue, 2 Jan 2024 13:08:25 +0000 Subject: [PATCH 13/29] fixes some ui stuff --- .../macros/gui/screen/MacroEditScreen.java | 23 ++-- .../gui/widget/commandlist/CommandEntry.java | 118 ----------------- .../commandlist/CommandEntryPlaceHolder.java | 10 +- .../widget/commandlist/CommandListWidget.java | 123 +++++++++++++++++- 4 files changed, 131 insertions(+), 143 deletions(-) delete mode 100644 src/main/java/tools/redstone/redstonetools/macros/gui/widget/commandlist/CommandEntry.java diff --git a/src/main/java/tools/redstone/redstonetools/macros/gui/screen/MacroEditScreen.java b/src/main/java/tools/redstone/redstonetools/macros/gui/screen/MacroEditScreen.java index 6918d673..0cdbb8cb 100644 --- a/src/main/java/tools/redstone/redstonetools/macros/gui/screen/MacroEditScreen.java +++ b/src/main/java/tools/redstone/redstonetools/macros/gui/screen/MacroEditScreen.java @@ -1,13 +1,11 @@ package tools.redstone.redstonetools.macros.gui.screen; +import net.minecraft.client.gui.DrawContext; import net.minecraft.client.gui.screen.ConfirmScreen; -import net.minecraft.client.gui.widget.ClickableWidget; -import net.minecraft.util.math.MathHelper; import tools.redstone.redstonetools.macros.Macro; import tools.redstone.redstonetools.macros.MacroManager; import tools.redstone.redstonetools.macros.actions.Action; import tools.redstone.redstonetools.macros.actions.CommandAction; -import tools.redstone.redstonetools.macros.gui.widget.commandlist.CommandEntry; import tools.redstone.redstonetools.macros.gui.widget.commandlist.CommandListWidget; import tools.redstone.redstonetools.macros.gui.widget.macrolist.MacroListWidget; import net.minecraft.client.MinecraftClient; @@ -19,7 +17,6 @@ import net.minecraft.client.util.InputUtil; import net.minecraft.client.util.InputUtil.Key; import net.minecraft.client.util.InputUtil.Type; -import net.minecraft.client.util.math.MatrixStack; import net.minecraft.screen.ScreenTexts; import net.minecraft.text.Text; import net.minecraft.util.Formatting; @@ -102,7 +99,7 @@ public void init() { this.addDrawableChild(keyBindButton); int widgetWidth = 339; - List entries = null; + List entries = null; double scrollAmount = 0; if (commandList != null) { entries = commandList.children(); @@ -115,7 +112,7 @@ public void init() { if (entries != null) { commandList.children().clear(); - for (CommandEntry entry : entries) { + for (CommandListWidget.CommandEntry entry : entries) { entry.setOwner(commandList); commandList.children().add(entry); } @@ -136,20 +133,20 @@ private boolean canClickDone() { } @Override - public void render(MatrixStack matrices, int mouseX, int mouseY, float delta) { + public void render(DrawContext context, int mouseX, int mouseY, float delta) { if (overlapped) { mouseX = -1; mouseY = -1; } this.renderBackgroundTexture(0); - commandList.render(matrices, mouseX, mouseY, delta); - super.render(matrices, mouseX, mouseY, delta); + commandList.render(context, mouseX, mouseY, delta); + super.render(context, mouseX, mouseY, delta); - drawCenteredTextWithShadow(matrices, this.textRenderer, this.title, this.width / 2, 8, 16777215); + drawCenteredTextWithShadow(context, this.textRenderer, this.title, this.width / 2, 8, 16777215); - drawCenteredTextWithShadow(matrices, this.textRenderer, "Key Bind", width / 2 - (99 - textRenderer.getWidth("Key Bind") / 2), 55 + textRenderer.fontHeight / 2, 16777215); - nameField.render(matrices, mouseX, mouseY, delta); + drawCenteredTextWithShadow(context, this.textRenderer, "Key Bind", width / 2 - (99 - textRenderer.getWidth("Key Bind") / 2), 55 + textRenderer.fontHeight / 2, 16777215); + nameField.render(context, mouseX, mouseY, delta); if (nameField.getText().isEmpty() && !nameField.isFocused()) { nameField.setSuggestion("Name"); @@ -244,7 +241,7 @@ private boolean updateKeybinding(Key key) { detectingKeycodeKey = false; Text text = key.getLocalizedText(); if (key == InputUtil.UNKNOWN_KEY) text = Text.of(""); - if ( KeyBindingUtils.isKeyAlreadyBound(key) ) { text = new LiteralText(text.getString()).formatted(Formatting.RED); } + if ( KeyBindingUtils.isKeyAlreadyBound(key) ) { text = Text.literal(text.getString()).formatted(Formatting.RED); } keyBindButton.setMessage(text); macro.setKey(key); diff --git a/src/main/java/tools/redstone/redstonetools/macros/gui/widget/commandlist/CommandEntry.java b/src/main/java/tools/redstone/redstonetools/macros/gui/widget/commandlist/CommandEntry.java deleted file mode 100644 index 5258f904..00000000 --- a/src/main/java/tools/redstone/redstonetools/macros/gui/widget/commandlist/CommandEntry.java +++ /dev/null @@ -1,118 +0,0 @@ -package tools.redstone.redstonetools.macros.gui.widget.commandlist; - -import net.minecraft.client.gui.DrawContext; -import tools.redstone.redstonetools.macros.gui.MacroCommandSuggestor; -import tools.redstone.redstonetools.macros.gui.widget.IconButtonWidget; -import net.minecraft.client.MinecraftClient; -import net.minecraft.client.gui.widget.ButtonWidget; -import net.minecraft.client.gui.widget.EntryListWidget; -import net.minecraft.client.gui.widget.TextFieldWidget; -import net.minecraft.client.util.math.MatrixStack; -import net.minecraft.text.Text; - -public class CommandEntry extends EntryListWidget.Entry { - - - protected CommandListWidget owner; - - public final TextFieldWidget command; - protected final ButtonWidget deleteButton; - - - public CommandEntry(MinecraftClient client, CommandListWidget owner, String text) { - this.owner = owner; - - command = new TextFieldWidget(client.textRenderer, 0, 0, 300, 20, Text.of("")); - command.setMaxLength(255); - command.setText(text); - - deleteButton = new IconButtonWidget(IconButtonWidget.CROSS_ICON,0, 0, 20, 20, Text.of(""), (button) -> { - this.owner.removeCommand(this); - }); - - MacroCommandSuggestor commandMacroCommandSuggestor = new MacroCommandSuggestor(client, owner.getParent(), command,client.textRenderer,true,false, 0,0,0); - commandMacroCommandSuggestor.setWindowActive(false); - commandMacroCommandSuggestor.refresh(); - commandMacroCommandSuggestor.close(); - } - - - @Override - public void render(MatrixStack matrices, int index, int y, int x, int entryWidth, int entryHeight, int mouseX, int mouseY, boolean hovered, float tickDelta) { - command.x = owner.getParent().width/2-owner.getWidth()/2+5; - command.y = y; - command.render(matrices,mouseX,mouseY,tickDelta); - - - deleteButton.x = command.x + command.getWidth()+5; - deleteButton.y = y; - deleteButton.render(matrices,mouseX,mouseY,tickDelta); - - if (edit) { - edit = false; - owner.getParent().editCommandField(command); - } - } - - public void tick() { - command.tick(); - } - private boolean edit = false; - - public void setFocused(boolean focused){ - command.setTextFieldFocused(focused); - if (focused){ - owner.centerScrollOn(this); - edit = true; - } - owner.focusOn(this); - } - - @Override - public void render(DrawContext context, int index, int y, int x, int entryWidth, int entryHeight, int mouseX, int mouseY, boolean hovered, float tickDelta) { - return; - } - - protected String getText() { - return command.getText(); - } - - public void setOwner(CommandListWidget owner) { - this.owner = owner; - } - - @Override - public boolean mouseClicked(double mouseX, double mouseY, int button) { - if (command.mouseClicked(mouseX,mouseY,button)) { - owner.centerScrollOn(this); - edit = true; - return true; - } - deleteButton.mouseClicked(mouseX,mouseY,button); - - return super.mouseClicked(mouseX, mouseY, button); - } - - @Override - public boolean charTyped(char chr, int modifiers) { - if (command.isFocused()) return command.charTyped(chr,modifiers); - - return super.charTyped(chr, modifiers); - } - - @Override - public boolean keyPressed(int keyCode, int scanCode, int modifiers) { - if (command.isFocused()) { - return command.keyPressed(keyCode, scanCode, modifiers); - } - - return super.keyPressed(keyCode, scanCode, modifiers); - } - - @Override - public boolean keyReleased(int keyCode, int scanCode, int modifiers) { - if (command.isFocused()) return command.keyReleased(keyCode, scanCode, modifiers); - - return super.keyReleased(keyCode, scanCode, modifiers); - } -} diff --git a/src/main/java/tools/redstone/redstonetools/macros/gui/widget/commandlist/CommandEntryPlaceHolder.java b/src/main/java/tools/redstone/redstonetools/macros/gui/widget/commandlist/CommandEntryPlaceHolder.java index ac8103de..cb300a91 100644 --- a/src/main/java/tools/redstone/redstonetools/macros/gui/widget/commandlist/CommandEntryPlaceHolder.java +++ b/src/main/java/tools/redstone/redstonetools/macros/gui/widget/commandlist/CommandEntryPlaceHolder.java @@ -1,23 +1,23 @@ package tools.redstone.redstonetools.macros.gui.widget.commandlist; import net.minecraft.client.MinecraftClient; -import net.minecraft.client.util.math.MatrixStack; +import net.minecraft.client.gui.DrawContext; +import tools.redstone.redstonetools.macros.gui.widget.commandlist.CommandListWidget.CommandEntry; -public class CommandEntryPlaceHolder extends CommandEntry{ +public class CommandEntryPlaceHolder extends CommandEntry { public CommandEntryPlaceHolder(MinecraftClient client, CommandListWidget owner, String text) { super(client, owner, text); super.deleteButton.visible = false; } - @Override - public void render(MatrixStack matrices, int index, int y, int x, int entryWidth, int entryHeight, int mouseX, int mouseY, boolean hovered, float tickDelta) { + public void render(DrawContext context, int index, int y, int x, int entryWidth, int entryHeight, int mouseX, int mouseY, boolean hovered, float tickDelta) { command.setSuggestion("Add new command"); if (!super.command.getText().isEmpty()) { super.owner.addCommandFromPlaceHolder(command.getText(),this); command.setText(""); } - super.render(matrices, index, y, x, entryWidth, entryHeight, mouseX, mouseY, hovered, tickDelta); + super.render(context, index, y, x, entryWidth, entryHeight, mouseX, mouseY, hovered, tickDelta); } } diff --git a/src/main/java/tools/redstone/redstonetools/macros/gui/widget/commandlist/CommandListWidget.java b/src/main/java/tools/redstone/redstonetools/macros/gui/widget/commandlist/CommandListWidget.java index a62653b3..e855aa4f 100644 --- a/src/main/java/tools/redstone/redstonetools/macros/gui/widget/commandlist/CommandListWidget.java +++ b/src/main/java/tools/redstone/redstonetools/macros/gui/widget/commandlist/CommandListWidget.java @@ -1,19 +1,25 @@ package tools.redstone.redstonetools.macros.gui.widget.commandlist; +import net.minecraft.client.gui.DrawContext; +import net.minecraft.client.gui.widget.ButtonWidget; +import net.minecraft.client.gui.widget.TextFieldWidget; +import net.minecraft.text.Text; +import tools.redstone.redstonetools.macros.gui.MacroCommandSuggestor; import tools.redstone.redstonetools.macros.gui.screen.MacroEditScreen; import net.minecraft.client.MinecraftClient; import net.minecraft.client.gui.screen.narration.NarrationMessageBuilder; import net.minecraft.client.gui.widget.EntryListWidget; +import tools.redstone.redstonetools.macros.gui.widget.IconButtonWidget; import java.util.ArrayList; import java.util.List; -public class CommandListWidget extends EntryListWidget { +public class CommandListWidget extends EntryListWidget { private final MacroEditScreen parent; - public CommandListWidget(MinecraftClient client, MacroEditScreen parent, int width, int height, int top, int bottom, int itemHeight) { - super(client, width, height, top, bottom, itemHeight); + public CommandListWidget(MinecraftClient client, MacroEditScreen parent, int width, int height, int y, int itemHeight) { + super(client, width, height, y, itemHeight); this.parent = parent; addEntry(new CommandEntryPlaceHolder(client,this,"")); } @@ -27,7 +33,7 @@ public void tick() { public CommandEntry addCommand(String command) { - CommandEntry entry = new CommandEntry(client,this,command); + CommandEntry entry = new CommandEntry(client, this, command); List entries = children(); entries.add(entries.size()-1,entry); @@ -39,8 +45,8 @@ protected void addCommandFromPlaceHolder(String command,CommandEntryPlaceHolder CommandEntry entry = addCommand(command); placeHolder.setFocused(false); - entry.command.x = placeHolder.command.x; - entry.command.y = placeHolder.command.y; + entry.command.setX(placeHolder.command.getX()); + entry.command.setY(placeHolder.command.getY()); entry.setFocused(true); } @@ -123,5 +129,108 @@ public int getWidth() { } @Override - public void appendNarrations(NarrationMessageBuilder builder) {} + protected void appendClickableNarrations(NarrationMessageBuilder builder) { + + } + + public static class CommandEntry extends EntryListWidget.Entry { + + protected CommandListWidget owner; + + public final TextFieldWidget command; + protected final ButtonWidget deleteButton; + + + public CommandEntry(MinecraftClient client, CommandListWidget owner, String text) { + this.owner = owner; + + command = new TextFieldWidget(client.textRenderer, 0, 0, 300, 20, Text.of("")); + command.setMaxLength(255); + command.setText(text); + + deleteButton = new IconButtonWidget(IconButtonWidget.CROSS_ICON,0, 0, 20, 20, Text.of(""), (button) -> { + this.owner.removeCommand(this); + }); + + MacroCommandSuggestor commandMacroCommandSuggestor = new MacroCommandSuggestor(client, owner.getParent(), command,client.textRenderer,true,false, 0,0,0); + commandMacroCommandSuggestor.setWindowActive(false); + commandMacroCommandSuggestor.refresh(); + commandMacroCommandSuggestor.close(); + } + + + @Override + public void render(DrawContext context, int index, int y, int x, int entryWidth, int entryHeight, int mouseX, int mouseY, boolean hovered, float tickDelta) { + command.setX(owner.getParent().width / 2 - owner.getWidth() / 2 + 5); + command.setY(y); + command.render(context,mouseX,mouseY,tickDelta); + + + deleteButton.setX(command.getX() + command.getWidth() + 5); + deleteButton.setY(y); + deleteButton.render(context,mouseX,mouseY,tickDelta); + + if (edit) { + edit = false; + owner.getParent().editCommandField(command); + } + } + + public void tick() { + command.tick(); + } + private boolean edit = false; + + public void setFocused(boolean focused){ + command.setFocused(focused); + if (focused){ + owner.centerScrollOn(this); + edit = true; + } + owner.focusOn(this); + } + + protected String getText() { + return command.getText(); + } + + public void setOwner(CommandListWidget owner) { + this.owner = owner; + } + + @Override + public boolean mouseClicked(double mouseX, double mouseY, int button) { + if (command.mouseClicked(mouseX,mouseY,button)) { + owner.centerScrollOn(this); + edit = true; + return true; + } + deleteButton.mouseClicked(mouseX,mouseY,button); + + return super.mouseClicked(mouseX, mouseY, button); + } + + @Override + public boolean charTyped(char chr, int modifiers) { + if (command.isFocused()) return command.charTyped(chr,modifiers); + + return super.charTyped(chr, modifiers); + } + + @Override + public boolean keyPressed(int keyCode, int scanCode, int modifiers) { + if (command.isFocused()) { + return command.keyPressed(keyCode, scanCode, modifiers); + } + + return super.keyPressed(keyCode, scanCode, modifiers); + } + + @Override + public boolean keyReleased(int keyCode, int scanCode, int modifiers) { + if (command.isFocused()) return command.keyReleased(keyCode, scanCode, modifiers); + + return super.keyReleased(keyCode, scanCode, modifiers); + } + } } From 781f44b737537929435c1cfdaf5f7dff10577339 Mon Sep 17 00:00:00 2001 From: rugmj Date: Tue, 2 Jan 2024 16:17:01 +0000 Subject: [PATCH 14/29] fixes mixins and player.sendChatMessage --- .../redstonetools/RedstoneToolsClient.java | 6 +++-- .../features/commands/CommandFeature.java | 2 +- .../toggleable/ToggleableFeature.java | 2 +- .../macros/actions/CommandAction.java | 2 +- .../mixin/features/AutoDustMixin.java | 9 ++++--- .../mixin/features/ItemBindMixin.java | 26 +++++++++++-------- src/main/resources/redstonetools.mixins.json | 2 +- 7 files changed, 29 insertions(+), 20 deletions(-) diff --git a/src/main/java/tools/redstone/redstonetools/RedstoneToolsClient.java b/src/main/java/tools/redstone/redstonetools/RedstoneToolsClient.java index 2207c32b..ba263e3e 100644 --- a/src/main/java/tools/redstone/redstonetools/RedstoneToolsClient.java +++ b/src/main/java/tools/redstone/redstonetools/RedstoneToolsClient.java @@ -15,7 +15,8 @@ public class RedstoneToolsClient implements ClientModInitializer { public static final String MOD_ID = "redstonetools"; - public static final String MOD_VERSION = "v" + FabricLoader.getInstance().getModContainer(MOD_ID).orElseThrow().getMetadata().getVersion().getFriendlyString(); + public static final String MOD_VERSION = "v" + FabricLoader.getInstance().getModContainer(MOD_ID).orElseThrow() + .getMetadata().getVersion().getFriendlyString(); public static final Logger LOGGER = LoggerFactory.getLogger(MOD_ID); public static final Path CONFIG_DIR = FabricLoader.getInstance().getConfigDir().resolve("redstonetools"); public static final Injector INJECTOR = Doctor.createInjector(ReflectionUtils.getModules()); @@ -32,7 +33,8 @@ public void onInitializeClient() { LOGGER.trace("Registering feature {}", feature.getClass().getName()); if (feature.requiresWorldEdit() && !DependencyLookup.WORLDEDIT_PRESENT) { - LOGGER.warn("Feature {} requires WorldEdit, but WorldEdit is not loaded. Skipping registration.", feature.getName()); + LOGGER.warn("Feature {} requires WorldEdit, but WorldEdit is not loaded. Skipping registration.", + feature.getName()); return; } feature.register(); diff --git a/src/main/java/tools/redstone/redstonetools/features/commands/CommandFeature.java b/src/main/java/tools/redstone/redstonetools/features/commands/CommandFeature.java index 0a3ee81a..12e84170 100644 --- a/src/main/java/tools/redstone/redstonetools/features/commands/CommandFeature.java +++ b/src/main/java/tools/redstone/redstonetools/features/commands/CommandFeature.java @@ -51,7 +51,7 @@ public void register() { ClientTickEvents.END_CLIENT_TICK.register(client -> { while (keyBinding.wasPressed()) { assert client.player != null; - client.player.sendMessage(Text.literal("/" + info.command())); + client.player.networkHandler.sendChatCommand(info.command()); } }); } diff --git a/src/main/java/tools/redstone/redstonetools/features/toggleable/ToggleableFeature.java b/src/main/java/tools/redstone/redstonetools/features/toggleable/ToggleableFeature.java index 2e80d9ff..b2980996 100644 --- a/src/main/java/tools/redstone/redstonetools/features/toggleable/ToggleableFeature.java +++ b/src/main/java/tools/redstone/redstonetools/features/toggleable/ToggleableFeature.java @@ -77,7 +77,7 @@ public void register() { ClientTickEvents.END_CLIENT_TICK.register(client -> { while (keyBinding.wasPressed()) { assert client.player != null; - client.player.sendChatMessage("/" + info.command()); + client.player.networkHandler.sendChatCommand(info.command()); } }); } diff --git a/src/main/java/tools/redstone/redstonetools/macros/actions/CommandAction.java b/src/main/java/tools/redstone/redstonetools/macros/actions/CommandAction.java index d44dc4c8..a07b26ed 100644 --- a/src/main/java/tools/redstone/redstonetools/macros/actions/CommandAction.java +++ b/src/main/java/tools/redstone/redstonetools/macros/actions/CommandAction.java @@ -15,7 +15,7 @@ public void run() { var player = MinecraftClient.getInstance().player; assert player != null; - player.sendChatMessage(command.startsWith("/") ? command : "/" + command); + player.networkHandler.sendChatCommand(command.startsWith("/") ? command.substring(1) : command); } @Override diff --git a/src/main/java/tools/redstone/redstonetools/mixin/features/AutoDustMixin.java b/src/main/java/tools/redstone/redstonetools/mixin/features/AutoDustMixin.java index d3fcf6bb..1d3618d8 100644 --- a/src/main/java/tools/redstone/redstonetools/mixin/features/AutoDustMixin.java +++ b/src/main/java/tools/redstone/redstonetools/mixin/features/AutoDustMixin.java @@ -35,7 +35,8 @@ private AutoDustFeature getAutoDustFeature() { } @Inject(method = "onPlaced", at = @At("TAIL")) - private void onPlaced(World world, BlockPos pos, BlockState state, LivingEntity placer, ItemStack itemStack, CallbackInfo ci) { + private void onPlaced(World world, BlockPos pos, BlockState state, LivingEntity placer, ItemStack itemStack, + CallbackInfo ci) { if (!getAutoDustFeature().isEnabled()) { return; } @@ -48,7 +49,9 @@ private void onPlaced(World world, BlockPos pos, BlockState state, LivingEntity return; } - ItemPlacementContext context = new ItemPlacementContext((PlayerEntity) placer, Hand.MAIN_HAND,new ItemStack(Items.REDSTONE),new BlockHitResult(new Vec3d(dustPos.getX(),dustPos.getY(),dustPos.getZ()), Direction.UP, dustPos,false)); - placer.method_48926().setBlockState(dustPos, Blocks.REDSTONE_WIRE.getPlacementState(context)); + ItemPlacementContext context = new ItemPlacementContext((PlayerEntity) placer, Hand.MAIN_HAND, + new ItemStack(Items.REDSTONE), new BlockHitResult( + new Vec3d(dustPos.getX(), dustPos.getY(), dustPos.getZ()), Direction.UP, dustPos, false)); + placer.getWorld().setBlockState(dustPos, Blocks.REDSTONE_WIRE.getPlacementState(context)); } } diff --git a/src/main/java/tools/redstone/redstonetools/mixin/features/ItemBindMixin.java b/src/main/java/tools/redstone/redstonetools/mixin/features/ItemBindMixin.java index ee194cba..ce3c181a 100644 --- a/src/main/java/tools/redstone/redstonetools/mixin/features/ItemBindMixin.java +++ b/src/main/java/tools/redstone/redstonetools/mixin/features/ItemBindMixin.java @@ -1,6 +1,7 @@ package tools.redstone.redstonetools.mixin.features; import net.minecraft.client.MinecraftClient; +import net.minecraft.client.network.ClientPlayNetworkHandler; import net.minecraft.client.network.ClientPlayerEntity; import net.minecraft.entity.Entity; import net.minecraft.entity.player.PlayerEntity; @@ -25,7 +26,6 @@ import static tools.redstone.redstonetools.RedstoneToolsClient.INJECTOR; - public abstract class ItemBindMixin { @Mixin(ItemStack.class) @@ -35,7 +35,8 @@ private abstract static class ItemStackMixin { public abstract @Nullable NbtCompound getNbt(); @Inject(method = "use", at = @At("HEAD"), cancellable = true) - public void checkCommandNBT(World world, PlayerEntity user, Hand hand, CallbackInfoReturnable> cir) { + public void checkCommandNBT(World world, PlayerEntity user, Hand hand, + CallbackInfoReturnable> cir) { if (tryToExecuteNBTCommand(hand, world)) { cir.setReturnValue(TypedActionResult.pass((ItemStack) ((Object) this))); } @@ -49,30 +50,33 @@ public void checkCommandNBT(ItemUsageContext context, CallbackInfoReturnable Date: Tue, 2 Jan 2024 16:48:29 +0000 Subject: [PATCH 15/29] fixes various errors --- .../features/commands/ColorCodeFeature.java | 7 ++++--- .../features/toggleable/AirPlaceFeature.java | 3 ++- .../macros/gui/screen/CommandEditScreen.java | 21 +++++++++---------- .../macros/gui/screen/MacroSelectScreen.java | 10 ++++----- .../macros/gui/widget/IconButtonWidget.java | 7 ++++--- .../gui/widget/macrolist/MacroEntry.java | 19 +++++++++-------- .../gui/widget/macrolist/MacroListWidget.java | 7 ++++--- .../redstonetools/utils/ColoredBlockType.java | 4 ++-- 8 files changed, 41 insertions(+), 37 deletions(-) diff --git a/src/main/java/tools/redstone/redstonetools/features/commands/ColorCodeFeature.java b/src/main/java/tools/redstone/redstonetools/features/commands/ColorCodeFeature.java index cbef6849..497775d8 100644 --- a/src/main/java/tools/redstone/redstonetools/features/commands/ColorCodeFeature.java +++ b/src/main/java/tools/redstone/redstonetools/features/commands/ColorCodeFeature.java @@ -1,6 +1,7 @@ package tools.redstone.redstonetools.features.commands; import com.google.auto.service.AutoService; +import com.sk89q.worldedit.function.pattern.Pattern; import tools.redstone.redstonetools.features.AbstractFeature; import tools.redstone.redstonetools.features.Feature; import tools.redstone.redstonetools.features.arguments.Argument; @@ -81,8 +82,8 @@ protected Feedback execute(ServerCommandSource source) throws CommandSyntaxExcep var playerSession = worldEdit.getSessionManager().get(wePlayer); // for each block in the selection - final World world = FabricAdapter.adapt(player.method_48926()); - try (EditSession session = worldEdit.newEditSession(FabricAdapter.adapt(player.method_48926()))) { + final World world = FabricAdapter.adapt(player.getWorld()); + try (EditSession session = worldEdit.newEditSession(FabricAdapter.adapt(player.getWorld()))) { // create mask and pattern and execute block set int blocksColored = session.replaceBlocks(selection, new Mask() { @@ -97,7 +98,7 @@ public Mask2D toMask2D() { return null; } }, - new com.sk89q.worldedit.function.pattern.Pattern() { + new Pattern() { @Override public BaseBlock applyBlock(BlockVector3 position) { return getColoredBlock(world, position, color.getValue()); diff --git a/src/main/java/tools/redstone/redstonetools/features/toggleable/AirPlaceFeature.java b/src/main/java/tools/redstone/redstonetools/features/toggleable/AirPlaceFeature.java index db0eba6a..94d7ef16 100644 --- a/src/main/java/tools/redstone/redstonetools/features/toggleable/AirPlaceFeature.java +++ b/src/main/java/tools/redstone/redstonetools/features/toggleable/AirPlaceFeature.java @@ -91,7 +91,8 @@ public static BlockHitResult findAirPlaceBlockHit(PlayerEntity playerEntity) { HitResult hitResult = findAirPlacePosition(client); if (hitResult == null) return true; - BlockPos blockPos = new BlockPos(hitResult.getPos()); + Vec3d pos = hitResult.getPos(); + BlockPos blockPos = new BlockPos((int) pos.x, (int) pos.y, (int) pos.z); BlockState blockState = ItemUtils.getUseState(client.player, ItemUtils.getMainItem(client.player), diff --git a/src/main/java/tools/redstone/redstonetools/macros/gui/screen/CommandEditScreen.java b/src/main/java/tools/redstone/redstonetools/macros/gui/screen/CommandEditScreen.java index d7eee994..90125762 100644 --- a/src/main/java/tools/redstone/redstonetools/macros/gui/screen/CommandEditScreen.java +++ b/src/main/java/tools/redstone/redstonetools/macros/gui/screen/CommandEditScreen.java @@ -1,5 +1,6 @@ package tools.redstone.redstonetools.macros.gui.screen; +import net.minecraft.client.gui.DrawContext; import tools.redstone.redstonetools.macros.gui.MacroCommandSuggestor; import net.minecraft.client.MinecraftClient; import net.minecraft.client.gui.screen.Screen; @@ -21,28 +22,27 @@ public CommandEditScreen(Screen parent, GameOptions gameOptions, TextFieldWidget super(parent, gameOptions, Text.of("")); this.commandField = commandField; client = MinecraftClient.getInstance(); - this.commandMacroCommandSuggestor = new MacroCommandSuggestor(client, parent, commandField,client.textRenderer,true,false, commandField.y -20,5,-805306368); + this.commandMacroCommandSuggestor = new MacroCommandSuggestor(client, parent, commandField,client.textRenderer,true,false, commandField.getY() -20,5,-805306368); commandField.setChangedListener((s) -> changed = true); commandMacroCommandSuggestor.setWindowActive(true); commandMacroCommandSuggestor.refresh(); } - @Override - public void render(MatrixStack matrices, int mouseX, int mouseY, float delta) { - parent.render(matrices, mouseX, mouseY, delta); + public void render(DrawContext context, int mouseX, int mouseY, float delta) { + parent.render(context, mouseX, mouseY, delta); - this.fillGradient(matrices, 0, 0, this.width, this.height, -1072689136, -804253680); + this.fillGradient(context, 0, 0, this.width, this.height, -1072689136, -804253680); - commandField.render(matrices, mouseX, mouseY, delta); + commandField.render(context, mouseX, mouseY, delta); - commandMacroCommandSuggestor.render(matrices, mouseX, mouseY); + commandMacroCommandSuggestor.render(context, mouseX, mouseY); if (changed) { commandMacroCommandSuggestor.refresh(); changed = false; } - super.render(matrices, mouseX, mouseY, delta); + super.render(context, mouseX, mouseY, delta); } @@ -60,7 +60,7 @@ public void resize(MinecraftClient client, int width, int height) { @Override public void close() { super.close(); - commandField.setTextFieldFocused(false); + commandField.setFocused(false); commandField.setChangedListener(null); commandMacroCommandSuggestor.setWindowActive(false); commandMacroCommandSuggestor.refresh(); @@ -73,14 +73,13 @@ public boolean mouseClicked(double mouseX, double mouseY, int button) { if (!commandMacroCommandSuggestor.mouseClicked(mouseX, mouseY, button)) { close(); } else { - commandField.setTextFieldFocused(true); + commandField.setFocused(true); } return false; } return super.mouseClicked(mouseX, mouseY, button); } - @Override public boolean mouseScrolled(double mouseX, double mouseY, double amount) { return commandMacroCommandSuggestor.mouseScrolled(amount); } diff --git a/src/main/java/tools/redstone/redstonetools/macros/gui/screen/MacroSelectScreen.java b/src/main/java/tools/redstone/redstonetools/macros/gui/screen/MacroSelectScreen.java index a67687d8..ce7e9382 100644 --- a/src/main/java/tools/redstone/redstonetools/macros/gui/screen/MacroSelectScreen.java +++ b/src/main/java/tools/redstone/redstonetools/macros/gui/screen/MacroSelectScreen.java @@ -1,5 +1,6 @@ package tools.redstone.redstonetools.macros.gui.screen; +import net.minecraft.client.gui.DrawContext; import tools.redstone.redstonetools.macros.gui.widget.macrolist.MacroEntry; import tools.redstone.redstonetools.macros.gui.widget.macrolist.MacroListWidget; import net.minecraft.client.gui.screen.Screen; @@ -35,13 +36,12 @@ public void init() { })); } - @Override - public void render(MatrixStack matrices, int mouseX, int mouseY, float delta) { + public void render(DrawContext context, int mouseX, int mouseY, float delta) { this.renderBackgroundTexture(0); - macroList.render(matrices, mouseX, mouseY, delta); + macroList.render(context, mouseX, mouseY, delta); - drawCenteredTextWithShadow(matrices, this.textRenderer, this.title, this.width / 2, 8, 16777215); - super.render(matrices, mouseX, mouseY, delta); + drawCenteredTextWithShadow(context, this.textRenderer, this.title, this.width / 2, 8, 16777215); + super.render(context, mouseX, mouseY, delta); } diff --git a/src/main/java/tools/redstone/redstonetools/macros/gui/widget/IconButtonWidget.java b/src/main/java/tools/redstone/redstonetools/macros/gui/widget/IconButtonWidget.java index e6e08235..af56ea36 100644 --- a/src/main/java/tools/redstone/redstonetools/macros/gui/widget/IconButtonWidget.java +++ b/src/main/java/tools/redstone/redstonetools/macros/gui/widget/IconButtonWidget.java @@ -2,6 +2,7 @@ import com.mojang.blaze3d.platform.GlStateManager; import com.mojang.blaze3d.systems.RenderSystem; +import net.minecraft.client.gui.DrawContext; import net.minecraft.client.gui.widget.ButtonWidget; import net.minecraft.client.util.math.MatrixStack; import net.minecraft.text.Text; @@ -18,8 +19,8 @@ public IconButtonWidget(Identifier texture ,int x, int y, int width, int height, this.texture = texture; } - public void renderButton(MatrixStack matrices, int mouseX, int mouseY, float delta) { - super.renderButton(matrices, mouseX, mouseY, delta); + public void renderButton(DrawContext context, int mouseX, int mouseY, float delta) { + super.renderButton(context, mouseX, mouseY, delta); RenderSystem.setShaderTexture(0, texture); @@ -29,7 +30,7 @@ public void renderButton(MatrixStack matrices, int mouseX, int mouseY, float del RenderSystem.enableBlend(); RenderSystem.defaultBlendFunc(); RenderSystem.blendFunc(GlStateManager.SrcFactor.SRC_ALPHA, GlStateManager.DstFactor.ONE_MINUS_SRC_ALPHA); - drawTexture(matrices, this.x, this.y, 0,0, 20, this.height, 20, 20); + drawTexture(context, this.getX(), this.getY(), 0,0, 20, this.height, 20, 20); } } diff --git a/src/main/java/tools/redstone/redstonetools/macros/gui/widget/macrolist/MacroEntry.java b/src/main/java/tools/redstone/redstonetools/macros/gui/widget/macrolist/MacroEntry.java index 523e4810..8426057e 100644 --- a/src/main/java/tools/redstone/redstonetools/macros/gui/widget/macrolist/MacroEntry.java +++ b/src/main/java/tools/redstone/redstonetools/macros/gui/widget/macrolist/MacroEntry.java @@ -1,5 +1,6 @@ package tools.redstone.redstonetools.macros.gui.widget.macrolist; +import net.minecraft.client.gui.DrawContext; import tools.redstone.redstonetools.macros.Macro; import tools.redstone.redstonetools.macros.gui.widget.IconButtonWidget; import net.minecraft.client.gui.screen.ConfirmScreen; @@ -34,10 +35,10 @@ public MacroEntry(Macro macro, MacroListWidget owner) { } - public void render(MatrixStack matrices, int index, int y, int x, int entryWidth, int entryHeight, int mouseX, int mouseY, boolean hovered, float tickDelta) { - renderWidget(buttonWidget,matrices,mouseX,mouseY,tickDelta,x-30,y-2); - renderWidget(editButton,matrices,mouseX,mouseY,tickDelta,x+entryWidth,y-2); - renderWidget(deleteButton,matrices,mouseX,mouseY,tickDelta,x+entryWidth+22,y-2); + public void render(DrawContext context, int index, int y, int x, int entryWidth, int entryHeight, int mouseX, int mouseY, boolean hovered, float tickDelta) { + renderWidget(buttonWidget,context,mouseX,mouseY,tickDelta,x-30,y-2); + renderWidget(editButton,context,mouseX,mouseY,tickDelta,x+entryWidth,y-2); + renderWidget(deleteButton,context,mouseX,mouseY,tickDelta,x+entryWidth+22,y-2); String text = macro.name; @@ -50,13 +51,13 @@ public void render(MatrixStack matrices, int index, int y, int x, int entryWidth } - owner.client.textRenderer.drawWithShadow(matrices, text, x, y+3,macro.enabled?16777215:8355711, true); + owner.client.textRenderer.drawWithShadow(context, text, x, y+3,macro.enabled?16777215:8355711, true); } - private void renderWidget(PressableWidget widget, MatrixStack matrices, int mouseX, int mouseY, float tickDelta, int x, int y) { - widget.x = x; - widget.y = y; - widget.render(matrices,mouseX,mouseY,tickDelta); + private void renderWidget(PressableWidget widget, DrawContext context, int mouseX, int mouseY, float tickDelta, int x, int y) { + widget.setX(x); + widget.setY(y); + widget.render(context,mouseX,mouseY,tickDelta); } public boolean mouseClicked(double mouseX, double mouseY, int button) { diff --git a/src/main/java/tools/redstone/redstonetools/macros/gui/widget/macrolist/MacroListWidget.java b/src/main/java/tools/redstone/redstonetools/macros/gui/widget/macrolist/MacroListWidget.java index 333f2bf4..73743d7a 100644 --- a/src/main/java/tools/redstone/redstonetools/macros/gui/widget/macrolist/MacroListWidget.java +++ b/src/main/java/tools/redstone/redstonetools/macros/gui/widget/macrolist/MacroListWidget.java @@ -1,5 +1,6 @@ package tools.redstone.redstonetools.macros.gui.widget.macrolist; +import net.minecraft.client.gui.DrawContext; import tools.redstone.redstonetools.macros.Macro; import tools.redstone.redstonetools.macros.MacroManager; import tools.redstone.redstonetools.macros.gui.screen.MacroSelectScreen; @@ -48,11 +49,11 @@ protected int getScrollbarPositionX() { } - protected void renderBackground(MatrixStack matrices) { - parent.renderBackground(matrices); + protected void renderBackground(DrawContext context, int mouseX, int mouseY, float delta) { + parent.renderBackground(context, mouseX, mouseY, delta); } - protected boolean isFocused() { + public boolean isFocused() { return parent.getFocused() == this; } diff --git a/src/main/java/tools/redstone/redstonetools/utils/ColoredBlockType.java b/src/main/java/tools/redstone/redstonetools/utils/ColoredBlockType.java index c8b14d90..0279defb 100644 --- a/src/main/java/tools/redstone/redstonetools/utils/ColoredBlockType.java +++ b/src/main/java/tools/redstone/redstonetools/utils/ColoredBlockType.java @@ -1,7 +1,7 @@ package tools.redstone.redstonetools.utils; import net.minecraft.block.Block; -import net.minecraft.registry.Registry; +import net.minecraft.registry.Registries; import net.minecraft.util.Identifier; public enum ColoredBlockType { @@ -34,6 +34,6 @@ public String toBlockId() { } public Block toBlock() { - return Registry.BLOCK.get(Identifier.tryParse(toBlockId())); + return Registries.BLOCK.get(Identifier.tryParse(toBlockId())); } } From cc6724b4e2d96b47e7987ba40f65d38b82159bb1 Mon Sep 17 00:00:00 2001 From: Quie_ Date: Wed, 3 Jan 2024 22:55:57 -0800 Subject: [PATCH 16/29] Fixed all the GUI errors --- .../macros/gui/screen/CommandEditScreen.java | 8 +++--- .../macros/gui/screen/MacroEditScreen.java | 26 +++++++++---------- .../macros/gui/screen/MacroSelectScreen.java | 20 +++++++------- .../macros/gui/widget/IconButtonWidget.java | 9 +++---- .../widget/commandlist/CommandListWidget.java | 21 ++++++++------- .../gui/widget/macrolist/MacroEntry.java | 22 +++++++--------- .../gui/widget/macrolist/MacroListWidget.java | 7 +++-- .../mixin/features/ItemBindMixin.java | 25 ++++++++---------- .../mixin/macros/AddMacroButtonMixin.java | 5 ++-- 9 files changed, 69 insertions(+), 74 deletions(-) diff --git a/src/main/java/tools/redstone/redstonetools/macros/gui/screen/CommandEditScreen.java b/src/main/java/tools/redstone/redstonetools/macros/gui/screen/CommandEditScreen.java index 90125762..5031ce25 100644 --- a/src/main/java/tools/redstone/redstonetools/macros/gui/screen/CommandEditScreen.java +++ b/src/main/java/tools/redstone/redstonetools/macros/gui/screen/CommandEditScreen.java @@ -1,15 +1,14 @@ package tools.redstone.redstonetools.macros.gui.screen; -import net.minecraft.client.gui.DrawContext; -import tools.redstone.redstonetools.macros.gui.MacroCommandSuggestor; import net.minecraft.client.MinecraftClient; +import net.minecraft.client.gui.DrawContext; import net.minecraft.client.gui.screen.Screen; import net.minecraft.client.gui.screen.option.GameOptionsScreen; import net.minecraft.client.gui.widget.TextFieldWidget; import net.minecraft.client.option.GameOptions; import net.minecraft.client.util.InputUtil; -import net.minecraft.client.util.math.MatrixStack; import net.minecraft.text.Text; +import tools.redstone.redstonetools.macros.gui.MacroCommandSuggestor; public class CommandEditScreen extends GameOptionsScreen { @@ -32,7 +31,7 @@ public CommandEditScreen(Screen parent, GameOptions gameOptions, TextFieldWidget public void render(DrawContext context, int mouseX, int mouseY, float delta) { parent.render(context, mouseX, mouseY, delta); - this.fillGradient(context, 0, 0, this.width, this.height, -1072689136, -804253680); + //this.fillGradient(context, 0, 0, this.width, this.height, -1072689136, -804253680); commandField.render(context, mouseX, mouseY, delta); @@ -49,7 +48,6 @@ public void render(DrawContext context, int mouseX, int mouseY, float delta) { @Override public void tick() { super.tick(); - commandField.tick(); } @Override diff --git a/src/main/java/tools/redstone/redstonetools/macros/gui/screen/MacroEditScreen.java b/src/main/java/tools/redstone/redstonetools/macros/gui/screen/MacroEditScreen.java index 0cdbb8cb..20682157 100644 --- a/src/main/java/tools/redstone/redstonetools/macros/gui/screen/MacroEditScreen.java +++ b/src/main/java/tools/redstone/redstonetools/macros/gui/screen/MacroEditScreen.java @@ -59,7 +59,7 @@ public void init() { nameField = new TextFieldWidget(this.textRenderer, this.width / 2 - 100, 22, 200, 20, Text.of("")); nameField.setText(macro.name.trim()); - doneButton = this.addDrawableChild(new ButtonWidget(this.width / 2 - 100, this.height / 4 + 144 + 5, 98, 20, Text.of("Done"), (button) -> { + doneButton = this.addDrawableChild(ButtonWidget.builder(Text.of("Done"), (button) -> { String name = nameField.getText().trim(); if (name.isEmpty()) return; @@ -71,7 +71,7 @@ public void init() { INJECTOR.getInstance(MacroManager.class).saveChanges(); client.setScreen(parent); - })); + }).dimensions(this.width / 2 - 100, this.height / 4 + 144 + 5, 98, 20).build()); doneButton.active = canClickDone(); nameField.setChangedListener(s -> { @@ -81,19 +81,19 @@ public void init() { addSelectableChild(nameField); - this.addDrawableChild(new ButtonWidget(this.width / 2 + 2, this.height / 4 + 144 + 5, 98, 20, ScreenTexts.CANCEL, (button) -> { + this.addDrawableChild(ButtonWidget.builder(ScreenTexts.CANCEL, (button) -> { close(); - })); + }).dimensions(this.width / 2 + 2, this.height / 4 + 144 + 5, 98, 20).build()); Key keyCode = macro.getKey(); Text text = keyCode.getLocalizedText(); if (keyCode == InputUtil.UNKNOWN_KEY) text = Text.of(""); if ( KeyBindingUtils.isKeyAlreadyBound(keyCode) ) { text = Text.literal(text.getString()).formatted(Formatting.RED); } - keyBindButton = new ButtonWidget(this.width / 2 + 26, 55, 75, 20, text, (button) -> { + keyBindButton = ButtonWidget.builder(text, (button) -> { detectingKeycodeKey = true; keyBindButton.setMessage((Text.literal("> ")).append(keyBindButton.getMessage().copy().formatted(Formatting.YELLOW)).append(" <").formatted(Formatting.YELLOW)); - }); + }).dimensions(this.width / 2 + 26, 55, 75, 20).build(); if (detectingKeycodeKey) keyBindButton.onPress(); this.addDrawableChild(keyBindButton); @@ -106,8 +106,8 @@ public void init() { scrollAmount = commandList.getScrollAmount(); } - commandList = new CommandListWidget(client, this, widgetWidth, height, 85, this.height / 4 + 144 + 5 - 10, 24); - commandList.setLeftPos(width / 2 - widgetWidth / 2); + commandList = new CommandListWidget(client, this, widgetWidth, height, 85, 24); + //commandList.setLeftPos(width / 2 - widgetWidth / 2); if (entries != null) { @@ -139,13 +139,13 @@ public void render(DrawContext context, int mouseX, int mouseY, float delta) { mouseY = -1; } - this.renderBackgroundTexture(0); + this.renderBackgroundTexture(context); commandList.render(context, mouseX, mouseY, delta); super.render(context, mouseX, mouseY, delta); - drawCenteredTextWithShadow(context, this.textRenderer, this.title, this.width / 2, 8, 16777215); + context.drawCenteredTextWithShadow(this.textRenderer, this.title, this.width / 2, 8, 16777215); - drawCenteredTextWithShadow(context, this.textRenderer, "Key Bind", width / 2 - (99 - textRenderer.getWidth("Key Bind") / 2), 55 + textRenderer.fontHeight / 2, 16777215); + context.drawCenteredTextWithShadow(this.textRenderer, "Key Bind", width / 2 - (99 - textRenderer.getWidth("Key Bind") / 2), 55 + textRenderer.fontHeight / 2, 16777215); nameField.render(context, mouseX, mouseY, delta); if (nameField.getText().isEmpty() && !nameField.isFocused()) { @@ -157,8 +157,8 @@ public void render(DrawContext context, int mouseX, int mouseY, float delta) { @Override public void tick() { - nameField.tick(); - commandList.tick(); + //nameField.tick(); + //commandList.tick(); super.tick(); } diff --git a/src/main/java/tools/redstone/redstonetools/macros/gui/screen/MacroSelectScreen.java b/src/main/java/tools/redstone/redstonetools/macros/gui/screen/MacroSelectScreen.java index ce7e9382..4275c7f1 100644 --- a/src/main/java/tools/redstone/redstonetools/macros/gui/screen/MacroSelectScreen.java +++ b/src/main/java/tools/redstone/redstonetools/macros/gui/screen/MacroSelectScreen.java @@ -1,15 +1,14 @@ package tools.redstone.redstonetools.macros.gui.screen; import net.minecraft.client.gui.DrawContext; -import tools.redstone.redstonetools.macros.gui.widget.macrolist.MacroEntry; -import tools.redstone.redstonetools.macros.gui.widget.macrolist.MacroListWidget; import net.minecraft.client.gui.screen.Screen; import net.minecraft.client.gui.screen.option.GameOptionsScreen; import net.minecraft.client.gui.widget.ButtonWidget; import net.minecraft.client.option.GameOptions; -import net.minecraft.client.util.math.MatrixStack; import net.minecraft.screen.ScreenTexts; import net.minecraft.text.Text; +import tools.redstone.redstonetools.macros.gui.widget.macrolist.MacroEntry; +import tools.redstone.redstonetools.macros.gui.widget.macrolist.MacroListWidget; public class MacroSelectScreen extends GameOptionsScreen { @@ -27,20 +26,23 @@ public void init() { this.macroList = new MacroListWidget(this,client); this.addSelectableChild(this.macroList); - this.addDrawableChild(new ButtonWidget(this.width / 2 +1, this.height - 29, 150, 20, Text.of("Create New..."), (button) -> { + ButtonWidget buttonWidget = ButtonWidget.builder(Text.of("Create New..."), (button) -> { this.client.setScreen(new MacroEditScreen(this,gameOptions,Text.of("New Macro"), macroList)); - })); + }).dimensions(this.width / 2 +1, this.height - 29, 150, 20).build(); + this.addDrawableChild(buttonWidget); - this.addDrawableChild(new ButtonWidget(this.width / 2 - 151, this.height - 29, 150, 20, ScreenTexts.DONE, (button) -> { + buttonWidget = ButtonWidget.builder(ScreenTexts.DONE, (button) -> { this.client.setScreen(this.parent); - })); + }).dimensions(this.width / 2 - 151, this.height - 29, 150, 20).build(); + + this.addDrawableChild(buttonWidget); } public void render(DrawContext context, int mouseX, int mouseY, float delta) { - this.renderBackgroundTexture(0); + this.renderBackgroundTexture(context); macroList.render(context, mouseX, mouseY, delta); - drawCenteredTextWithShadow(context, this.textRenderer, this.title, this.width / 2, 8, 16777215); + context.drawCenteredTextWithShadow(this.textRenderer, this.title, this.width / 2, 8, 16777215); super.render(context, mouseX, mouseY, delta); } diff --git a/src/main/java/tools/redstone/redstonetools/macros/gui/widget/IconButtonWidget.java b/src/main/java/tools/redstone/redstonetools/macros/gui/widget/IconButtonWidget.java index af56ea36..db1038aa 100644 --- a/src/main/java/tools/redstone/redstonetools/macros/gui/widget/IconButtonWidget.java +++ b/src/main/java/tools/redstone/redstonetools/macros/gui/widget/IconButtonWidget.java @@ -4,7 +4,6 @@ import com.mojang.blaze3d.systems.RenderSystem; import net.minecraft.client.gui.DrawContext; import net.minecraft.client.gui.widget.ButtonWidget; -import net.minecraft.client.util.math.MatrixStack; import net.minecraft.text.Text; import net.minecraft.util.Identifier; @@ -14,13 +13,13 @@ public class IconButtonWidget extends ButtonWidget { public static Identifier PENCIL_ICON = new Identifier("redstonetools","gui/pencil.png"); private final Identifier texture; - public IconButtonWidget(Identifier texture ,int x, int y, int width, int height, Text message, PressAction onPress) { - super(x, y, width, height, message, onPress); + public IconButtonWidget(Identifier texture ,int x, int y, int width, int height, Text message, PressAction onPress, NarrationSupplier narrationSupplier) { + super(x, y, width, height, message, onPress, narrationSupplier); this.texture = texture; } public void renderButton(DrawContext context, int mouseX, int mouseY, float delta) { - super.renderButton(context, mouseX, mouseY, delta); + super.renderWidget(context, mouseX, mouseY, delta); RenderSystem.setShaderTexture(0, texture); @@ -30,7 +29,7 @@ public void renderButton(DrawContext context, int mouseX, int mouseY, float delt RenderSystem.enableBlend(); RenderSystem.defaultBlendFunc(); RenderSystem.blendFunc(GlStateManager.SrcFactor.SRC_ALPHA, GlStateManager.DstFactor.ONE_MINUS_SRC_ALPHA); - drawTexture(context, this.getX(), this.getY(), 0,0, 20, this.height, 20, 20); + context.drawGuiTexture(this.texture,this.getX(), this.getY(), 0,0, 20, this.height, 20, 20); } } diff --git a/src/main/java/tools/redstone/redstonetools/macros/gui/widget/commandlist/CommandListWidget.java b/src/main/java/tools/redstone/redstonetools/macros/gui/widget/commandlist/CommandListWidget.java index e855aa4f..c5e1b05a 100644 --- a/src/main/java/tools/redstone/redstonetools/macros/gui/widget/commandlist/CommandListWidget.java +++ b/src/main/java/tools/redstone/redstonetools/macros/gui/widget/commandlist/CommandListWidget.java @@ -24,11 +24,11 @@ public CommandListWidget(MinecraftClient client, MacroEditScreen parent, int wid addEntry(new CommandEntryPlaceHolder(client,this,"")); } - public void tick() { - for (CommandEntry entry : children()) { - entry.tick(); - } - } +// public void tick() { +// for (CommandEntry entry : children()) { +// entry.tick(); +// } +// } @@ -148,9 +148,10 @@ public CommandEntry(MinecraftClient client, CommandListWidget owner, String text command.setMaxLength(255); command.setText(text); - deleteButton = new IconButtonWidget(IconButtonWidget.CROSS_ICON,0, 0, 20, 20, Text.of(""), (button) -> { + + deleteButton = IconButtonWidget.builder(Text.of(""), (button) -> { this.owner.removeCommand(this); - }); + }).dimensions(0, 0, 20, 20).build(); MacroCommandSuggestor commandMacroCommandSuggestor = new MacroCommandSuggestor(client, owner.getParent(), command,client.textRenderer,true,false, 0,0,0); commandMacroCommandSuggestor.setWindowActive(false); @@ -176,9 +177,9 @@ public void render(DrawContext context, int index, int y, int x, int entryWidth, } } - public void tick() { - command.tick(); - } +// public void tick() { +// command.tick(); +// } private boolean edit = false; public void setFocused(boolean focused){ diff --git a/src/main/java/tools/redstone/redstonetools/macros/gui/widget/macrolist/MacroEntry.java b/src/main/java/tools/redstone/redstonetools/macros/gui/widget/macrolist/MacroEntry.java index 8426057e..d59750b4 100644 --- a/src/main/java/tools/redstone/redstonetools/macros/gui/widget/macrolist/MacroEntry.java +++ b/src/main/java/tools/redstone/redstonetools/macros/gui/widget/macrolist/MacroEntry.java @@ -1,15 +1,13 @@ package tools.redstone.redstonetools.macros.gui.widget.macrolist; import net.minecraft.client.gui.DrawContext; -import tools.redstone.redstonetools.macros.Macro; -import tools.redstone.redstonetools.macros.gui.widget.IconButtonWidget; import net.minecraft.client.gui.screen.ConfirmScreen; import net.minecraft.client.gui.widget.*; import net.minecraft.client.sound.PositionedSoundInstance; -import net.minecraft.client.util.math.MatrixStack; import net.minecraft.sound.SoundEvents; import net.minecraft.text.Text; -import net.minecraft.text.TranslatableTextContent; +import tools.redstone.redstonetools.macros.Macro; +import tools.redstone.redstonetools.macros.gui.widget.IconButtonWidget; public class MacroEntry extends AlwaysSelectedEntryListWidget.Entry{ @@ -25,13 +23,14 @@ public MacroEntry(Macro macro, MacroListWidget owner) { this.macro = macro; this.owner = owner; - buttonWidget = new CheckboxWidget(0, 0, 20, 20, null, macro.enabled, false); - deleteButton = new IconButtonWidget(IconButtonWidget.CROSS_ICON,0, 0, 20, 20 ,Text.of(""), (button) -> { + buttonWidget = CheckboxWidget.builder(null, null).build(); + buttonWidget.setDimensionsAndPosition(20,20,0,0); + deleteButton = IconButtonWidget.builder(Text.of(""), (button) -> { deleteIfConfirmed(); - }); - editButton = new IconButtonWidget(IconButtonWidget.PENCIL_ICON,0, 0, 20, 20, Text.of(""), (button) -> { + }).dimensions(0, 0, 20, 20).build(); + editButton = IconButtonWidget.builder(Text.of(""), (button) -> { owner.parent.openEditScreen(this); - }); + }).dimensions(0, 0, 20, 20).build(); } @@ -50,8 +49,7 @@ public void render(DrawContext context, int index, int y, int x, int entryWidth, text += "..."; } - - owner.client.textRenderer.drawWithShadow(context, text, x, y+3,macro.enabled?16777215:8355711, true); + context.drawTextWithShadow(owner.client.textRenderer,text,x,y+3,macro.enabled?16777215:8355711); } private void renderWidget(PressableWidget widget, DrawContext context, int mouseX, int mouseY, float tickDelta, int x, int y) { @@ -95,7 +93,7 @@ private void onPressed() { } public Text getNarration() { - return new TranslatableTextContent("narrator.select"); + return Text.translatable("narrator.select"); } diff --git a/src/main/java/tools/redstone/redstonetools/macros/gui/widget/macrolist/MacroListWidget.java b/src/main/java/tools/redstone/redstonetools/macros/gui/widget/macrolist/MacroListWidget.java index 73743d7a..477f2873 100644 --- a/src/main/java/tools/redstone/redstonetools/macros/gui/widget/macrolist/MacroListWidget.java +++ b/src/main/java/tools/redstone/redstonetools/macros/gui/widget/macrolist/MacroListWidget.java @@ -1,12 +1,11 @@ package tools.redstone.redstonetools.macros.gui.widget.macrolist; +import net.minecraft.client.MinecraftClient; import net.minecraft.client.gui.DrawContext; +import net.minecraft.client.gui.widget.AlwaysSelectedEntryListWidget; import tools.redstone.redstonetools.macros.Macro; import tools.redstone.redstonetools.macros.MacroManager; import tools.redstone.redstonetools.macros.gui.screen.MacroSelectScreen; -import net.minecraft.client.MinecraftClient; -import net.minecraft.client.gui.widget.AlwaysSelectedEntryListWidget; -import net.minecraft.client.util.math.MatrixStack; import static tools.redstone.redstonetools.RedstoneToolsClient.INJECTOR; @@ -19,7 +18,7 @@ public class MacroListWidget extends AlwaysSelectedEntryListWidget { public MacroListWidget(MacroSelectScreen parent, MinecraftClient client) { - super(client, parent.width, parent.height, 20, parent.height - 42, 20); + super(client, parent.width, parent.height, 20, 20); this.parent = parent; this.client = client; diff --git a/src/main/java/tools/redstone/redstonetools/mixin/features/ItemBindMixin.java b/src/main/java/tools/redstone/redstonetools/mixin/features/ItemBindMixin.java index ce3c181a..085a813c 100644 --- a/src/main/java/tools/redstone/redstonetools/mixin/features/ItemBindMixin.java +++ b/src/main/java/tools/redstone/redstonetools/mixin/features/ItemBindMixin.java @@ -2,7 +2,6 @@ import net.minecraft.client.MinecraftClient; import net.minecraft.client.network.ClientPlayNetworkHandler; -import net.minecraft.client.network.ClientPlayerEntity; import net.minecraft.entity.Entity; import net.minecraft.entity.player.PlayerEntity; import net.minecraft.item.ItemStack; @@ -26,6 +25,7 @@ import static tools.redstone.redstonetools.RedstoneToolsClient.INJECTOR; + public abstract class ItemBindMixin { @Mixin(ItemStack.class) @@ -35,8 +35,7 @@ private abstract static class ItemStackMixin { public abstract @Nullable NbtCompound getNbt(); @Inject(method = "use", at = @At("HEAD"), cancellable = true) - public void checkCommandNBT(World world, PlayerEntity user, Hand hand, - CallbackInfoReturnable> cir) { + public void checkCommandNBT(World world, PlayerEntity user, Hand hand, CallbackInfoReturnable> cir) { if (tryToExecuteNBTCommand(hand, world)) { cir.setReturnValue(TypedActionResult.pass((ItemStack) ((Object) this))); } @@ -50,33 +49,31 @@ public void checkCommandNBT(ItemUsageContext context, CallbackInfoReturnable { + ButtonWidget buttonWidget = ButtonWidget.builder(Text.of("Macros..."), (button) -> { this.client.setScreen(new MacroSelectScreen(this,super.gameOptions,Text.of("Macros"))); - })); + }).dimensions(this.width / 2 + 5, this.height / 6 + 36, 150, 20).build(); + this.addDrawableChild(buttonWidget); } } From 3ea9fb7af0c31496ec1f02fce998bbafc1e6a4c2 Mon Sep 17 00:00:00 2001 From: rugmj Date: Thu, 4 Jan 2024 12:25:52 +0000 Subject: [PATCH 17/29] reverts itembindmixin --- .../redstonetools/mixin/features/ItemBindMixin.java | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/main/java/tools/redstone/redstonetools/mixin/features/ItemBindMixin.java b/src/main/java/tools/redstone/redstonetools/mixin/features/ItemBindMixin.java index 085a813c..0cad09fd 100644 --- a/src/main/java/tools/redstone/redstonetools/mixin/features/ItemBindMixin.java +++ b/src/main/java/tools/redstone/redstonetools/mixin/features/ItemBindMixin.java @@ -53,7 +53,7 @@ private boolean tryToExecuteNBTCommand(Hand hand, World world) { NbtCompound nbt = getNbt(); if (nbt == null || !nbt.contains("command")) return false; NbtString command = (NbtString) nbt.get("command"); - MinecraftClient.getInstance().getNetworkHandler().sendChatMessage(command.asString()); + MinecraftClient.getInstance().getNetworkHandler().sendChatCommand(command.asString()); return true; } @@ -61,11 +61,11 @@ private boolean tryToExecuteNBTCommand(Hand hand, World world) { @Mixin(ClientPlayNetworkHandler.class) - private abstract static class PlayerMixin { + private abstract static class NetworkHandlerMixin { - @Inject(method = "sendChatMessage", at = @At("HEAD"), cancellable = true) + @Inject(method = "sendChatCommand", at = @At("HEAD"), cancellable = true) public void injectCommand(String message, CallbackInfo ci) { - if (!message.startsWith("/") || !ItemBindFeature.waitingForCommand) return; + if (!ItemBindFeature.waitingForCommand) return; Feedback addCommandFeedback = ItemBindFeature.addCommand(message); if (addCommandFeedback != null) { From 61cdc1de42dc6edaf913cfee878a421148e25ac7 Mon Sep 17 00:00:00 2001 From: rugmj Date: Thu, 4 Jan 2024 12:28:48 +0000 Subject: [PATCH 18/29] fixes CommandException errors --- .../redstonetools/features/commands/MinSelectionFeature.java | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/main/java/tools/redstone/redstonetools/features/commands/MinSelectionFeature.java b/src/main/java/tools/redstone/redstonetools/features/commands/MinSelectionFeature.java index c35adc29..70d9975b 100644 --- a/src/main/java/tools/redstone/redstonetools/features/commands/MinSelectionFeature.java +++ b/src/main/java/tools/redstone/redstonetools/features/commands/MinSelectionFeature.java @@ -2,6 +2,7 @@ import com.google.auto.service.AutoService; +import com.mojang.brigadier.exceptions.SimpleCommandExceptionType; import tools.redstone.redstonetools.features.AbstractFeature; import tools.redstone.redstonetools.features.Feature; import tools.redstone.redstonetools.features.feedback.Feedback; @@ -99,7 +100,7 @@ private void minimiseSelection(World selectionWorld, Region selection) try { selection.contract(changes.toArray(new BlockVector3[changes.size()])); } catch (RegionOperationException e) { - throw new net.minecraft.command.CommandException(Text.of("There was an error modifying the region.")); + throw new SimpleCommandExceptionType(Text.of("There was an error modifying the region.")).create(); } if (!finished) From ced8b64cd5925fab1eaf18897aeb27f55123851c Mon Sep 17 00:00:00 2001 From: rugmj Date: Sat, 6 Jan 2024 20:18:30 +0000 Subject: [PATCH 19/29] defines required interfaces for argument rewrite --- build.gradle | 4 +- .../redstonetools/RedstoneToolsClient.java | 16 ++++++- .../arguments/serializers/TypeSerializer.java | 44 ++++++++++++++++++- .../redstonetools/utils/ReflectionUtils.java | 41 ++++++++++------- 4 files changed, 86 insertions(+), 19 deletions(-) diff --git a/build.gradle b/build.gradle index b0c7c243..6e355a1f 100644 --- a/build.gradle +++ b/build.gradle @@ -34,6 +34,8 @@ dependencies { include implementation("rip.hippo:Doctor:1.0.1") include implementation("javax.inject:javax.inject:1") + include implementation("org.reflections:reflections:0.10.2") + // Json include implementation("javax.json:javax.json-api:1.1.4") include "org.glassfish:javax.json:1.1.4" @@ -102,4 +104,4 @@ publishing { // The repositories here will be used for publishing your artifact, not for // retrieving dependencies. } -} \ No newline at end of file +} diff --git a/src/main/java/tools/redstone/redstonetools/RedstoneToolsClient.java b/src/main/java/tools/redstone/redstonetools/RedstoneToolsClient.java index ba263e3e..2a4403b1 100644 --- a/src/main/java/tools/redstone/redstonetools/RedstoneToolsClient.java +++ b/src/main/java/tools/redstone/redstonetools/RedstoneToolsClient.java @@ -1,12 +1,23 @@ package tools.redstone.redstonetools; import net.fabricmc.api.ClientModInitializer; +import net.fabricmc.fabric.api.command.v2.ArgumentTypeRegistry; import net.fabricmc.loader.api.FabricLoader; import net.minecraft.client.MinecraftClient; +import net.minecraft.command.argument.serialize.ArgumentSerializer; +import net.minecraft.command.argument.serialize.ConstantArgumentSerializer; +import net.minecraft.util.Identifier; + +import org.reflections.Reflections; import org.slf4j.Logger; import org.slf4j.LoggerFactory; + +import com.mojang.brigadier.arguments.ArgumentType; + import rip.hippo.inject.Doctor; import rip.hippo.inject.Injector; +import tools.redstone.redstonetools.features.arguments.serializers.IntegerSerializer; +import tools.redstone.redstonetools.features.arguments.serializers.TypeSerializer; import tools.redstone.redstonetools.utils.DependencyLookup; import tools.redstone.redstonetools.utils.ReflectionUtils; @@ -20,6 +31,7 @@ public class RedstoneToolsClient implements ClientModInitializer { public static final Logger LOGGER = LoggerFactory.getLogger(MOD_ID); public static final Path CONFIG_DIR = FabricLoader.getInstance().getConfigDir().resolve("redstonetools"); public static final Injector INJECTOR = Doctor.createInjector(ReflectionUtils.getModules()); + public static final Reflections REFLECTIONS = new Reflections("tools.redstone.redstonetools"); @Override public void onInitializeClient() { @@ -29,7 +41,9 @@ public void onInitializeClient() { RedstoneToolsGameRules.register(); // Register features - ReflectionUtils.getFeatures().forEach(feature -> { + ReflectionUtils.getFeatures().forEach(feature -> + + { LOGGER.trace("Registering feature {}", feature.getClass().getName()); if (feature.requiresWorldEdit() && !DependencyLookup.WORLDEDIT_PRESENT) { diff --git a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/TypeSerializer.java b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/TypeSerializer.java index 9796c052..ab4b148a 100644 --- a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/TypeSerializer.java +++ b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/TypeSerializer.java @@ -7,9 +7,18 @@ import com.mojang.brigadier.suggestion.Suggestions; import com.mojang.brigadier.suggestion.SuggestionsBuilder; +import net.minecraft.command.argument.serialize.ArgumentSerializer; +import net.minecraft.command.argument.serialize.ArgumentSerializer.ArgumentTypeProperties; +import net.minecraft.network.PacketByteBuf; + import java.util.Collection; import java.util.concurrent.CompletableFuture; +import com.google.common.reflect.TypeToken; +import com.google.gson.JsonObject; +import com.google.gson.stream.JsonReader; +import com.google.gson.Gson; + /** * Base class for the 'wrapped' argument type. * @@ -20,7 +29,8 @@ public abstract class TypeSerializer implements ArgumentType { protected final Class clazz; - // TODO: Consider moving this constructor to enum serializer as it's the only class that uses the clazz field + // TODO: Consider moving this constructor to enum serializer as it's the only + // class that uses the clazz field protected TypeSerializer(Class clazz) { this.clazz = clazz; } @@ -37,11 +47,41 @@ public final T parse(StringReader reader) throws CommandSyntaxException { /* String Serialization */ public abstract T deserialize(StringReader reader) throws CommandSyntaxException; + public abstract T deserialize(S serialized); + public abstract S serialize(T value); /* Usage In Commands */ public abstract Collection getExamples(); - public abstract CompletableFuture listSuggestions(CommandContext context, SuggestionsBuilder builder); + + public abstract CompletableFuture listSuggestions(CommandContext context, + SuggestionsBuilder builder); + + public abstract Serializer getSerializer(); + + public static abstract class Serializer, T extends ArgumentTypeProperties> + implements ArgumentSerializer { + + public void writePacket(T properties, PacketByteBuf packetByteBuf) { + var jsonObject = new JsonObject(); + writeJson(properties, jsonObject); + packetByteBuf.writeString(jsonObject.toString()); + } + + public T fromPacket(PacketByteBuf packetByteBuf) { + String json = packetByteBuf.readString(); + TypeToken typeToken = new TypeToken<>() { + }; + var jsonReader = new JsonReader(new java.io.StringReader(json)); + return new Gson().fromJson(jsonReader, typeToken.getType()); + } + + public void writeJson(T var1, JsonObject var2) { + var gson = new Gson(); + var newObject = gson.fromJson(gson.toJson(var1), JsonObject.class); + newObject.entrySet().forEach(entry -> var2.addProperty(entry.getKey(), entry.getValue().toString())); + } + } } diff --git a/src/main/java/tools/redstone/redstonetools/utils/ReflectionUtils.java b/src/main/java/tools/redstone/redstonetools/utils/ReflectionUtils.java index ead82a6b..8c0d2f35 100644 --- a/src/main/java/tools/redstone/redstonetools/utils/ReflectionUtils.java +++ b/src/main/java/tools/redstone/redstonetools/utils/ReflectionUtils.java @@ -1,23 +1,31 @@ package tools.redstone.redstonetools.utils; +import static tools.redstone.redstonetools.RedstoneToolsClient.REFLECTIONS; + +import java.io.IOException; +import java.lang.invoke.MethodHandles; +import java.lang.reflect.Field; +import java.lang.reflect.Modifier; +import java.net.URL; +import java.util.Arrays; +import java.util.Enumeration; +import java.util.HashSet; +import java.util.List; +import java.util.Objects; +import java.util.Set; +import java.util.stream.Collectors; + import org.apache.commons.io.IOUtils; import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; import org.jetbrains.annotations.Nullable; + import rip.hippo.inject.DoctorModule; import sun.misc.Unsafe; import tools.redstone.redstonetools.features.AbstractFeature; import tools.redstone.redstonetools.features.Feature; import tools.redstone.redstonetools.features.arguments.Argument; - -import java.lang.invoke.MethodHandles; -import java.lang.reflect.Field; -import java.io.IOException; -import java.io.InputStream; -import java.lang.reflect.Modifier; -import java.net.URL; -import java.util.*; -import java.util.stream.Collectors; +import tools.redstone.redstonetools.features.arguments.serializers.TypeSerializer; public class ReflectionUtils { private static final Logger LOGGER = LogManager.getLogger(); @@ -45,11 +53,9 @@ private ReflectionUtils() { // get lookup Field field = MethodHandles.Lookup.class.getDeclaredField("IMPL_LOOKUP"); MethodHandles.publicLookup(); - INTERNAL_LOOKUP = (MethodHandles.Lookup) - unsafe.getObject( - unsafe.staticFieldBase(field), - unsafe.staticFieldOffset(field) - ); + INTERNAL_LOOKUP = (MethodHandles.Lookup) unsafe.getObject( + unsafe.staticFieldBase(field), + unsafe.staticFieldOffset(field)); } catch (Exception e) { e.printStackTrace(); throw new ExceptionInInitializerError(e); @@ -72,6 +78,10 @@ public static DoctorModule[] getModules() { return modules; } + public static Set> getAllArguments() { + return REFLECTIONS.getSubTypesOf(TypeSerializer.class); + } + public static Set getFeatures() { if (features == null) { try { @@ -128,7 +138,8 @@ public static List> getArguments(Class fe if (!Modifier.isPublic(field.getModifiers()) || !Modifier.isStatic(field.getModifiers()) || !Modifier.isFinal(field.getModifiers())) { - throw new RuntimeException("Field " + field.getName() + " of feature " + featureClass.getName() + " is not public static final"); + throw new RuntimeException("Field " + field.getName() + " of feature " + featureClass.getName() + + " is not public static final"); } try { From 10d9b82a17ea81f337571b6692003b7d98ac8c65 Mon Sep 17 00:00:00 2001 From: Quie_ Date: Wed, 10 Jan 2024 12:30:15 -0500 Subject: [PATCH 20/29] Worked on switching some Serializer classes to ArgumentType classes and adding the serializers as subclasses. --- .../redstonetools/RedstoneToolsClient.java | 9 --- .../features/arguments/Argument.java | 10 +-- .../serializers/BigIntegerArgumentType.java | 69 +++++++++++++++++++ .../serializers/BigIntegerSerializer.java | 33 --------- ...lizer.java => BlockStateArgumentType.java} | 36 ++++++++-- ...alizer.java => BrigadierArgumentType.java} | 10 ++- .../serializers/CollectionSerializer.java | 14 ++-- .../arguments/serializers/EnumSerializer.java | 4 +- ...rializer.java => GenericArgumentType.java} | 15 ++-- ...rializer.java => IntLikeArgumentType.java} | 36 ++++++++-- .../serializers/IntegerSerializer.java | 2 +- .../arguments/serializers/LongSerializer.java | 2 +- ...lizer.java => NumberBaseArgumentType.java} | 35 ++++++++-- .../serializers/NumberSerializer.java | 2 +- .../StringBrigadierSerializer.java | 2 +- .../features/commands/BaseConvertFeature.java | 2 +- .../commands/BinaryBlockReadFeature.java | 9 +-- .../redstonetools/utils/ReflectionUtils.java | 6 +- 18 files changed, 198 insertions(+), 98 deletions(-) create mode 100644 src/main/java/tools/redstone/redstonetools/features/arguments/serializers/BigIntegerArgumentType.java delete mode 100644 src/main/java/tools/redstone/redstonetools/features/arguments/serializers/BigIntegerSerializer.java rename src/main/java/tools/redstone/redstonetools/features/arguments/serializers/{BlockStateArgumentSerializer.java => BlockStateArgumentType.java} (50%) rename src/main/java/tools/redstone/redstonetools/features/arguments/serializers/{BrigadierSerializer.java => BrigadierArgumentType.java} (66%) rename src/main/java/tools/redstone/redstonetools/features/arguments/serializers/{TypeSerializer.java => GenericArgumentType.java} (94%) rename src/main/java/tools/redstone/redstonetools/features/arguments/serializers/{IntLikeSerializer.java => IntLikeArgumentType.java} (75%) rename src/main/java/tools/redstone/redstonetools/features/arguments/serializers/{NumberBaseSerializer.java => NumberBaseArgumentType.java} (64%) diff --git a/src/main/java/tools/redstone/redstonetools/RedstoneToolsClient.java b/src/main/java/tools/redstone/redstonetools/RedstoneToolsClient.java index 2a4403b1..551ad222 100644 --- a/src/main/java/tools/redstone/redstonetools/RedstoneToolsClient.java +++ b/src/main/java/tools/redstone/redstonetools/RedstoneToolsClient.java @@ -1,23 +1,14 @@ package tools.redstone.redstonetools; import net.fabricmc.api.ClientModInitializer; -import net.fabricmc.fabric.api.command.v2.ArgumentTypeRegistry; import net.fabricmc.loader.api.FabricLoader; -import net.minecraft.client.MinecraftClient; -import net.minecraft.command.argument.serialize.ArgumentSerializer; -import net.minecraft.command.argument.serialize.ConstantArgumentSerializer; -import net.minecraft.util.Identifier; import org.reflections.Reflections; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import com.mojang.brigadier.arguments.ArgumentType; - import rip.hippo.inject.Doctor; import rip.hippo.inject.Injector; -import tools.redstone.redstonetools.features.arguments.serializers.IntegerSerializer; -import tools.redstone.redstonetools.features.arguments.serializers.TypeSerializer; import tools.redstone.redstonetools.utils.DependencyLookup; import tools.redstone.redstonetools.utils.ReflectionUtils; diff --git a/src/main/java/tools/redstone/redstonetools/features/arguments/Argument.java b/src/main/java/tools/redstone/redstonetools/features/arguments/Argument.java index 683536c0..89cb76ae 100644 --- a/src/main/java/tools/redstone/redstonetools/features/arguments/Argument.java +++ b/src/main/java/tools/redstone/redstonetools/features/arguments/Argument.java @@ -1,20 +1,20 @@ package tools.redstone.redstonetools.features.arguments; -import tools.redstone.redstonetools.features.arguments.serializers.TypeSerializer; +import tools.redstone.redstonetools.features.arguments.serializers.GenericArgumentType; import com.mojang.brigadier.context.CommandContext; public class Argument { private String name; - private final TypeSerializer type; + private final GenericArgumentType type; private boolean optional = false; private volatile T value; private T defaultValue; - private Argument(TypeSerializer type) { + private Argument(GenericArgumentType type) { this.type = type; } - public static Argument ofType(TypeSerializer type) { + public static Argument ofType(GenericArgumentType type) { return new Argument<>(type); } @@ -48,7 +48,7 @@ public String getName() { return name; } - public TypeSerializer getType() { + public GenericArgumentType getType() { return type; } diff --git a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/BigIntegerArgumentType.java b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/BigIntegerArgumentType.java new file mode 100644 index 00000000..b3651c4a --- /dev/null +++ b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/BigIntegerArgumentType.java @@ -0,0 +1,69 @@ +package tools.redstone.redstonetools.features.arguments.serializers; + +import net.minecraft.command.CommandRegistryAccess; +import net.minecraft.command.argument.serialize.ArgumentSerializer; + +import java.math.BigInteger; +import java.util.Optional; + +public class BigIntegerArgumentType extends IntLikeArgumentType { + private static final BigIntegerArgumentType INSTANCE = new BigIntegerArgumentType(null, null); + + public static BigIntegerArgumentType bigInteger() { + return INSTANCE; + } + + public static BigIntegerArgumentType bigInteger(BigInteger min) { + return new BigIntegerArgumentType(min, null); + } + + public static BigIntegerArgumentType bigInteger(BigInteger min, BigInteger max) { + return new BigIntegerArgumentType(min, max); + } + + private BigIntegerArgumentType(BigInteger min, BigInteger max) { + super(BigInteger.class, min, max); + + } + + @Override + protected Optional tryParseOptional(String string, int radix) { + try { + return Optional.of(new BigInteger(string, radix)); + } catch (NumberFormatException ignored) { + return Optional.empty(); + } + } + + public static class BigIntegerSerializer extends Serializer>{ + + @Override + public ArgumentTypeProperties getArgumentTypeProperties(BigIntegerArgumentType argumentType) { + return new Properties(argumentType.max,argumentType.min); + } + + public final class Properties + implements ArgumentSerializer.ArgumentTypeProperties{ + final BigInteger max, min; + + public Properties(BigInteger max, BigInteger min) { + this.max = max; + this.min = min; + } + + @Override + public BigIntegerArgumentType createType(CommandRegistryAccess commandRegistryAccess) { + return new BigIntegerArgumentType(this.max,this.min); + } + + @Override + public ArgumentSerializer getSerializer() { + return BigIntegerSerializer.this; + } + } + } + + + + +} diff --git a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/BigIntegerSerializer.java b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/BigIntegerSerializer.java deleted file mode 100644 index 36b94bbb..00000000 --- a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/BigIntegerSerializer.java +++ /dev/null @@ -1,33 +0,0 @@ -package tools.redstone.redstonetools.features.arguments.serializers; - -import java.math.BigInteger; -import java.util.Optional; - -public class BigIntegerSerializer extends IntLikeSerializer { - private static final BigIntegerSerializer INSTANCE = new BigIntegerSerializer(null, null); - - public static BigIntegerSerializer bigInteger() { - return INSTANCE; - } - - public static BigIntegerSerializer bigInteger(BigInteger min) { - return new BigIntegerSerializer(min, null); - } - - public static BigIntegerSerializer bigInteger(BigInteger min, BigInteger max) { - return new BigIntegerSerializer(min, max); - } - - private BigIntegerSerializer(BigInteger min, BigInteger max) { - super(BigInteger.class, min, max); - } - - @Override - protected Optional tryParseOptional(String string, int radix) { - try { - return Optional.of(new BigInteger(string, radix)); - } catch (NumberFormatException ignored) { - return Optional.empty(); - } - } -} diff --git a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/BlockStateArgumentSerializer.java b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/BlockStateArgumentType.java similarity index 50% rename from src/main/java/tools/redstone/redstonetools/features/arguments/serializers/BlockStateArgumentSerializer.java rename to src/main/java/tools/redstone/redstonetools/features/arguments/serializers/BlockStateArgumentType.java index b16446ce..9ce1dbcb 100644 --- a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/BlockStateArgumentSerializer.java +++ b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/BlockStateArgumentType.java @@ -4,20 +4,20 @@ import com.mojang.brigadier.exceptions.CommandSyntaxException; import net.minecraft.command.CommandRegistryAccess; import net.minecraft.command.argument.BlockStateArgument; -import net.minecraft.command.argument.BlockStateArgumentType; +import net.minecraft.command.argument.serialize.ArgumentSerializer; import net.minecraft.registry.Registries; -public class BlockStateArgumentSerializer extends BrigadierSerializer { +public class BlockStateArgumentType extends BrigadierArgumentType { - private static BlockStateArgumentSerializer INSTANCE; + private static BlockStateArgumentType INSTANCE; - private BlockStateArgumentSerializer(CommandRegistryAccess registryAccess) { - super(BlockStateArgument.class, BlockStateArgumentType.blockState(registryAccess)); + private BlockStateArgumentType(CommandRegistryAccess registryAccess) { + super(BlockStateArgument.class, net.minecraft.command.argument.BlockStateArgumentType.blockState(registryAccess)); } - public static BlockStateArgumentSerializer blockState(CommandRegistryAccess registryAccess) { + public static BlockStateArgumentType blockState(CommandRegistryAccess registryAccess) { if (INSTANCE == null) { - INSTANCE = new BlockStateArgumentSerializer(registryAccess); + INSTANCE = new BlockStateArgumentType(registryAccess); } return INSTANCE; @@ -62,4 +62,26 @@ public String serialize(BlockStateArgument value) { return builder.toString(); } + public static class BlockStateArgumentSerializer extends Serializer>{ + + @Override + public ArgumentTypeProperties getArgumentTypeProperties(BlockStateArgumentType argumentType) { + return new Properties(); + } + + public final class Properties + implements ArgumentSerializer.ArgumentTypeProperties{ + + @Override + public BlockStateArgumentType createType(CommandRegistryAccess commandRegistryAccess) { + return new BlockStateArgumentType(commandRegistryAccess); + } + + @Override + public ArgumentSerializer getSerializer() { + return BlockStateArgumentSerializer.this; + } + } + } + } diff --git a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/BrigadierSerializer.java b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/BrigadierArgumentType.java similarity index 66% rename from src/main/java/tools/redstone/redstonetools/features/arguments/serializers/BrigadierSerializer.java rename to src/main/java/tools/redstone/redstonetools/features/arguments/serializers/BrigadierArgumentType.java index 5a2e5ba9..846a3bcf 100644 --- a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/BrigadierSerializer.java +++ b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/BrigadierArgumentType.java @@ -6,16 +6,17 @@ import com.mojang.brigadier.exceptions.CommandSyntaxException; import com.mojang.brigadier.suggestion.Suggestions; import com.mojang.brigadier.suggestion.SuggestionsBuilder; +import net.minecraft.command.argument.serialize.ArgumentSerializer; import java.util.Collection; import java.util.concurrent.CompletableFuture; -public abstract class BrigadierSerializer extends TypeSerializer { +public abstract class BrigadierArgumentType extends GenericArgumentType { // the wrapped brigadier argument type private final ArgumentType argumentType; - public BrigadierSerializer(Class clazz, ArgumentType argumentType) { + public BrigadierArgumentType(Class clazz, ArgumentType argumentType) { super(clazz); this.argumentType = argumentType; } @@ -35,4 +36,9 @@ public Collection getExamples() { return argumentType.getExamples(); } + public abstract class BrigadierSerializer extends Serializer,ArgumentSerializer.ArgumentTypeProperties>>{ + + public abstract ArgumentTypeProperties> getArgumentTypeProperties(BrigadierArgumentType argumentType); + + } } diff --git a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/CollectionSerializer.java b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/CollectionSerializer.java index c68c7c29..16bb16b7 100644 --- a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/CollectionSerializer.java +++ b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/CollectionSerializer.java @@ -18,18 +18,18 @@ * @param The collection type. */ public class CollectionSerializer> - extends TypeSerializer> + extends GenericArgumentType> { - public static CollectionSerializer> listOf(TypeSerializer element) { + public static CollectionSerializer> listOf(GenericArgumentType element) { return new CollectionSerializer<>(List.class, element, ArrayList::new); } - public static CollectionSerializer> setOf(TypeSerializer element) { + public static CollectionSerializer> setOf(GenericArgumentType element) { return new CollectionSerializer<>(Set.class, element, HashSet::new); } - final TypeSerializer elementType; + final GenericArgumentType elementType; final Function, C> collectionFactory; // cache example because @@ -39,10 +39,10 @@ public static CollectionSerializer> setOf(TypeSerializer ele @SuppressWarnings("unchecked") protected CollectionSerializer(Class clazz, - TypeSerializer elementType, + GenericArgumentType elementType, Function, C> collectionFactory) { super((Class) clazz); - this.elementType = (TypeSerializer) elementType; + this.elementType = (GenericArgumentType) elementType; this.collectionFactory = collectionFactory; // build example @@ -55,7 +55,7 @@ protected CollectionSerializer(Class clazz, this.example = b.delete(b.length() - 3, b.length()).append("]").toString(); } - public TypeSerializer getElementType() { + public GenericArgumentType getElementType() { return elementType; } diff --git a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/EnumSerializer.java b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/EnumSerializer.java index af7d354a..35315687 100644 --- a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/EnumSerializer.java +++ b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/EnumSerializer.java @@ -9,12 +9,10 @@ import java.util.Collection; import java.util.EnumSet; -import java.util.List; -import java.util.Optional; import java.util.concurrent.CompletableFuture; public abstract class EnumSerializer> - extends TypeSerializer { + extends GenericArgumentType { protected EnumSerializer(Class clazz) { super(clazz); diff --git a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/TypeSerializer.java b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/GenericArgumentType.java similarity index 94% rename from src/main/java/tools/redstone/redstonetools/features/arguments/serializers/TypeSerializer.java rename to src/main/java/tools/redstone/redstonetools/features/arguments/serializers/GenericArgumentType.java index ab4b148a..f444a1d2 100644 --- a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/TypeSerializer.java +++ b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/GenericArgumentType.java @@ -1,12 +1,15 @@ package tools.redstone.redstonetools.features.arguments.serializers; +import com.google.common.reflect.TypeToken; +import com.google.gson.Gson; +import com.google.gson.JsonObject; +import com.google.gson.stream.JsonReader; import com.mojang.brigadier.StringReader; import com.mojang.brigadier.arguments.ArgumentType; import com.mojang.brigadier.context.CommandContext; import com.mojang.brigadier.exceptions.CommandSyntaxException; import com.mojang.brigadier.suggestion.Suggestions; import com.mojang.brigadier.suggestion.SuggestionsBuilder; - import net.minecraft.command.argument.serialize.ArgumentSerializer; import net.minecraft.command.argument.serialize.ArgumentSerializer.ArgumentTypeProperties; import net.minecraft.network.PacketByteBuf; @@ -14,24 +17,19 @@ import java.util.Collection; import java.util.concurrent.CompletableFuture; -import com.google.common.reflect.TypeToken; -import com.google.gson.JsonObject; -import com.google.gson.stream.JsonReader; -import com.google.gson.Gson; - /** * Base class for the 'wrapped' argument type. * * @param The value type. * @param The serialized type. */ -public abstract class TypeSerializer implements ArgumentType { +public abstract class GenericArgumentType implements ArgumentType { protected final Class clazz; // TODO: Consider moving this constructor to enum serializer as it's the only // class that uses the clazz field - protected TypeSerializer(Class clazz) { + protected GenericArgumentType(Class clazz) { this.clazz = clazz; } @@ -58,7 +56,6 @@ public final T parse(StringReader reader) throws CommandSyntaxException { public abstract CompletableFuture listSuggestions(CommandContext context, SuggestionsBuilder builder); - public abstract Serializer getSerializer(); public static abstract class Serializer, T extends ArgumentTypeProperties> implements ArgumentSerializer { diff --git a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/IntLikeSerializer.java b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/IntLikeArgumentType.java similarity index 75% rename from src/main/java/tools/redstone/redstonetools/features/arguments/serializers/IntLikeSerializer.java rename to src/main/java/tools/redstone/redstonetools/features/arguments/serializers/IntLikeArgumentType.java index 987d7df1..58b77389 100644 --- a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/IntLikeSerializer.java +++ b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/IntLikeArgumentType.java @@ -5,6 +5,8 @@ import com.mojang.brigadier.exceptions.CommandSyntaxException; import com.mojang.brigadier.suggestion.Suggestions; import com.mojang.brigadier.suggestion.SuggestionsBuilder; +import net.minecraft.command.CommandRegistryAccess; +import net.minecraft.command.argument.serialize.ArgumentSerializer; import net.minecraft.text.Text; import tools.redstone.redstonetools.utils.NumberBase; @@ -13,13 +15,13 @@ import java.util.Optional; import java.util.concurrent.CompletableFuture; -public abstract class IntLikeSerializer> extends TypeSerializer { - private final T min; +public abstract class IntLikeArgumentType> extends GenericArgumentType { + final T min; private final boolean hasMin; - private final T max; + final T max; private final boolean hasMax; - protected IntLikeSerializer(Class clazz, T min, T max) { + protected IntLikeArgumentType(Class clazz, T min, T max) { super(clazz); this.min = min; @@ -127,4 +129,30 @@ public Collection getExamples() { public CompletableFuture listSuggestions(CommandContext context, SuggestionsBuilder builder) { return builder.buildFuture(); } + +// public static abstract class IntLikeSerializer extends Serializer, ArgumentSerializer.ArgumentTypeProperties>>{ +// +// @Override +// public ArgumentTypeProperties> getArgumentTypeProperties(IntLikeArgumentType argumentType) { +// return new Properties(argumentType.max,argumentType.min); +// } +// +// public abstract class Properties implements ArgumentTypeProperties>{ +// +// final T max, min; +// +// public Properties(T max, T min) { +// this.max = max; +// this.min = min; +// } +// +// @Override +// public abstract IntLikeArgumentType createType(CommandRegistryAccess commandRegistryAccess); +// +// @Override +// public ArgumentSerializer, ?> getSerializer() { +// return IntLikeSerializer.this; +// } +// } +// } } diff --git a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/IntegerSerializer.java b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/IntegerSerializer.java index 8a53cf08..22f53850 100644 --- a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/IntegerSerializer.java +++ b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/IntegerSerializer.java @@ -2,7 +2,7 @@ import java.util.Optional; -public class IntegerSerializer extends IntLikeSerializer { +public class IntegerSerializer extends IntLikeArgumentType { private static final IntegerSerializer INSTANCE = new IntegerSerializer(Integer.MIN_VALUE, Integer.MAX_VALUE); public static IntegerSerializer integer() { diff --git a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/LongSerializer.java b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/LongSerializer.java index 43516d84..3038e6a0 100644 --- a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/LongSerializer.java +++ b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/LongSerializer.java @@ -2,7 +2,7 @@ import java.util.Optional; -public class LongSerializer extends IntLikeSerializer { +public class LongSerializer extends IntLikeArgumentType { private static final LongSerializer INSTANCE = new LongSerializer(Long.MIN_VALUE, Long.MAX_VALUE); public static LongSerializer longArg() { diff --git a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/NumberBaseSerializer.java b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/NumberBaseArgumentType.java similarity index 64% rename from src/main/java/tools/redstone/redstonetools/features/arguments/serializers/NumberBaseSerializer.java rename to src/main/java/tools/redstone/redstonetools/features/arguments/serializers/NumberBaseArgumentType.java index 87126ee2..acace7d2 100644 --- a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/NumberBaseSerializer.java +++ b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/NumberBaseArgumentType.java @@ -5,6 +5,8 @@ import com.mojang.brigadier.exceptions.CommandSyntaxException; import com.mojang.brigadier.suggestion.Suggestions; import com.mojang.brigadier.suggestion.SuggestionsBuilder; +import net.minecraft.command.CommandRegistryAccess; +import net.minecraft.command.argument.serialize.ArgumentSerializer; import net.minecraft.text.Text; import tools.redstone.redstonetools.utils.NumberBase; @@ -12,15 +14,15 @@ import java.util.Collection; import java.util.concurrent.CompletableFuture; -public class NumberBaseSerializer extends TypeSerializer { +public class NumberBaseArgumentType extends GenericArgumentType { private static final IntegerSerializer INT_SERIALIZER = IntegerSerializer.integer(2, 36); - private static final NumberBaseSerializer INSTANCE = new NumberBaseSerializer(); + private static final NumberBaseArgumentType INSTANCE = new NumberBaseArgumentType(); - public static NumberBaseSerializer numberBase() { + public static NumberBaseArgumentType numberBase() { return INSTANCE; } - protected NumberBaseSerializer() { + protected NumberBaseArgumentType() { super(Integer.class); } @@ -72,4 +74,29 @@ public CompletableFuture listSuggestions(CommandContext cont return builder.buildFuture(); } + + public static class NumberBaseSerializer extends Serializer>{ + + @Override + public ArgumentTypeProperties getArgumentTypeProperties(NumberBaseArgumentType argumentType) { + return new Properties(); + } + + public final class Properties + implements ArgumentSerializer.ArgumentTypeProperties{ + + @Override + public NumberBaseArgumentType createType(CommandRegistryAccess commandRegistryAccess) { + return new NumberBaseArgumentType(); + } + + @Override + public ArgumentSerializer getSerializer() { + return NumberBaseSerializer.this; + } + } + + } + + } diff --git a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/NumberSerializer.java b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/NumberSerializer.java index 320eb217..a12d9744 100644 --- a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/NumberSerializer.java +++ b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/NumberSerializer.java @@ -4,7 +4,7 @@ import java.util.Optional; -public class NumberSerializer extends IntLikeSerializer { +public class NumberSerializer extends IntLikeArgumentType { private static final NumberSerializer INSTANCE = new NumberSerializer(null,null); public static NumberSerializer numberArg(){ diff --git a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/StringBrigadierSerializer.java b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/StringBrigadierSerializer.java index f5dba14b..67cb02ec 100644 --- a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/StringBrigadierSerializer.java +++ b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/StringBrigadierSerializer.java @@ -4,7 +4,7 @@ import com.mojang.brigadier.arguments.ArgumentType; import com.mojang.brigadier.exceptions.CommandSyntaxException; -public abstract class StringBrigadierSerializer extends BrigadierSerializer { +public abstract class StringBrigadierSerializer extends BrigadierArgumentType { public StringBrigadierSerializer(Class clazz, ArgumentType argumentType) { super(clazz, argumentType); diff --git a/src/main/java/tools/redstone/redstonetools/features/commands/BaseConvertFeature.java b/src/main/java/tools/redstone/redstonetools/features/commands/BaseConvertFeature.java index 818d4203..bf9a2c5c 100644 --- a/src/main/java/tools/redstone/redstonetools/features/commands/BaseConvertFeature.java +++ b/src/main/java/tools/redstone/redstonetools/features/commands/BaseConvertFeature.java @@ -9,7 +9,7 @@ import tools.redstone.redstonetools.utils.NumberArg; -import static tools.redstone.redstonetools.features.arguments.serializers.NumberBaseSerializer.numberBase; +import static tools.redstone.redstonetools.features.arguments.serializers.NumberBaseArgumentType.numberBase; import static tools.redstone.redstonetools.features.arguments.serializers.NumberSerializer.numberArg; @AutoService(AbstractFeature.class) diff --git a/src/main/java/tools/redstone/redstonetools/features/commands/BinaryBlockReadFeature.java b/src/main/java/tools/redstone/redstonetools/features/commands/BinaryBlockReadFeature.java index fdcd7b60..1ea3ff15 100644 --- a/src/main/java/tools/redstone/redstonetools/features/commands/BinaryBlockReadFeature.java +++ b/src/main/java/tools/redstone/redstonetools/features/commands/BinaryBlockReadFeature.java @@ -7,24 +7,19 @@ import tools.redstone.redstonetools.features.feedback.Feedback; import tools.redstone.redstonetools.utils.WorldEditUtils; import com.mojang.brigadier.exceptions.CommandSyntaxException; -import com.mojang.datafixers.util.Either; import com.sk89q.worldedit.math.BlockVector3; -import com.sk89q.worldedit.regions.CuboidRegion; -import com.sk89q.worldedit.regions.Region; -import net.minecraft.block.BlockState; import net.minecraft.block.Blocks; import net.minecraft.block.RedstoneLampBlock; import net.minecraft.command.argument.BlockStateArgument; import net.minecraft.server.command.ServerCommandSource; -import net.minecraft.state.property.Property; import net.minecraft.util.math.BlockPos; import java.util.Collections; -import static tools.redstone.redstonetools.features.arguments.serializers.BlockStateArgumentSerializer.blockState; +import static tools.redstone.redstonetools.features.arguments.serializers.BlockStateArgumentType.blockState; import static tools.redstone.redstonetools.features.arguments.serializers.BoolSerializer.bool; import static tools.redstone.redstonetools.features.arguments.serializers.IntegerSerializer.integer; -import static tools.redstone.redstonetools.features.arguments.serializers.NumberBaseSerializer.numberBase; +import static tools.redstone.redstonetools.features.arguments.serializers.NumberBaseArgumentType.numberBase; @AutoService(AbstractFeature.class) diff --git a/src/main/java/tools/redstone/redstonetools/utils/ReflectionUtils.java b/src/main/java/tools/redstone/redstonetools/utils/ReflectionUtils.java index 8c0d2f35..076916c7 100644 --- a/src/main/java/tools/redstone/redstonetools/utils/ReflectionUtils.java +++ b/src/main/java/tools/redstone/redstonetools/utils/ReflectionUtils.java @@ -25,7 +25,7 @@ import tools.redstone.redstonetools.features.AbstractFeature; import tools.redstone.redstonetools.features.Feature; import tools.redstone.redstonetools.features.arguments.Argument; -import tools.redstone.redstonetools.features.arguments.serializers.TypeSerializer; +import tools.redstone.redstonetools.features.arguments.serializers.GenericArgumentType; public class ReflectionUtils { private static final Logger LOGGER = LogManager.getLogger(); @@ -78,8 +78,8 @@ public static DoctorModule[] getModules() { return modules; } - public static Set> getAllArguments() { - return REFLECTIONS.getSubTypesOf(TypeSerializer.class); + public static Set> getAllArguments() { + return REFLECTIONS.getSubTypesOf(GenericArgumentType.class); } public static Set getFeatures() { From 3c4590ab1e75f40eb36f3f52f025107a6d324568 Mon Sep 17 00:00:00 2001 From: rugmj Date: Sat, 20 Jan 2024 16:48:46 +0000 Subject: [PATCH 21/29] implements the serializer for all remaining serializers and registers them to the game --- .factorypath | 22 +++++++++++ .../redstonetools/RedstoneToolsClient.java | 31 ++++++++++++++++ .../serializers/BlockColorSerializer.java | 25 +++++++++++++ .../arguments/serializers/BoolSerializer.java | 26 +++++++++++++ .../serializers/CollectionSerializer.java | 37 ++++++++++++++++--- .../ColoredBlockTypeSerializer.java | 25 +++++++++++++ .../serializers/DirectionSerializer.java | 25 +++++++++++++ .../serializers/DoubleSerializer.java | 25 +++++++++++++ .../serializers/FloatSerializer.java | 25 +++++++++++++ .../serializers/IntegerSerializer.java | 26 +++++++++++++ .../arguments/serializers/LongSerializer.java | 26 +++++++++++++ .../serializers/MacroNameSerializer.java | 28 +++++++++++++- .../serializers/NumberSerializer.java | 34 +++++++++++++++-- .../serializers/SignalBlockSerializer.java | 25 +++++++++++++ .../serializers/StringSerializer.java | 32 +++++++++++++++- .../redstonetools/utils/ReflectionUtils.java | 8 +++- 16 files changed, 407 insertions(+), 13 deletions(-) create mode 100644 .factorypath diff --git a/.factorypath b/.factorypath new file mode 100644 index 00000000..7c91a24b --- /dev/null +++ b/.factorypath @@ -0,0 +1,22 @@ + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/main/java/tools/redstone/redstonetools/RedstoneToolsClient.java b/src/main/java/tools/redstone/redstonetools/RedstoneToolsClient.java index 551ad222..66467350 100644 --- a/src/main/java/tools/redstone/redstonetools/RedstoneToolsClient.java +++ b/src/main/java/tools/redstone/redstonetools/RedstoneToolsClient.java @@ -1,7 +1,10 @@ package tools.redstone.redstonetools; import net.fabricmc.api.ClientModInitializer; +import net.fabricmc.fabric.api.command.v2.ArgumentTypeRegistry; import net.fabricmc.loader.api.FabricLoader; +import net.minecraft.command.argument.serialize.ArgumentSerializer; +import net.minecraft.util.Identifier; import org.reflections.Reflections; import org.slf4j.Logger; @@ -9,9 +12,11 @@ import rip.hippo.inject.Doctor; import rip.hippo.inject.Injector; +import tools.redstone.redstonetools.features.arguments.serializers.GenericArgumentType; import tools.redstone.redstonetools.utils.DependencyLookup; import tools.redstone.redstonetools.utils.ReflectionUtils; +import java.lang.reflect.InvocationTargetException; import java.nio.file.Path; public class RedstoneToolsClient implements ClientModInitializer { @@ -31,6 +36,32 @@ public void onInitializeClient() { // Register game rules RedstoneToolsGameRules.register(); + // Register arguments + ReflectionUtils.getAllArguments().forEach(argument -> { + var nestedClasses = (Class[]) argument + .getDeclaredClasses(); + + if (nestedClasses.length == 0) { + LOGGER.error("Failed to register {} because no serializer nested class was found", + argument.getSimpleName()); + return; + } + + Identifier id = new Identifier(MOD_ID, argument.getSimpleName().toLowerCase()); + + try { + var serializer = nestedClasses[0].getDeclaredConstructor().newInstance(); + + ArgumentTypeRegistry.registerArgumentType( + id, + argument, serializer); + } catch (InstantiationException | IllegalAccessException | IllegalArgumentException + | InvocationTargetException | NoSuchMethodException | SecurityException e) { + LOGGER.error("Failed to register argument type {}. Skipping registration.", + argument.getName()); + } + }); + // Register features ReflectionUtils.getFeatures().forEach(feature -> diff --git a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/BlockColorSerializer.java b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/BlockColorSerializer.java index a90c2a85..b79060f0 100644 --- a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/BlockColorSerializer.java +++ b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/BlockColorSerializer.java @@ -1,5 +1,7 @@ package tools.redstone.redstonetools.features.arguments.serializers; +import net.minecraft.command.CommandRegistryAccess; +import net.minecraft.command.argument.serialize.ArgumentSerializer; import tools.redstone.redstonetools.utils.BlockColor; public class BlockColorSerializer extends EnumSerializer { @@ -12,4 +14,27 @@ private BlockColorSerializer() { public static BlockColorSerializer blockColor() { return INSTANCE; } + + public static class Serializer + extends GenericArgumentType.Serializer { + + public final class Properties + implements ArgumentSerializer.ArgumentTypeProperties { + + @Override + public BlockColorSerializer createType(CommandRegistryAccess var1) { + return blockColor(); + } + + @Override + public ArgumentSerializer getSerializer() { + return new Serializer(); + } + } + + @Override + public Properties getArgumentTypeProperties(BlockColorSerializer var1) { + return new Properties(); + } + } } diff --git a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/BoolSerializer.java b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/BoolSerializer.java index 02fb39e5..81c400e1 100644 --- a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/BoolSerializer.java +++ b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/BoolSerializer.java @@ -3,6 +3,9 @@ import com.mojang.brigadier.arguments.ArgumentType; import com.mojang.brigadier.arguments.BoolArgumentType; +import net.minecraft.command.CommandRegistryAccess; +import net.minecraft.command.argument.serialize.ArgumentSerializer; + public class BoolSerializer extends StringBrigadierSerializer { private static final BoolSerializer INSTANCE = new BoolSerializer(BoolArgumentType.bool()); @@ -20,4 +23,27 @@ public String serialize(Boolean value) { return String.valueOf(value); } + public static class Serializer + extends GenericArgumentType.Serializer { + + public final class Properties + implements ArgumentSerializer.ArgumentTypeProperties { + + @Override + public BoolSerializer createType(CommandRegistryAccess var1) { + return bool(); + } + + @Override + public ArgumentSerializer getSerializer() { + return new Serializer(); + } + } + + @Override + public Properties getArgumentTypeProperties(BoolSerializer serializer) { + return new Properties(); + } + } + } diff --git a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/CollectionSerializer.java b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/CollectionSerializer.java index 16bb16b7..c01c7ef6 100644 --- a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/CollectionSerializer.java +++ b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/CollectionSerializer.java @@ -6,6 +6,9 @@ import com.mojang.brigadier.suggestion.Suggestions; import com.mojang.brigadier.suggestion.SuggestionsBuilder; +import net.minecraft.command.CommandRegistryAccess; +import net.minecraft.command.argument.serialize.ArgumentSerializer; + import java.util.*; import java.util.concurrent.CompletableFuture; import java.util.function.Function; @@ -18,8 +21,7 @@ * @param The collection type. */ public class CollectionSerializer> - extends GenericArgumentType> -{ + extends GenericArgumentType> { public static CollectionSerializer> listOf(GenericArgumentType element) { return new CollectionSerializer<>(List.class, element, ArrayList::new); @@ -39,8 +41,8 @@ public static CollectionSerializer> setOf(GenericArgumentType clazz, - GenericArgumentType elementType, - Function, C> collectionFactory) { + GenericArgumentType elementType, + Function, C> collectionFactory) { super((Class) clazz); this.elementType = (GenericArgumentType) elementType; this.collectionFactory = collectionFactory; @@ -116,7 +118,8 @@ public CompletableFuture listSuggestions(CommandContext cont int oldCursor = inputParser.getCursor(); try { elementType.deserialize(inputParser); - } catch (CommandSyntaxException ignored) { } + } catch (CommandSyntaxException ignored) { + } if (oldCursor == inputParser.getCursor()) break; inputParser.skipWhitespace(); @@ -173,4 +176,28 @@ public List serialize(C value) { .toList(); } + public static class Serializer + extends GenericArgumentType.Serializer, Serializer.Properties> { + + public final class Properties + implements ArgumentSerializer.ArgumentTypeProperties> { + + @Override + public CollectionSerializer createType(CommandRegistryAccess var1) { + // TODO: Actually make this work, this is currently a work around to get it to + // compile + return listOf(IntegerSerializer.integer()); + } + + @Override + public ArgumentSerializer, ?> getSerializer() { + return new Serializer(); + } + } + + @Override + public Properties getArgumentTypeProperties(CollectionSerializer serializer) { + return new Properties(); + } + } } diff --git a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/ColoredBlockTypeSerializer.java b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/ColoredBlockTypeSerializer.java index 3b7b6e99..b19a3ee1 100644 --- a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/ColoredBlockTypeSerializer.java +++ b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/ColoredBlockTypeSerializer.java @@ -1,5 +1,7 @@ package tools.redstone.redstonetools.features.arguments.serializers; +import net.minecraft.command.CommandRegistryAccess; +import net.minecraft.command.argument.serialize.ArgumentSerializer; import tools.redstone.redstonetools.utils.ColoredBlockType; public class ColoredBlockTypeSerializer extends EnumSerializer { @@ -12,4 +14,27 @@ private ColoredBlockTypeSerializer() { public static ColoredBlockTypeSerializer coloredBlockType() { return INSTANCE; } + + public static class Serializer + extends GenericArgumentType.Serializer { + + public final class Properties + implements ArgumentSerializer.ArgumentTypeProperties { + + @Override + public ColoredBlockTypeSerializer createType(CommandRegistryAccess var1) { + return coloredBlockType(); + } + + @Override + public ArgumentSerializer getSerializer() { + return new Serializer(); + } + } + + @Override + public Properties getArgumentTypeProperties(ColoredBlockTypeSerializer serializer) { + return new Properties(); + } + } } diff --git a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/DirectionSerializer.java b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/DirectionSerializer.java index 9a2f3b36..daddaeea 100644 --- a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/DirectionSerializer.java +++ b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/DirectionSerializer.java @@ -1,5 +1,7 @@ package tools.redstone.redstonetools.features.arguments.serializers; +import net.minecraft.command.CommandRegistryAccess; +import net.minecraft.command.argument.serialize.ArgumentSerializer; import tools.redstone.redstonetools.utils.DirectionArgument; public class DirectionSerializer extends EnumSerializer { @@ -12,4 +14,27 @@ private DirectionSerializer() { public static DirectionSerializer direction() { return INSTANCE; } + + public static class Serializer + extends GenericArgumentType.Serializer { + + public final class Properties + implements ArgumentSerializer.ArgumentTypeProperties { + + @Override + public DirectionSerializer createType(CommandRegistryAccess var1) { + return direction(); + } + + @Override + public ArgumentSerializer getSerializer() { + return new Serializer(); + } + } + + @Override + public Properties getArgumentTypeProperties(DirectionSerializer serializer) { + return new Properties(); + } + } } diff --git a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/DoubleSerializer.java b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/DoubleSerializer.java index 86daafa0..f1c2b394 100644 --- a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/DoubleSerializer.java +++ b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/DoubleSerializer.java @@ -3,6 +3,9 @@ import com.mojang.brigadier.arguments.ArgumentType; import com.mojang.brigadier.arguments.DoubleArgumentType; +import net.minecraft.command.CommandRegistryAccess; +import net.minecraft.command.argument.serialize.ArgumentSerializer; + public class DoubleSerializer extends StringBrigadierSerializer { private static final DoubleSerializer INSTANCE = new DoubleSerializer(DoubleArgumentType.doubleArg()); @@ -28,4 +31,26 @@ public String serialize(Double value) { return String.valueOf(value); } + public static class Serializer + extends GenericArgumentType.Serializer { + + public final class Properties + implements ArgumentSerializer.ArgumentTypeProperties { + + @Override + public DoubleSerializer createType(CommandRegistryAccess var1) { + return doubleArg(); + } + + @Override + public ArgumentSerializer getSerializer() { + return new Serializer(); + } + } + + @Override + public Properties getArgumentTypeProperties(DoubleSerializer serializer) { + return new Properties(); + } + } } diff --git a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/FloatSerializer.java b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/FloatSerializer.java index 3511e418..fd9ae6bb 100644 --- a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/FloatSerializer.java +++ b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/FloatSerializer.java @@ -3,6 +3,9 @@ import com.mojang.brigadier.arguments.ArgumentType; import com.mojang.brigadier.arguments.FloatArgumentType; +import net.minecraft.command.CommandRegistryAccess; +import net.minecraft.command.argument.serialize.ArgumentSerializer; + public class FloatSerializer extends StringBrigadierSerializer { private static final FloatSerializer INSTANCE = new FloatSerializer(FloatArgumentType.floatArg()); @@ -28,4 +31,26 @@ public String serialize(Float value) { return String.valueOf(value); } + public static class Serializer + extends GenericArgumentType.Serializer { + + public final class Properties + implements ArgumentSerializer.ArgumentTypeProperties { + + @Override + public FloatSerializer createType(CommandRegistryAccess var1) { + return floatArg(); + } + + @Override + public ArgumentSerializer getSerializer() { + return new Serializer(); + } + } + + @Override + public Properties getArgumentTypeProperties(FloatSerializer serializer) { + return new Properties(); + } + } } diff --git a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/IntegerSerializer.java b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/IntegerSerializer.java index 22f53850..bc8bfb4f 100644 --- a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/IntegerSerializer.java +++ b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/IntegerSerializer.java @@ -2,6 +2,9 @@ import java.util.Optional; +import net.minecraft.command.CommandRegistryAccess; +import net.minecraft.command.argument.serialize.ArgumentSerializer; + public class IntegerSerializer extends IntLikeArgumentType { private static final IntegerSerializer INSTANCE = new IntegerSerializer(Integer.MIN_VALUE, Integer.MAX_VALUE); @@ -29,4 +32,27 @@ protected Optional tryParseOptional(String string, int radix) { return Optional.empty(); } } + + public static class Serializer + extends GenericArgumentType.Serializer { + + public final class Properties + implements ArgumentSerializer.ArgumentTypeProperties { + + @Override + public IntegerSerializer createType(CommandRegistryAccess var1) { + return integer(); + } + + @Override + public ArgumentSerializer getSerializer() { + return new Serializer(); + } + } + + @Override + public Properties getArgumentTypeProperties(IntegerSerializer var1) { + return new Properties(); + } + } } diff --git a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/LongSerializer.java b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/LongSerializer.java index 3038e6a0..8c2577e3 100644 --- a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/LongSerializer.java +++ b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/LongSerializer.java @@ -2,6 +2,9 @@ import java.util.Optional; +import net.minecraft.command.CommandRegistryAccess; +import net.minecraft.command.argument.serialize.ArgumentSerializer; + public class LongSerializer extends IntLikeArgumentType { private static final LongSerializer INSTANCE = new LongSerializer(Long.MIN_VALUE, Long.MAX_VALUE); @@ -29,4 +32,27 @@ protected Optional tryParseOptional(String string, int radix) { return Optional.empty(); } } + + public static class Serializer + extends GenericArgumentType.Serializer { + + public final class Properties + implements ArgumentSerializer.ArgumentTypeProperties { + + @Override + public LongSerializer createType(CommandRegistryAccess var1) { + return longArg(); + } + + @Override + public ArgumentSerializer getSerializer() { + return new Serializer(); + } + } + + @Override + public Properties getArgumentTypeProperties(LongSerializer serializer) { + return new Properties(); + } + } } diff --git a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/MacroNameSerializer.java b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/MacroNameSerializer.java index 8f9ce185..72ab8516 100644 --- a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/MacroNameSerializer.java +++ b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/MacroNameSerializer.java @@ -5,11 +5,14 @@ import com.mojang.brigadier.context.CommandContext; import com.mojang.brigadier.suggestion.Suggestions; import com.mojang.brigadier.suggestion.SuggestionsBuilder; + +import net.minecraft.command.CommandRegistryAccess; +import net.minecraft.command.argument.serialize.ArgumentSerializer; + import java.util.concurrent.CompletableFuture; import static tools.redstone.redstonetools.RedstoneToolsClient.INJECTOR; - public class MacroNameSerializer extends StringSerializer { private static final MacroNameSerializer INSTANCE = new MacroNameSerializer(); @@ -33,4 +36,27 @@ public CompletableFuture listSuggestions(CommandContext cont return builder.buildFuture(); } + + public static class Serializer + extends GenericArgumentType.Serializer { + + public final class Properties + implements ArgumentSerializer.ArgumentTypeProperties { + + @Override + public MacroNameSerializer createType(CommandRegistryAccess var1) { + return macroName(); + } + + @Override + public ArgumentSerializer getSerializer() { + return new Serializer(); + } + } + + @Override + public Properties getArgumentTypeProperties(MacroNameSerializer serializer) { + return new Properties(); + } + } } diff --git a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/NumberSerializer.java b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/NumberSerializer.java index a12d9744..7c8426f0 100644 --- a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/NumberSerializer.java +++ b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/NumberSerializer.java @@ -4,10 +4,13 @@ import java.util.Optional; +import net.minecraft.command.CommandRegistryAccess; +import net.minecraft.command.argument.serialize.ArgumentSerializer; + public class NumberSerializer extends IntLikeArgumentType { - private static final NumberSerializer INSTANCE = new NumberSerializer(null,null); + private static final NumberSerializer INSTANCE = new NumberSerializer(null, null); - public static NumberSerializer numberArg(){ + public static NumberSerializer numberArg() { return INSTANCE; } @@ -19,8 +22,8 @@ public static NumberSerializer numberArg(NumberArg min, NumberArg max) { return new NumberSerializer(min, max); } - private NumberSerializer(NumberArg min, NumberArg max){ - super(NumberArg.class,min, max); + private NumberSerializer(NumberArg min, NumberArg max) { + super(NumberArg.class, min, max); } @Override @@ -31,4 +34,27 @@ protected Optional tryParseOptional(String string, int radix) { return Optional.empty(); } } + + public static class Serializer + extends GenericArgumentType.Serializer { + + public final class Properties + implements ArgumentSerializer.ArgumentTypeProperties { + + @Override + public NumberSerializer createType(CommandRegistryAccess var1) { + return numberArg(); + } + + @Override + public ArgumentSerializer getSerializer() { + return new Serializer(); + } + } + + @Override + public Properties getArgumentTypeProperties(NumberSerializer serializer) { + return new Properties(); + } + } } diff --git a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/SignalBlockSerializer.java b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/SignalBlockSerializer.java index 14c12ad3..8c76b91d 100644 --- a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/SignalBlockSerializer.java +++ b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/SignalBlockSerializer.java @@ -1,5 +1,7 @@ package tools.redstone.redstonetools.features.arguments.serializers; +import net.minecraft.command.CommandRegistryAccess; +import net.minecraft.command.argument.serialize.ArgumentSerializer; import tools.redstone.redstonetools.utils.SignalBlock; public class SignalBlockSerializer extends EnumSerializer { @@ -12,4 +14,27 @@ private SignalBlockSerializer() { public static SignalBlockSerializer signalBlock() { return INSTANCE; } + + public static class Serializer + extends GenericArgumentType.Serializer { + + public final class Properties + implements ArgumentSerializer.ArgumentTypeProperties { + + @Override + public SignalBlockSerializer createType(CommandRegistryAccess var1) { + return signalBlock(); + } + + @Override + public ArgumentSerializer getSerializer() { + return new Serializer(); + } + } + + @Override + public Properties getArgumentTypeProperties(SignalBlockSerializer serializer) { + return new Properties(); + } + } } diff --git a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/StringSerializer.java b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/StringSerializer.java index a7ddbf29..db8f7b66 100644 --- a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/StringSerializer.java +++ b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/StringSerializer.java @@ -3,11 +3,15 @@ import com.mojang.brigadier.arguments.ArgumentType; import com.mojang.brigadier.arguments.StringArgumentType; +import net.minecraft.command.CommandRegistryAccess; +import net.minecraft.command.argument.serialize.ArgumentSerializer; + public class StringSerializer extends StringBrigadierSerializer { private static final StringSerializer INSTANCE_WORD = new StringSerializer(StringArgumentType.word()); private static final StringSerializer INSTANCE_STRING = new StringSerializer(StringArgumentType.string()); - private static final StringSerializer INSTANCE_GREEDY_STRING = new StringSerializer(StringArgumentType.greedyString()); + private static final StringSerializer INSTANCE_GREEDY_STRING = new StringSerializer( + StringArgumentType.greedyString()); public static StringSerializer string() { return INSTANCE_STRING; @@ -27,8 +31,32 @@ protected StringSerializer(ArgumentType argumentType) { @Override public String serialize(String value) { - // TODO: Check if this is correct, doesn't StringArgumentType.string() require quotes which this doesn't add? + // TODO: Check if this is correct, doesn't StringArgumentType.string() require + // quotes which this doesn't add? return value; } + public static class Serializer + extends GenericArgumentType.Serializer { + + public final class Properties + implements ArgumentSerializer.ArgumentTypeProperties { + + @Override + public StringSerializer createType(CommandRegistryAccess var1) { + return string(); + } + + @Override + public ArgumentSerializer getSerializer() { + return new Serializer(); + } + } + + @Override + public Properties getArgumentTypeProperties(StringSerializer serializer) { + return new Properties(); + } + } + } diff --git a/src/main/java/tools/redstone/redstonetools/utils/ReflectionUtils.java b/src/main/java/tools/redstone/redstonetools/utils/ReflectionUtils.java index 076916c7..d1f54a95 100644 --- a/src/main/java/tools/redstone/redstonetools/utils/ReflectionUtils.java +++ b/src/main/java/tools/redstone/redstonetools/utils/ReflectionUtils.java @@ -31,6 +31,7 @@ public class ReflectionUtils { private static final Logger LOGGER = LogManager.getLogger(); private static DoctorModule[] modules; private static Set features; + private static Set> arguments; private ReflectionUtils() { throw new IllegalStateException("Utility class"); @@ -79,7 +80,12 @@ public static DoctorModule[] getModules() { } public static Set> getAllArguments() { - return REFLECTIONS.getSubTypesOf(GenericArgumentType.class); + if (arguments == null) { + arguments = REFLECTIONS.getSubTypesOf(GenericArgumentType.class).stream() + .filter(argument -> !Modifier.isAbstract(argument.getModifiers())).collect(Collectors.toSet()); + } + + return arguments; } public static Set getFeatures() { From 45a6f0b4c5cc47a4f696c3c2e0c9176382d53464 Mon Sep 17 00:00:00 2001 From: rugmj Date: Sun, 21 Jan 2024 12:22:25 +0000 Subject: [PATCH 22/29] fixes item bind --- .../redstone/redstonetools/mixin/features/ItemBindMixin.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/main/java/tools/redstone/redstonetools/mixin/features/ItemBindMixin.java b/src/main/java/tools/redstone/redstonetools/mixin/features/ItemBindMixin.java index 0cad09fd..df9934d7 100644 --- a/src/main/java/tools/redstone/redstonetools/mixin/features/ItemBindMixin.java +++ b/src/main/java/tools/redstone/redstonetools/mixin/features/ItemBindMixin.java @@ -2,7 +2,6 @@ import net.minecraft.client.MinecraftClient; import net.minecraft.client.network.ClientPlayNetworkHandler; -import net.minecraft.entity.Entity; import net.minecraft.entity.player.PlayerEntity; import net.minecraft.item.ItemStack; import net.minecraft.item.ItemUsageContext; @@ -69,7 +68,8 @@ public void injectCommand(String message, CallbackInfo ci) { Feedback addCommandFeedback = ItemBindFeature.addCommand(message); if (addCommandFeedback != null) { - INJECTOR.getInstance(FeedbackSender.class).sendFeedback(((Entity) ((Object)this)).getCommandSource(),addCommandFeedback); + INJECTOR.getInstance(FeedbackSender.class).sendFeedback( + MinecraftClient.getInstance().getServer().getCommandSource(), addCommandFeedback); ci.cancel(); } } From 09ff7536ec9f881d6643d29c39fce1f53308af75 Mon Sep 17 00:00:00 2001 From: rugmj Date: Tue, 23 Jan 2024 18:23:45 +0000 Subject: [PATCH 23/29] fix: updates the command suggestor mixin --- .../macros/autocomplete/CommandSuggestorMixin.java | 10 +++++----- src/main/resources/redstonetools.mixins.json | 2 +- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/src/main/java/tools/redstone/redstonetools/mixin/macros/autocomplete/CommandSuggestorMixin.java b/src/main/java/tools/redstone/redstonetools/mixin/macros/autocomplete/CommandSuggestorMixin.java index b958d060..b1b1f9c5 100644 --- a/src/main/java/tools/redstone/redstonetools/mixin/macros/autocomplete/CommandSuggestorMixin.java +++ b/src/main/java/tools/redstone/redstonetools/mixin/macros/autocomplete/CommandSuggestorMixin.java @@ -3,7 +3,7 @@ import com.mojang.brigadier.suggestion.Suggestions; import net.minecraft.client.gui.screen.ChatInputSuggestor; import net.minecraft.client.gui.widget.TextFieldWidget; -import net.minecraft.client.util.math.MatrixStack; +import net.minecraft.client.gui.DrawContext; import org.jetbrains.annotations.Nullable; import org.spongepowered.asm.mixin.Final; import org.spongepowered.asm.mixin.Mixin; @@ -27,7 +27,7 @@ public class CommandSuggestorMixin{ int maxSuggestionSize; - @ModifyVariable(method = "showSuggestions", at = @At("STORE"), ordinal = 1) + @ModifyVariable(method = "show", at = @At("STORE"), ordinal = 1) public int suggestionWindXPos(int j){ if (MacroCommandSuggestor.instance(this)) { Suggestions suggestions = this.pendingSuggestions.join(); @@ -36,7 +36,7 @@ public int suggestionWindXPos(int j){ return j; } - @ModifyVariable(method = "showSuggestions", at = @At("STORE"), ordinal = 2) + @ModifyVariable(method = "show", at = @At("STORE"), ordinal = 2) public int suggestionWindYPos(int k){ if (MacroCommandSuggestor.instance(this)) { Suggestions suggestions = this.pendingSuggestions.join(); @@ -51,11 +51,11 @@ public int suggestionWindYPos(int k){ private int i = 0; @Inject(method = "render", at = @At("HEAD")) - public void render(MatrixStack matrices, int mouseX, int mouseY, CallbackInfo ci){ + public void render(DrawContext ctx, int mouseX, int mouseY, CallbackInfo ci){ i = 0; } - @ModifyVariable(method = "render", at = @At("STORE"), ordinal = 3) + @ModifyVariable(method = "render", at = @At("LOAD"), ordinal = 0) public int messageYPos(int j) { if (MacroCommandSuggestor.instance(this)) { int y = MacroCommandSuggestor.getY(this); diff --git a/src/main/resources/redstonetools.mixins.json b/src/main/resources/redstonetools.mixins.json index 607d9172..600915cb 100644 --- a/src/main/resources/redstonetools.mixins.json +++ b/src/main/resources/redstonetools.mixins.json @@ -26,4 +26,4 @@ "macros.autocomplete.CommandSuggestorMixin", "update.CheckUpdateMixin" ] -} \ No newline at end of file +} From 537973379cec4fba5664922dd1dc603235808129 Mon Sep 17 00:00:00 2001 From: MiranCZ Date: Fri, 26 Jan 2024 15:58:27 +0100 Subject: [PATCH 24/29] Ported macro GUI --- .../macros/gui/screen/CommandEditScreen.java | 18 +++++++++------- .../macros/gui/screen/MacroEditScreen.java | 16 ++++++-------- .../macros/gui/screen/MacroSelectScreen.java | 4 +++- .../macros/gui/widget/IconButtonWidget.java | 5 ++--- .../widget/commandlist/CommandListWidget.java | 18 ++++++---------- .../gui/widget/macrolist/MacroEntry.java | 17 +++++++++------ .../gui/widget/macrolist/MacroListWidget.java | 6 ++---- .../mixin/macros/AddMacroButtonMixin.java | 20 +++++++++++++++++- .../assets/{ => redstonetools}/gui/cross.png | Bin .../assets/{ => redstonetools}/gui/pencil.png | Bin .../assets/{ => redstonetools}/icon.png | Bin .../{ => redstonetools}/lang/en_au.json | 0 .../{ => redstonetools}/lang/en_ca.json | 0 .../{ => redstonetools}/lang/en_gb.json | 0 .../{ => redstonetools}/lang/en_nz.json | 0 .../{ => redstonetools}/lang/en_us.json | 0 16 files changed, 59 insertions(+), 45 deletions(-) rename src/main/resources/assets/{ => redstonetools}/gui/cross.png (100%) rename src/main/resources/assets/{ => redstonetools}/gui/pencil.png (100%) rename src/main/resources/assets/{ => redstonetools}/icon.png (100%) rename src/main/resources/assets/{ => redstonetools}/lang/en_au.json (100%) rename src/main/resources/assets/{ => redstonetools}/lang/en_ca.json (100%) rename src/main/resources/assets/{ => redstonetools}/lang/en_gb.json (100%) rename src/main/resources/assets/{ => redstonetools}/lang/en_nz.json (100%) rename src/main/resources/assets/{ => redstonetools}/lang/en_us.json (100%) diff --git a/src/main/java/tools/redstone/redstonetools/macros/gui/screen/CommandEditScreen.java b/src/main/java/tools/redstone/redstonetools/macros/gui/screen/CommandEditScreen.java index 5031ce25..a7257926 100644 --- a/src/main/java/tools/redstone/redstonetools/macros/gui/screen/CommandEditScreen.java +++ b/src/main/java/tools/redstone/redstonetools/macros/gui/screen/CommandEditScreen.java @@ -28,14 +28,21 @@ public CommandEditScreen(Screen parent, GameOptions gameOptions, TextFieldWidget commandMacroCommandSuggestor.refresh(); } + @Override + public void renderBackground(DrawContext context, int mouseX, int mouseY, float delta) { + } + public void render(DrawContext context, int mouseX, int mouseY, float delta) { parent.render(context, mouseX, mouseY, delta); + context.getMatrices().translate(0,0,0.03F); - //this.fillGradient(context, 0, 0, this.width, this.height, -1072689136, -804253680); + context.fillGradient( 0, 0, this.width, this.height, -1072689136, -804253680); commandField.render(context, mouseX, mouseY, delta); commandMacroCommandSuggestor.render(context, mouseX, mouseY); + commandMacroCommandSuggestor.tryRenderWindow(context,mouseX,mouseY); + if (changed) { commandMacroCommandSuggestor.refresh(); changed = false; @@ -45,11 +52,6 @@ public void render(DrawContext context, int mouseX, int mouseY, float delta) { } - @Override - public void tick() { - super.tick(); - } - @Override public void resize(MinecraftClient client, int width, int height) { parent.resize(client,width,height); @@ -78,8 +80,8 @@ public boolean mouseClicked(double mouseX, double mouseY, int button) { return super.mouseClicked(mouseX, mouseY, button); } - public boolean mouseScrolled(double mouseX, double mouseY, double amount) { - return commandMacroCommandSuggestor.mouseScrolled(amount); + public boolean mouseScrolled(double mouseX, double mouseY, double horizontalAmount, double verticalAmount) { + return commandMacroCommandSuggestor.mouseScrolled(verticalAmount); } @Override diff --git a/src/main/java/tools/redstone/redstonetools/macros/gui/screen/MacroEditScreen.java b/src/main/java/tools/redstone/redstonetools/macros/gui/screen/MacroEditScreen.java index 20682157..af6a2f4a 100644 --- a/src/main/java/tools/redstone/redstonetools/macros/gui/screen/MacroEditScreen.java +++ b/src/main/java/tools/redstone/redstonetools/macros/gui/screen/MacroEditScreen.java @@ -106,8 +106,8 @@ public void init() { scrollAmount = commandList.getScrollAmount(); } - commandList = new CommandListWidget(client, this, widgetWidth, height, 85, 24); - //commandList.setLeftPos(width / 2 - widgetWidth / 2); + commandList = new CommandListWidget(client, this, widgetWidth, this.height / 4 + 144 + 5 - 10-85, 85, 24); + commandList.setX(width / 2 - widgetWidth / 2); if (entries != null) { @@ -128,6 +128,10 @@ public void init() { this.addSelectableChild(commandList); } + @Override + public void renderBackground(DrawContext context, int mouseX, int mouseY, float delta) { + } + private boolean canClickDone() { return !nameField.getText().trim().isEmpty() && macroListWidget.canAdd(macro); } @@ -155,14 +159,6 @@ public void render(DrawContext context, int mouseX, int mouseY, float delta) { } } - @Override - public void tick() { - //nameField.tick(); - //commandList.tick(); - - super.tick(); - } - @Override public void resize(MinecraftClient client, int width, int height) { super.resize(client, width, height); diff --git a/src/main/java/tools/redstone/redstonetools/macros/gui/screen/MacroSelectScreen.java b/src/main/java/tools/redstone/redstonetools/macros/gui/screen/MacroSelectScreen.java index 4275c7f1..001f0395 100644 --- a/src/main/java/tools/redstone/redstonetools/macros/gui/screen/MacroSelectScreen.java +++ b/src/main/java/tools/redstone/redstonetools/macros/gui/screen/MacroSelectScreen.java @@ -44,11 +44,13 @@ public void render(DrawContext context, int mouseX, int mouseY, float delta) { context.drawCenteredTextWithShadow(this.textRenderer, this.title, this.width / 2, 8, 16777215); super.render(context, mouseX, mouseY, delta); - } public void openEditScreen(MacroEntry entry) { client.setScreen(new MacroEditScreen(this,gameOptions,Text.of("Edit Macro"), macroList, entry.macro)); } + @Override + public void renderBackground(DrawContext context, int mouseX, int mouseY, float delta) { + } } diff --git a/src/main/java/tools/redstone/redstonetools/macros/gui/widget/IconButtonWidget.java b/src/main/java/tools/redstone/redstonetools/macros/gui/widget/IconButtonWidget.java index db1038aa..5b1f5f11 100644 --- a/src/main/java/tools/redstone/redstonetools/macros/gui/widget/IconButtonWidget.java +++ b/src/main/java/tools/redstone/redstonetools/macros/gui/widget/IconButtonWidget.java @@ -18,10 +18,9 @@ public IconButtonWidget(Identifier texture ,int x, int y, int width, int height, this.texture = texture; } - public void renderButton(DrawContext context, int mouseX, int mouseY, float delta) { + public void renderWidget(DrawContext context, int mouseX, int mouseY, float delta) { super.renderWidget(context, mouseX, mouseY, delta); - RenderSystem.setShaderTexture(0, texture); RenderSystem.enableDepthTest(); @@ -29,7 +28,7 @@ public void renderButton(DrawContext context, int mouseX, int mouseY, float delt RenderSystem.enableBlend(); RenderSystem.defaultBlendFunc(); RenderSystem.blendFunc(GlStateManager.SrcFactor.SRC_ALPHA, GlStateManager.DstFactor.ONE_MINUS_SRC_ALPHA); - context.drawGuiTexture(this.texture,this.getX(), this.getY(), 0,0, 20, this.height, 20, 20); + context.drawTexture(this.texture,this.getX(), this.getY(), 0,0, 20, this.height, 20, 20); } } diff --git a/src/main/java/tools/redstone/redstonetools/macros/gui/widget/commandlist/CommandListWidget.java b/src/main/java/tools/redstone/redstonetools/macros/gui/widget/commandlist/CommandListWidget.java index c5e1b05a..d702381a 100644 --- a/src/main/java/tools/redstone/redstonetools/macros/gui/widget/commandlist/CommandListWidget.java +++ b/src/main/java/tools/redstone/redstonetools/macros/gui/widget/commandlist/CommandListWidget.java @@ -4,6 +4,7 @@ import net.minecraft.client.gui.widget.ButtonWidget; import net.minecraft.client.gui.widget.TextFieldWidget; import net.minecraft.text.Text; +import org.jetbrains.annotations.Nullable; import tools.redstone.redstonetools.macros.gui.MacroCommandSuggestor; import tools.redstone.redstonetools.macros.gui.screen.MacroEditScreen; import net.minecraft.client.MinecraftClient; @@ -24,13 +25,11 @@ public CommandListWidget(MinecraftClient client, MacroEditScreen parent, int wid addEntry(new CommandEntryPlaceHolder(client,this,"")); } -// public void tick() { -// for (CommandEntry entry : children()) { -// entry.tick(); -// } -// } + @Override + public void setSelected(@Nullable CommandListWidget.CommandEntry entry) { + } public CommandEntry addCommand(String command) { CommandEntry entry = new CommandEntry(client, this, command); @@ -148,10 +147,9 @@ public CommandEntry(MinecraftClient client, CommandListWidget owner, String text command.setMaxLength(255); command.setText(text); - - deleteButton = IconButtonWidget.builder(Text.of(""), (button) -> { + deleteButton = new IconButtonWidget(IconButtonWidget.CROSS_ICON,0,0,20,20,Text.empty(),(button) -> { this.owner.removeCommand(this); - }).dimensions(0, 0, 20, 20).build(); + },null); MacroCommandSuggestor commandMacroCommandSuggestor = new MacroCommandSuggestor(client, owner.getParent(), command,client.textRenderer,true,false, 0,0,0); commandMacroCommandSuggestor.setWindowActive(false); @@ -177,9 +175,6 @@ public void render(DrawContext context, int index, int y, int x, int entryWidth, } } -// public void tick() { -// command.tick(); -// } private boolean edit = false; public void setFocused(boolean focused){ @@ -188,7 +183,6 @@ public void setFocused(boolean focused){ owner.centerScrollOn(this); edit = true; } - owner.focusOn(this); } protected String getText() { diff --git a/src/main/java/tools/redstone/redstonetools/macros/gui/widget/macrolist/MacroEntry.java b/src/main/java/tools/redstone/redstonetools/macros/gui/widget/macrolist/MacroEntry.java index d59750b4..3457b5e8 100644 --- a/src/main/java/tools/redstone/redstonetools/macros/gui/widget/macrolist/MacroEntry.java +++ b/src/main/java/tools/redstone/redstonetools/macros/gui/widget/macrolist/MacroEntry.java @@ -1,5 +1,6 @@ package tools.redstone.redstonetools.macros.gui.widget.macrolist; +import net.minecraft.client.MinecraftClient; import net.minecraft.client.gui.DrawContext; import net.minecraft.client.gui.screen.ConfirmScreen; import net.minecraft.client.gui.widget.*; @@ -23,14 +24,18 @@ public MacroEntry(Macro macro, MacroListWidget owner) { this.macro = macro; this.owner = owner; - buttonWidget = CheckboxWidget.builder(null, null).build(); - buttonWidget.setDimensionsAndPosition(20,20,0,0); - deleteButton = IconButtonWidget.builder(Text.of(""), (button) -> { + buttonWidget = CheckboxWidget.builder(Text.empty(), MinecraftClient.getInstance().textRenderer).build(); + + if (buttonWidget.isChecked() != macro.enabled) { + buttonWidget.onPress(); + } + + deleteButton = new IconButtonWidget(IconButtonWidget.CROSS_ICON,0, 0, 20, 20 ,Text.of(""), (button) -> { deleteIfConfirmed(); - }).dimensions(0, 0, 20, 20).build(); - editButton = IconButtonWidget.builder(Text.of(""), (button) -> { + },null); + editButton = new IconButtonWidget(IconButtonWidget.PENCIL_ICON,0, 0, 20, 20, Text.of(""), (button) -> { owner.parent.openEditScreen(this); - }).dimensions(0, 0, 20, 20).build(); + },null); } diff --git a/src/main/java/tools/redstone/redstonetools/macros/gui/widget/macrolist/MacroListWidget.java b/src/main/java/tools/redstone/redstonetools/macros/gui/widget/macrolist/MacroListWidget.java index 477f2873..f457d77f 100644 --- a/src/main/java/tools/redstone/redstonetools/macros/gui/widget/macrolist/MacroListWidget.java +++ b/src/main/java/tools/redstone/redstonetools/macros/gui/widget/macrolist/MacroListWidget.java @@ -1,7 +1,6 @@ package tools.redstone.redstonetools.macros.gui.widget.macrolist; import net.minecraft.client.MinecraftClient; -import net.minecraft.client.gui.DrawContext; import net.minecraft.client.gui.widget.AlwaysSelectedEntryListWidget; import tools.redstone.redstonetools.macros.Macro; import tools.redstone.redstonetools.macros.MacroManager; @@ -19,6 +18,8 @@ public class MacroListWidget extends AlwaysSelectedEntryListWidget { public MacroListWidget(MacroSelectScreen parent, MinecraftClient client) { super(client, parent.width, parent.height, 20, 20); + setHeight(parent.height - 62); + this.parent = parent; this.client = client; @@ -48,9 +49,6 @@ protected int getScrollbarPositionX() { } - protected void renderBackground(DrawContext context, int mouseX, int mouseY, float delta) { - parent.renderBackground(context, mouseX, mouseY, delta); - } public boolean isFocused() { return parent.getFocused() == this; diff --git a/src/main/java/tools/redstone/redstonetools/mixin/macros/AddMacroButtonMixin.java b/src/main/java/tools/redstone/redstonetools/mixin/macros/AddMacroButtonMixin.java index 2edfc7f3..42d4c749 100644 --- a/src/main/java/tools/redstone/redstonetools/mixin/macros/AddMacroButtonMixin.java +++ b/src/main/java/tools/redstone/redstonetools/mixin/macros/AddMacroButtonMixin.java @@ -1,14 +1,18 @@ package tools.redstone.redstonetools.mixin.macros; +import net.minecraft.client.gui.Element; import net.minecraft.client.gui.screen.Screen; import net.minecraft.client.gui.screen.option.ControlsOptionsScreen; import net.minecraft.client.gui.screen.option.GameOptionsScreen; import net.minecraft.client.gui.widget.ButtonWidget; import net.minecraft.client.option.GameOptions; +import net.minecraft.screen.ScreenTexts; import net.minecraft.text.Text; import org.spongepowered.asm.mixin.Mixin; +import org.spongepowered.asm.mixin.Unique; import org.spongepowered.asm.mixin.injection.At; import org.spongepowered.asm.mixin.injection.Inject; +import org.spongepowered.asm.mixin.injection.ModifyVariable; import org.spongepowered.asm.mixin.injection.callback.CallbackInfo; import tools.redstone.redstonetools.macros.gui.screen.MacroSelectScreen; @@ -22,7 +26,21 @@ public AddMacroButtonMixin(Screen parent, GameOptions gameOptions, Text title) { public void init(CallbackInfo ci) { ButtonWidget buttonWidget = ButtonWidget.builder(Text.of("Macros..."), (button) -> { this.client.setScreen(new MacroSelectScreen(this,super.gameOptions,Text.of("Macros"))); - }).dimensions(this.width / 2 + 5, this.height / 6 + 36, 150, 20).build(); + }).dimensions(this.width / 2 - 155, this.height / 6 + 36+24, 150, 20).build(); this.addDrawableChild(buttonWidget); + + moveDoneButton(); + } + + + //TODO refactor this into mixin instead + @Unique + private void moveDoneButton() { + for (Element e : this.children()) { + if (!(e instanceof ButtonWidget button)) continue; + if (((ButtonWidget) e).getMessage() == ScreenTexts.DONE) { + button.setY(button.getY()+24); + } + } } } diff --git a/src/main/resources/assets/gui/cross.png b/src/main/resources/assets/redstonetools/gui/cross.png similarity index 100% rename from src/main/resources/assets/gui/cross.png rename to src/main/resources/assets/redstonetools/gui/cross.png diff --git a/src/main/resources/assets/gui/pencil.png b/src/main/resources/assets/redstonetools/gui/pencil.png similarity index 100% rename from src/main/resources/assets/gui/pencil.png rename to src/main/resources/assets/redstonetools/gui/pencil.png diff --git a/src/main/resources/assets/icon.png b/src/main/resources/assets/redstonetools/icon.png similarity index 100% rename from src/main/resources/assets/icon.png rename to src/main/resources/assets/redstonetools/icon.png diff --git a/src/main/resources/assets/lang/en_au.json b/src/main/resources/assets/redstonetools/lang/en_au.json similarity index 100% rename from src/main/resources/assets/lang/en_au.json rename to src/main/resources/assets/redstonetools/lang/en_au.json diff --git a/src/main/resources/assets/lang/en_ca.json b/src/main/resources/assets/redstonetools/lang/en_ca.json similarity index 100% rename from src/main/resources/assets/lang/en_ca.json rename to src/main/resources/assets/redstonetools/lang/en_ca.json diff --git a/src/main/resources/assets/lang/en_gb.json b/src/main/resources/assets/redstonetools/lang/en_gb.json similarity index 100% rename from src/main/resources/assets/lang/en_gb.json rename to src/main/resources/assets/redstonetools/lang/en_gb.json diff --git a/src/main/resources/assets/lang/en_nz.json b/src/main/resources/assets/redstonetools/lang/en_nz.json similarity index 100% rename from src/main/resources/assets/lang/en_nz.json rename to src/main/resources/assets/redstonetools/lang/en_nz.json diff --git a/src/main/resources/assets/lang/en_us.json b/src/main/resources/assets/redstonetools/lang/en_us.json similarity index 100% rename from src/main/resources/assets/lang/en_us.json rename to src/main/resources/assets/redstonetools/lang/en_us.json From e9a5dd8a6951f5013ce98c4b6ff3341adb0f41b3 Mon Sep 17 00:00:00 2001 From: RUGMJ Date: Sat, 27 Jan 2024 09:04:56 +0000 Subject: [PATCH 25/29] Discard changes to .factorypath --- .factorypath | 22 ---------------------- 1 file changed, 22 deletions(-) delete mode 100644 .factorypath diff --git a/.factorypath b/.factorypath deleted file mode 100644 index 7c91a24b..00000000 --- a/.factorypath +++ /dev/null @@ -1,22 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - From c1c3a03a8fe4910b14f78e945d68a9cd407186af Mon Sep 17 00:00:00 2001 From: rugmj Date: Sun, 28 Jan 2024 16:06:20 +0000 Subject: [PATCH 26/29] includes javaassist --- build.gradle | 1 + 1 file changed, 1 insertion(+) diff --git a/build.gradle b/build.gradle index 6e355a1f..93902835 100644 --- a/build.gradle +++ b/build.gradle @@ -35,6 +35,7 @@ dependencies { include implementation("javax.inject:javax.inject:1") include implementation("org.reflections:reflections:0.10.2") + include implementation("org.javassist:javassist:3.30.2-GA") // Json include implementation("javax.json:javax.json-api:1.1.4") From 8dd9edb4cb44202c39eb5141f43fe65ec91ee900 Mon Sep 17 00:00:00 2001 From: Killian Date: Sun, 28 Jan 2024 17:51:58 +0100 Subject: [PATCH 27/29] Use AutoService to detect Serializers, remove dependency on reflections & Javassist --- build.gradle | 3 -- .../redstonetools/RedstoneToolsClient.java | 5 -- .../serializers/BigIntegerArgumentType.java | 2 + .../serializers/BlockColorSerializer.java | 2 + .../serializers/BlockStateArgumentType.java | 2 + .../arguments/serializers/BoolSerializer.java | 2 + .../serializers/BrigadierArgumentType.java | 1 + .../serializers/CollectionSerializer.java | 2 + .../ColoredBlockTypeSerializer.java | 2 + .../serializers/DirectionSerializer.java | 2 + .../serializers/DoubleSerializer.java | 2 + .../serializers/FloatSerializer.java | 2 + .../serializers/IntegerSerializer.java | 2 + .../arguments/serializers/LongSerializer.java | 2 + .../serializers/MacroNameSerializer.java | 6 +-- .../serializers/NumberBaseArgumentType.java | 2 + .../serializers/NumberSerializer.java | 2 + .../serializers/SignalBlockSerializer.java | 2 + .../serializers/StringSerializer.java | 2 + .../redstonetools/utils/ReflectionUtils.java | 46 +++++++++++-------- 20 files changed, 60 insertions(+), 31 deletions(-) diff --git a/build.gradle b/build.gradle index 93902835..ed030bff 100644 --- a/build.gradle +++ b/build.gradle @@ -34,9 +34,6 @@ dependencies { include implementation("rip.hippo:Doctor:1.0.1") include implementation("javax.inject:javax.inject:1") - include implementation("org.reflections:reflections:0.10.2") - include implementation("org.javassist:javassist:3.30.2-GA") - // Json include implementation("javax.json:javax.json-api:1.1.4") include "org.glassfish:javax.json:1.1.4" diff --git a/src/main/java/tools/redstone/redstonetools/RedstoneToolsClient.java b/src/main/java/tools/redstone/redstonetools/RedstoneToolsClient.java index 66467350..0d8a922c 100644 --- a/src/main/java/tools/redstone/redstonetools/RedstoneToolsClient.java +++ b/src/main/java/tools/redstone/redstonetools/RedstoneToolsClient.java @@ -5,14 +5,10 @@ import net.fabricmc.loader.api.FabricLoader; import net.minecraft.command.argument.serialize.ArgumentSerializer; import net.minecraft.util.Identifier; - -import org.reflections.Reflections; import org.slf4j.Logger; import org.slf4j.LoggerFactory; - import rip.hippo.inject.Doctor; import rip.hippo.inject.Injector; -import tools.redstone.redstonetools.features.arguments.serializers.GenericArgumentType; import tools.redstone.redstonetools.utils.DependencyLookup; import tools.redstone.redstonetools.utils.ReflectionUtils; @@ -27,7 +23,6 @@ public class RedstoneToolsClient implements ClientModInitializer { public static final Logger LOGGER = LoggerFactory.getLogger(MOD_ID); public static final Path CONFIG_DIR = FabricLoader.getInstance().getConfigDir().resolve("redstonetools"); public static final Injector INJECTOR = Doctor.createInjector(ReflectionUtils.getModules()); - public static final Reflections REFLECTIONS = new Reflections("tools.redstone.redstonetools"); @Override public void onInitializeClient() { diff --git a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/BigIntegerArgumentType.java b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/BigIntegerArgumentType.java index b3651c4a..12167f3c 100644 --- a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/BigIntegerArgumentType.java +++ b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/BigIntegerArgumentType.java @@ -1,11 +1,13 @@ package tools.redstone.redstonetools.features.arguments.serializers; +import com.google.auto.service.AutoService; import net.minecraft.command.CommandRegistryAccess; import net.minecraft.command.argument.serialize.ArgumentSerializer; import java.math.BigInteger; import java.util.Optional; +@AutoService(GenericArgumentType.class) public class BigIntegerArgumentType extends IntLikeArgumentType { private static final BigIntegerArgumentType INSTANCE = new BigIntegerArgumentType(null, null); diff --git a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/BlockColorSerializer.java b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/BlockColorSerializer.java index b79060f0..9ca9ac82 100644 --- a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/BlockColorSerializer.java +++ b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/BlockColorSerializer.java @@ -1,9 +1,11 @@ package tools.redstone.redstonetools.features.arguments.serializers; +import com.google.auto.service.AutoService; import net.minecraft.command.CommandRegistryAccess; import net.minecraft.command.argument.serialize.ArgumentSerializer; import tools.redstone.redstonetools.utils.BlockColor; +@AutoService(GenericArgumentType.class) public class BlockColorSerializer extends EnumSerializer { private static final BlockColorSerializer INSTANCE = new BlockColorSerializer(); diff --git a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/BlockStateArgumentType.java b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/BlockStateArgumentType.java index 9ce1dbcb..6d5d6bd4 100644 --- a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/BlockStateArgumentType.java +++ b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/BlockStateArgumentType.java @@ -1,5 +1,6 @@ package tools.redstone.redstonetools.features.arguments.serializers; +import com.google.auto.service.AutoService; import com.mojang.brigadier.StringReader; import com.mojang.brigadier.exceptions.CommandSyntaxException; import net.minecraft.command.CommandRegistryAccess; @@ -7,6 +8,7 @@ import net.minecraft.command.argument.serialize.ArgumentSerializer; import net.minecraft.registry.Registries; +@AutoService(GenericArgumentType.class) public class BlockStateArgumentType extends BrigadierArgumentType { private static BlockStateArgumentType INSTANCE; diff --git a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/BoolSerializer.java b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/BoolSerializer.java index 81c400e1..22c1f8aa 100644 --- a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/BoolSerializer.java +++ b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/BoolSerializer.java @@ -1,11 +1,13 @@ package tools.redstone.redstonetools.features.arguments.serializers; +import com.google.auto.service.AutoService; import com.mojang.brigadier.arguments.ArgumentType; import com.mojang.brigadier.arguments.BoolArgumentType; import net.minecraft.command.CommandRegistryAccess; import net.minecraft.command.argument.serialize.ArgumentSerializer; +@AutoService(GenericArgumentType.class) public class BoolSerializer extends StringBrigadierSerializer { private static final BoolSerializer INSTANCE = new BoolSerializer(BoolArgumentType.bool()); diff --git a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/BrigadierArgumentType.java b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/BrigadierArgumentType.java index 846a3bcf..2745f9f1 100644 --- a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/BrigadierArgumentType.java +++ b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/BrigadierArgumentType.java @@ -1,5 +1,6 @@ package tools.redstone.redstonetools.features.arguments.serializers; +import com.google.auto.service.AutoService; import com.mojang.brigadier.StringReader; import com.mojang.brigadier.arguments.ArgumentType; import com.mojang.brigadier.context.CommandContext; diff --git a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/CollectionSerializer.java b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/CollectionSerializer.java index c01c7ef6..fed8f7a0 100644 --- a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/CollectionSerializer.java +++ b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/CollectionSerializer.java @@ -1,5 +1,6 @@ package tools.redstone.redstonetools.features.arguments.serializers; +import com.google.auto.service.AutoService; import com.mojang.brigadier.StringReader; import com.mojang.brigadier.context.CommandContext; import com.mojang.brigadier.exceptions.CommandSyntaxException; @@ -20,6 +21,7 @@ * @param The element type. * @param The collection type. */ +@AutoService(GenericArgumentType.class) public class CollectionSerializer> extends GenericArgumentType> { diff --git a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/ColoredBlockTypeSerializer.java b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/ColoredBlockTypeSerializer.java index b19a3ee1..bf79b1c9 100644 --- a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/ColoredBlockTypeSerializer.java +++ b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/ColoredBlockTypeSerializer.java @@ -1,9 +1,11 @@ package tools.redstone.redstonetools.features.arguments.serializers; +import com.google.auto.service.AutoService; import net.minecraft.command.CommandRegistryAccess; import net.minecraft.command.argument.serialize.ArgumentSerializer; import tools.redstone.redstonetools.utils.ColoredBlockType; +@AutoService(GenericArgumentType.class) public class ColoredBlockTypeSerializer extends EnumSerializer { private static final ColoredBlockTypeSerializer INSTANCE = new ColoredBlockTypeSerializer(); diff --git a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/DirectionSerializer.java b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/DirectionSerializer.java index daddaeea..0793a737 100644 --- a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/DirectionSerializer.java +++ b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/DirectionSerializer.java @@ -1,9 +1,11 @@ package tools.redstone.redstonetools.features.arguments.serializers; +import com.google.auto.service.AutoService; import net.minecraft.command.CommandRegistryAccess; import net.minecraft.command.argument.serialize.ArgumentSerializer; import tools.redstone.redstonetools.utils.DirectionArgument; +@AutoService(GenericArgumentType.class) public class DirectionSerializer extends EnumSerializer { private static final DirectionSerializer INSTANCE = new DirectionSerializer(); diff --git a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/DoubleSerializer.java b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/DoubleSerializer.java index f1c2b394..db6d25d9 100644 --- a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/DoubleSerializer.java +++ b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/DoubleSerializer.java @@ -1,11 +1,13 @@ package tools.redstone.redstonetools.features.arguments.serializers; +import com.google.auto.service.AutoService; import com.mojang.brigadier.arguments.ArgumentType; import com.mojang.brigadier.arguments.DoubleArgumentType; import net.minecraft.command.CommandRegistryAccess; import net.minecraft.command.argument.serialize.ArgumentSerializer; +@AutoService(GenericArgumentType.class) public class DoubleSerializer extends StringBrigadierSerializer { private static final DoubleSerializer INSTANCE = new DoubleSerializer(DoubleArgumentType.doubleArg()); diff --git a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/FloatSerializer.java b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/FloatSerializer.java index fd9ae6bb..7c6c698f 100644 --- a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/FloatSerializer.java +++ b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/FloatSerializer.java @@ -1,11 +1,13 @@ package tools.redstone.redstonetools.features.arguments.serializers; +import com.google.auto.service.AutoService; import com.mojang.brigadier.arguments.ArgumentType; import com.mojang.brigadier.arguments.FloatArgumentType; import net.minecraft.command.CommandRegistryAccess; import net.minecraft.command.argument.serialize.ArgumentSerializer; +@AutoService(GenericArgumentType.class) public class FloatSerializer extends StringBrigadierSerializer { private static final FloatSerializer INSTANCE = new FloatSerializer(FloatArgumentType.floatArg()); diff --git a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/IntegerSerializer.java b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/IntegerSerializer.java index bc8bfb4f..990873df 100644 --- a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/IntegerSerializer.java +++ b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/IntegerSerializer.java @@ -2,9 +2,11 @@ import java.util.Optional; +import com.google.auto.service.AutoService; import net.minecraft.command.CommandRegistryAccess; import net.minecraft.command.argument.serialize.ArgumentSerializer; +@AutoService(GenericArgumentType.class) public class IntegerSerializer extends IntLikeArgumentType { private static final IntegerSerializer INSTANCE = new IntegerSerializer(Integer.MIN_VALUE, Integer.MAX_VALUE); diff --git a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/LongSerializer.java b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/LongSerializer.java index 8c2577e3..ec9f9ee2 100644 --- a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/LongSerializer.java +++ b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/LongSerializer.java @@ -2,9 +2,11 @@ import java.util.Optional; +import com.google.auto.service.AutoService; import net.minecraft.command.CommandRegistryAccess; import net.minecraft.command.argument.serialize.ArgumentSerializer; +@AutoService(GenericArgumentType.class) public class LongSerializer extends IntLikeArgumentType { private static final LongSerializer INSTANCE = new LongSerializer(Long.MIN_VALUE, Long.MAX_VALUE); diff --git a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/MacroNameSerializer.java b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/MacroNameSerializer.java index 72ab8516..8769506c 100644 --- a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/MacroNameSerializer.java +++ b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/MacroNameSerializer.java @@ -1,18 +1,18 @@ package tools.redstone.redstonetools.features.arguments.serializers; -import tools.redstone.redstonetools.macros.Macro; -import tools.redstone.redstonetools.macros.MacroManager; +import com.google.auto.service.AutoService; import com.mojang.brigadier.context.CommandContext; import com.mojang.brigadier.suggestion.Suggestions; import com.mojang.brigadier.suggestion.SuggestionsBuilder; - import net.minecraft.command.CommandRegistryAccess; import net.minecraft.command.argument.serialize.ArgumentSerializer; +import tools.redstone.redstonetools.macros.MacroManager; import java.util.concurrent.CompletableFuture; import static tools.redstone.redstonetools.RedstoneToolsClient.INJECTOR; +@AutoService(GenericArgumentType.class) public class MacroNameSerializer extends StringSerializer { private static final MacroNameSerializer INSTANCE = new MacroNameSerializer(); diff --git a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/NumberBaseArgumentType.java b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/NumberBaseArgumentType.java index acace7d2..d8dd9b86 100644 --- a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/NumberBaseArgumentType.java +++ b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/NumberBaseArgumentType.java @@ -1,5 +1,6 @@ package tools.redstone.redstonetools.features.arguments.serializers; +import com.google.auto.service.AutoService; import com.mojang.brigadier.StringReader; import com.mojang.brigadier.context.CommandContext; import com.mojang.brigadier.exceptions.CommandSyntaxException; @@ -14,6 +15,7 @@ import java.util.Collection; import java.util.concurrent.CompletableFuture; +@AutoService(GenericArgumentType.class) public class NumberBaseArgumentType extends GenericArgumentType { private static final IntegerSerializer INT_SERIALIZER = IntegerSerializer.integer(2, 36); private static final NumberBaseArgumentType INSTANCE = new NumberBaseArgumentType(); diff --git a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/NumberSerializer.java b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/NumberSerializer.java index 7c8426f0..7dc6145b 100644 --- a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/NumberSerializer.java +++ b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/NumberSerializer.java @@ -1,5 +1,6 @@ package tools.redstone.redstonetools.features.arguments.serializers; +import com.google.auto.service.AutoService; import tools.redstone.redstonetools.utils.NumberArg; import java.util.Optional; @@ -7,6 +8,7 @@ import net.minecraft.command.CommandRegistryAccess; import net.minecraft.command.argument.serialize.ArgumentSerializer; +@AutoService(GenericArgumentType.class) public class NumberSerializer extends IntLikeArgumentType { private static final NumberSerializer INSTANCE = new NumberSerializer(null, null); diff --git a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/SignalBlockSerializer.java b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/SignalBlockSerializer.java index 8c76b91d..b517287b 100644 --- a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/SignalBlockSerializer.java +++ b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/SignalBlockSerializer.java @@ -1,9 +1,11 @@ package tools.redstone.redstonetools.features.arguments.serializers; +import com.google.auto.service.AutoService; import net.minecraft.command.CommandRegistryAccess; import net.minecraft.command.argument.serialize.ArgumentSerializer; import tools.redstone.redstonetools.utils.SignalBlock; +@AutoService(GenericArgumentType.class) public class SignalBlockSerializer extends EnumSerializer { private static final SignalBlockSerializer INSTANCE = new SignalBlockSerializer(); diff --git a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/StringSerializer.java b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/StringSerializer.java index db8f7b66..6da4e2ca 100644 --- a/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/StringSerializer.java +++ b/src/main/java/tools/redstone/redstonetools/features/arguments/serializers/StringSerializer.java @@ -1,11 +1,13 @@ package tools.redstone.redstonetools.features.arguments.serializers; +import com.google.auto.service.AutoService; import com.mojang.brigadier.arguments.ArgumentType; import com.mojang.brigadier.arguments.StringArgumentType; import net.minecraft.command.CommandRegistryAccess; import net.minecraft.command.argument.serialize.ArgumentSerializer; +@AutoService(GenericArgumentType.class) public class StringSerializer extends StringBrigadierSerializer { private static final StringSerializer INSTANCE_WORD = new StringSerializer(StringArgumentType.word()); diff --git a/src/main/java/tools/redstone/redstonetools/utils/ReflectionUtils.java b/src/main/java/tools/redstone/redstonetools/utils/ReflectionUtils.java index d1f54a95..eaab5ad7 100644 --- a/src/main/java/tools/redstone/redstonetools/utils/ReflectionUtils.java +++ b/src/main/java/tools/redstone/redstonetools/utils/ReflectionUtils.java @@ -1,25 +1,9 @@ package tools.redstone.redstonetools.utils; -import static tools.redstone.redstonetools.RedstoneToolsClient.REFLECTIONS; - -import java.io.IOException; -import java.lang.invoke.MethodHandles; -import java.lang.reflect.Field; -import java.lang.reflect.Modifier; -import java.net.URL; -import java.util.Arrays; -import java.util.Enumeration; -import java.util.HashSet; -import java.util.List; -import java.util.Objects; -import java.util.Set; -import java.util.stream.Collectors; - import org.apache.commons.io.IOUtils; import org.apache.logging.log4j.LogManager; import org.apache.logging.log4j.Logger; import org.jetbrains.annotations.Nullable; - import rip.hippo.inject.DoctorModule; import sun.misc.Unsafe; import tools.redstone.redstonetools.features.AbstractFeature; @@ -27,6 +11,14 @@ import tools.redstone.redstonetools.features.arguments.Argument; import tools.redstone.redstonetools.features.arguments.serializers.GenericArgumentType; +import java.io.IOException; +import java.lang.invoke.MethodHandles; +import java.lang.reflect.Field; +import java.lang.reflect.Modifier; +import java.net.URL; +import java.util.*; +import java.util.stream.Collectors; + public class ReflectionUtils { private static final Logger LOGGER = LogManager.getLogger(); private static DoctorModule[] modules; @@ -81,8 +73,14 @@ public static DoctorModule[] getModules() { public static Set> getAllArguments() { if (arguments == null) { - arguments = REFLECTIONS.getSubTypesOf(GenericArgumentType.class).stream() - .filter(argument -> !Modifier.isAbstract(argument.getModifiers())).collect(Collectors.toSet()); + try { + arguments = findClasses(GenericArgumentType.class) + .stream() + .filter(argument -> !Modifier.isAbstract(argument.getModifiers())) + .collect(Collectors.toSet()); + } catch (IOException e) { + throw new RuntimeException(e); + } } return arguments; @@ -99,7 +97,7 @@ public static Set getFeatures() { return features; } - private static Set serviceLoad(Class clazz) throws IOException { + public static Set> findClasses(Class clazz) throws IOException { ClassLoader cl = ReflectionUtils.class.getClassLoader(); Enumeration serviceFiles = cl.getResources("META-INF/services/" + clazz.getName()); Set classNames = new HashSet<>(); @@ -109,11 +107,19 @@ private static Set serviceLoad(Class clazz) throws IOExcepti classNames.addAll(IOUtils.readLines(reader, "UTF-8")); } } - return classNames.stream() + //noinspection unchecked + return (Set>) classNames.stream() .filter(it -> !it.isEmpty() && !it.isBlank()) .map(ReflectionUtils::loadClass) .filter(Objects::nonNull) .filter(clazz::isAssignableFrom) + .map(clazz::cast) + .collect(Collectors.toSet()); + } + + private static Set serviceLoad(Class clazz) throws IOException { + return findClasses(clazz) + .stream() .map(it -> { try { return it.getDeclaredConstructor().newInstance(); From 5584f6ac6c58da9b3082627d5dbd96f8914d6781 Mon Sep 17 00:00:00 2001 From: Killian Date: Sun, 28 Jan 2024 18:29:42 +0100 Subject: [PATCH 28/29] =?UTF-8?q?=F0=9F=90=9B=20fix(ReflectionUtils):=20do?= =?UTF-8?q?n't=20crash=20lol?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../tools/redstone/redstonetools/utils/ReflectionUtils.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/main/java/tools/redstone/redstonetools/utils/ReflectionUtils.java b/src/main/java/tools/redstone/redstonetools/utils/ReflectionUtils.java index eaab5ad7..5792620a 100644 --- a/src/main/java/tools/redstone/redstonetools/utils/ReflectionUtils.java +++ b/src/main/java/tools/redstone/redstonetools/utils/ReflectionUtils.java @@ -108,12 +108,12 @@ public static Set> findClasses(Class clazz) throws IOE } } //noinspection unchecked - return (Set>) classNames.stream() + return classNames.stream() .filter(it -> !it.isEmpty() && !it.isBlank()) .map(ReflectionUtils::loadClass) .filter(Objects::nonNull) .filter(clazz::isAssignableFrom) - .map(clazz::cast) + .map(it -> (Class) it) .collect(Collectors.toSet()); } From 995f8aaac49ff6ce330eba0b2dc2a6e907ce8f86 Mon Sep 17 00:00:00 2001 From: rugmj Date: Sun, 28 Jan 2024 19:33:14 +0000 Subject: [PATCH 29/29] fixes mod version --- gradle.properties | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/gradle.properties b/gradle.properties index f2aaaecb..0cd069fc 100644 --- a/gradle.properties +++ b/gradle.properties @@ -9,7 +9,7 @@ org.gradle.parallel=true loader_version=0.15.3 # Mod Properties - mod_version = 1.20.4-1.0.0 + mod_version = 1.20.4-2.0.0 maven_group = tools.redstone archives_base_name = redstonetools