From cf6a14f5d9f55ec408e8519d17d93aad88d3daed Mon Sep 17 00:00:00 2001 From: Tschipp <11649893+Tschipp@users.noreply.github.com> Date: Wed, 16 Nov 2022 09:23:51 -0800 Subject: [PATCH] More updates to joint fabric-forge build --- .idea/scopes/Fabric_sources.xml | 3 - .idea/scopes/Forge_sources.xml | 3 - .../main/java/tschipp/carryon/Constants.java | 10 + .../client/render/CarriedObjectRender.java | 88 ++++- .../client/render/CarryRenderHelper.java | 92 ++++++ .../carryon/common/carry/ListHandler.java | 194 +++++++++++ .../carryon/common/carry/PickupHandler.java | 67 +++- .../common/carry/PlacementHandler.java | 18 +- .../carryon/common/config/CarryConfig.java | 311 ++++++++++++++++++ .../carryon/config/AnnotationData.java | 24 ++ .../tschipp/carryon/config/BuiltCategory.java | 37 +++ .../tschipp/carryon/config/BuiltConfig.java | 11 + .../tschipp/carryon/config/ConfigLoader.java | 61 ++++ .../tschipp/carryon/config/PropertyData.java | 59 ++++ .../tschipp/carryon/config/PropertyType.java | 9 + .../carryon/config/annotations/Category.java | 12 + .../carryon/config/annotations/Config.java | 12 + .../carryon/config/annotations/Property.java | 24 ++ .../carryon/mixin/HumanoidModelMixin.java | 55 ++++ .../tschipp/carryon/mixin/PlayerMixin.java | 1 + .../platform/services/IPlatformHelper.java | 4 + .../main/resources/assets/carryon/logo.png | Bin 0 -> 173666 bytes Common/src/main/resources/carryon.mixins.json | 3 +- .../tschipp/carryon/CarryOnFabricMod.java | 12 + .../config/fabric/ConfigLoaderImpl.java | 131 ++++++++ .../tschipp/carryon/events/ClientEvents.java | 4 + .../tschipp/carryon/events/CommonEvents.java | 75 +++++ .../platform/FabricPlatformHelper.java | 7 + Fabric/src/main/resources/fabric.mod.json | 14 +- .../java/tschipp/carryon/CarryOnForge.java | 3 + .../config/forge/ConfigLoaderImpl.java | 102 ++++++ .../tschipp/carryon/events/ClientEvents.java | 3 +- .../tschipp/carryon/events/CommonEvents.java | 13 +- .../carryon/platform/ForgePlatformHelper.java | 7 + 34 files changed, 1417 insertions(+), 52 deletions(-) delete mode 100644 .idea/scopes/Fabric_sources.xml delete mode 100644 .idea/scopes/Forge_sources.xml create mode 100644 Common/src/main/java/tschipp/carryon/common/carry/ListHandler.java create mode 100644 Common/src/main/java/tschipp/carryon/common/config/CarryConfig.java create mode 100644 Common/src/main/java/tschipp/carryon/config/AnnotationData.java create mode 100644 Common/src/main/java/tschipp/carryon/config/BuiltCategory.java create mode 100644 Common/src/main/java/tschipp/carryon/config/BuiltConfig.java create mode 100644 Common/src/main/java/tschipp/carryon/config/ConfigLoader.java create mode 100644 Common/src/main/java/tschipp/carryon/config/PropertyData.java create mode 100644 Common/src/main/java/tschipp/carryon/config/PropertyType.java create mode 100644 Common/src/main/java/tschipp/carryon/config/annotations/Category.java create mode 100644 Common/src/main/java/tschipp/carryon/config/annotations/Config.java create mode 100644 Common/src/main/java/tschipp/carryon/config/annotations/Property.java create mode 100644 Common/src/main/java/tschipp/carryon/mixin/HumanoidModelMixin.java create mode 100644 Common/src/main/resources/assets/carryon/logo.png create mode 100644 Fabric/src/main/java/tschipp/carryon/config/fabric/ConfigLoaderImpl.java create mode 100644 Fabric/src/main/java/tschipp/carryon/events/ClientEvents.java create mode 100644 Fabric/src/main/java/tschipp/carryon/events/CommonEvents.java create mode 100644 Forge/src/main/java/tschipp/carryon/config/forge/ConfigLoaderImpl.java diff --git a/.idea/scopes/Fabric_sources.xml b/.idea/scopes/Fabric_sources.xml deleted file mode 100644 index 0448412..0000000 --- a/.idea/scopes/Fabric_sources.xml +++ /dev/null @@ -1,3 +0,0 @@ - - - \ No newline at end of file diff --git a/.idea/scopes/Forge_sources.xml b/.idea/scopes/Forge_sources.xml deleted file mode 100644 index 7b5f24d..0000000 --- a/.idea/scopes/Forge_sources.xml +++ /dev/null @@ -1,3 +0,0 @@ - - - \ No newline at end of file diff --git a/Common/src/main/java/tschipp/carryon/Constants.java b/Common/src/main/java/tschipp/carryon/Constants.java index c7ce9f8..4410baa 100644 --- a/Common/src/main/java/tschipp/carryon/Constants.java +++ b/Common/src/main/java/tschipp/carryon/Constants.java @@ -2,10 +2,20 @@ package tschipp.carryon; import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import tschipp.carryon.common.config.CarryConfig; +import tschipp.carryon.config.ConfigLoader; public class Constants { public static final String MOD_ID = "carryon"; public static final String MOD_NAME = "Carry On"; public static final Logger LOG = LoggerFactory.getLogger(MOD_NAME); + + public static final CarryConfig.Common COMMON_CONFIG = new CarryConfig.Common(); + public static final CarryConfig.Client CLIENT_CONFIG = new CarryConfig.Client(); + + static { + ConfigLoader.registerConfig(COMMON_CONFIG); + ConfigLoader.registerConfig(CLIENT_CONFIG); + } } \ No newline at end of file diff --git a/Common/src/main/java/tschipp/carryon/client/render/CarriedObjectRender.java b/Common/src/main/java/tschipp/carryon/client/render/CarriedObjectRender.java index d0f9163..1cfeacd 100644 --- a/Common/src/main/java/tschipp/carryon/client/render/CarriedObjectRender.java +++ b/Common/src/main/java/tschipp/carryon/client/render/CarriedObjectRender.java @@ -5,27 +5,36 @@ import com.mojang.blaze3d.vertex.PoseStack; import com.mojang.math.Vector3f; import net.minecraft.client.Minecraft; import net.minecraft.client.renderer.MultiBufferSource; +import net.minecraft.client.renderer.entity.EntityRenderDispatcher; import net.minecraft.client.resources.model.BakedModel; +import net.minecraft.nbt.CompoundTag; +import net.minecraft.world.entity.Entity; +import net.minecraft.world.entity.EntityType; +import net.minecraft.world.entity.LivingEntity; import net.minecraft.world.entity.player.Player; import net.minecraft.world.inventory.InventoryMenu; import net.minecraft.world.item.ItemStack; import net.minecraft.world.level.block.Block; import net.minecraft.world.level.block.Blocks; import net.minecraft.world.level.block.state.BlockState; +import net.minecraft.world.phys.Vec3; +import tschipp.carryon.Constants; import tschipp.carryon.common.carry.CarryOnData; import tschipp.carryon.common.carry.CarryOnData.CarryType; import tschipp.carryon.common.carry.CarryOnDataManager; +import java.util.Optional; + public class CarriedObjectRender { - public static boolean drawFirstPerson(Player player, MultiBufferSource buffer, PoseStack matrix, int light) + public static boolean drawFirstPerson(Player player, MultiBufferSource buffer, PoseStack matrix, int light, float partialTicks) { CarryOnData carry = CarryOnDataManager.getCarryData(player); if(carry.isCarrying(CarryType.BLOCK)) drawFirstPersonBlock(player, buffer, matrix, light, carry.getBlock()); - else - ; + else if (carry.isCarrying(CarryType.ENTITY)) + drawFirstPersonEntity(player, buffer, matrix, light, carry.getEntity(player.level), partialTicks); return carry.isCarrying(); } @@ -39,8 +48,7 @@ public class CarriedObjectRender RenderSystem.disableCull(); int perspective = CarryRenderHelper.getPerspective(); - //TODO: FacePlayer config - if (isChest(state.getBlock())) { + if (Constants.CLIENT_CONFIG.facePlayer && isChest(state.getBlock())) { matrix.mulPose(Vector3f.YP.rotationDegrees(180)); matrix.mulPose(Vector3f.XN.rotationDegrees(8)); } else { @@ -74,8 +82,76 @@ public class CarriedObjectRender matrix.popPose(); } + private static void drawFirstPersonEntity(Player player, MultiBufferSource buffer, PoseStack matrix, int light, Entity entity, float partialTicks) { + EntityRenderDispatcher manager = Minecraft.getInstance().getEntityRenderDispatcher(); - public static boolean isChest(Block block) + if (entity != null) + { + Vec3 playerpos = CarryRenderHelper.getExactPos(player, partialTicks); + + entity.setPos(playerpos.x, playerpos.y, playerpos.z); + entity.xRotO = 0.0f; + entity.yRotO = 0.0f; + entity.setYHeadRot(0.0f); + + float height = entity.getBbHeight(); + float width = entity.getBbWidth(); + + matrix.pushPose(); + matrix.scale(0.8f, 0.8f, 0.8f); + matrix.mulPose(Vector3f.YP.rotationDegrees(180)); + matrix.translate(0.0, -height - .1, width + 0.1); + + // RenderSystem.enableAlphaTest(); + + // Lighting.en + manager.setRenderShadow(false); + + //TODO: Scripts + /* + CarryOnOverride carryOverride = ScriptChecker.getOverride(player); + if (carryOverride != null) + { + CarryRenderHelper.performOverrideTransformation(matrix, carryOverride); + + String entityname = carryOverride.getRenderNameEntity(); + if (entityname != null) + { + Entity newEntity = null; + + Optional> type = EntityType.byString(entityname); + if (type.isPresent()) + newEntity = type.get().create(level); + + if (newEntity != null) + { + CompoundTag nbttag = carryOverride.getRenderNBT(); + if (nbttag != null) + newEntity.deserializeNBT(nbttag); + entity = newEntity; + entity.setPos(playerpos.x, playerpos.y, playerpos.z); + entity.xRotO = 0.0f; + entity.yRotO = 0.0f; + entity.setYHeadRot(0.0f); + } + } + } + */ + + + if (entity instanceof LivingEntity) + ((LivingEntity) entity).hurtTime = 0; + + manager.render(entity, 0, 0, 0, 0f, 0, matrix, buffer, light); + manager.setRenderShadow(true); + } + + // RenderSystem.disableAlphaTest(); + matrix.popPose(); + } + + + private static boolean isChest(Block block) { return block == Blocks.CHEST || block == Blocks.ENDER_CHEST || block == Blocks.TRAPPED_CHEST; } diff --git a/Common/src/main/java/tschipp/carryon/client/render/CarryRenderHelper.java b/Common/src/main/java/tschipp/carryon/client/render/CarryRenderHelper.java index 69c37d5..0dab93c 100644 --- a/Common/src/main/java/tschipp/carryon/client/render/CarryRenderHelper.java +++ b/Common/src/main/java/tschipp/carryon/client/render/CarryRenderHelper.java @@ -10,8 +10,11 @@ import net.minecraft.client.renderer.entity.ItemRenderer; import net.minecraft.client.renderer.texture.OverlayTexture; import net.minecraft.client.resources.model.BakedModel; import net.minecraft.nbt.CompoundTag; +import net.minecraft.util.Mth; import net.minecraft.world.entity.Entity; import net.minecraft.world.entity.LivingEntity; +import net.minecraft.world.entity.Pose; +import net.minecraft.world.entity.player.Player; import net.minecraft.world.item.ItemStack; import net.minecraft.world.level.block.state.BlockState; import net.minecraft.world.phys.Vec3; @@ -36,6 +39,87 @@ public class CarryRenderHelper return Vector3f.YP.rotationDegrees(getExactBodyRotationDegrees(entity, partialticks)); } + public static void applyGeneralTransformations(Player player, float partialticks, PoseStack matrix) + { + int perspective = CarryRenderHelper.getPerspective(); + Quaternion playerrot = CarryRenderHelper.getExactBodyRotation(player, partialticks); + Vec3 playerpos = CarryRenderHelper.getExactPos(player, partialticks); + Vec3 cameraPos = Minecraft.getInstance().gameRenderer.getMainCamera().getPosition(); + Vec3 offset = playerpos.subtract(cameraPos); + Pose pose = player.getPose(); + + matrix.pushPose(); + matrix.translate(offset.x, offset.y, offset.z); + + if (perspective == 2) + playerrot.mul(Vector3f.YP.rotationDegrees(180)); + matrix.mulPose(playerrot); + + matrix.pushPose(); + matrix.scale(0.6f, 0.6f, 0.6f); + + if (perspective == 2) + matrix.translate(0, 0, -1.35); + + if (doSneakCheck(player)) + { + matrix.translate(0, -0.4, 0); + } + + if (pose == Pose.SWIMMING) + { + float f = player.getSwimAmount(partialticks); + float f3 = player.isInWater() ? -90.0F - player.xRotO : -90.0F; + float f4 = Mth.lerp(f, 0.0F, f3); + if (perspective == 2) + { + matrix.translate(0, 0, 1.35); + matrix.mulPose(Vector3f.XP.rotationDegrees(f4)); + } + else + matrix.mulPose(Vector3f.XN.rotationDegrees(f4)); + + matrix.translate(0, -1.5, -1.848); + if (perspective == 2) + matrix.translate(0, 0, 2.38); + } + + if (pose == Pose.FALL_FLYING) + { + float f1 = player.getFallFlyingTicks() + partialticks; + float f2 = Mth.clamp(f1 * f1 / 100.0F, 0.0F, 1.0F); + if (!player.isAutoSpinAttack()) + { + if (perspective == 2) + matrix.translate(0, 0, 1.35); + + if (perspective == 2) + matrix.mulPose(Vector3f.XP.rotationDegrees(f2 * (-90.0F - player.xRotO))); + else + matrix.mulPose(Vector3f.XN.rotationDegrees(f2 * (-90.0F - player.xRotO))); + } + + Vec3 Vector3d = player.getViewVector(partialticks); + Vec3 Vector3d1 = player.getDeltaMovement(); + double d0 = Vector3d1.horizontalDistanceSqr(); + double d1 = Vector3d1.horizontalDistanceSqr(); + if (d0 > 0.0D && d1 > 0.0D) + { + double d2 = (Vector3d1.x * Vector3d.x + Vector3d1.z * Vector3d.z) / (Math.sqrt(d0) * Math.sqrt(d1)); + double d3 = Vector3d1.x * Vector3d.z - Vector3d1.z * Vector3d.x; + + matrix.mulPose(Vector3f.YP.rotation((float) (Math.signum(d3) * Math.acos(d2)))); + } + + if (perspective != 2) + matrix.translate(0, 0, -1.35); + matrix.translate(0, -0.2, 0); + } + + matrix.translate(0, 1.6, 0.65); + } + + //TODO: Scripting // public static void performOverrideTransformation(PoseStack matrix, CarryOnOverride override) // { @@ -84,4 +168,12 @@ public class CarryRenderHelper return 1; return 2; } + + public static boolean doSneakCheck(Player player) + { + if (player.getAbilities().flying) + return false; + + return player.isShiftKeyDown() || player.isCrouching(); + } } diff --git a/Common/src/main/java/tschipp/carryon/common/carry/ListHandler.java b/Common/src/main/java/tschipp/carryon/common/carry/ListHandler.java new file mode 100644 index 0000000..7773f47 --- /dev/null +++ b/Common/src/main/java/tschipp/carryon/common/carry/ListHandler.java @@ -0,0 +1,194 @@ +package tschipp.carryon.common.carry; + +import net.minecraft.core.Registry; +import net.minecraft.resources.ResourceLocation; +import net.minecraft.tags.TagKey; +import net.minecraft.world.entity.Entity; +import net.minecraft.world.entity.EntityType; +import net.minecraft.world.level.block.Block; +import net.minecraft.world.level.block.state.properties.Property; +import tschipp.carryon.Constants; + +import java.util.*; +import java.util.stream.Collectors; + +public class ListHandler { + + private static Set FORBIDDEN_TILES = new HashSet<>(); + private static Set FORBIDDEN_ENTITIES = new HashSet<>(); + private static Set ALLOWED_ENTITIES = new HashSet<>(); + private static Set ALLOWED_TILES = new HashSet<>(); + private static Set FORBIDDEN_STACKING = new HashSet<>(); + private static Set ALLOWED_STACKING = new HashSet<>(); + + private static List> FORBIDDEN_TILES_TAGS = new ArrayList<>(); + private static List>> FORBIDDEN_ENTITIES_TAGS = new ArrayList<>(); + private static List>> ALLOWED_ENTITIES_TAGS = new ArrayList<>(); + private static List> ALLOWED_TILES_TAGS = new ArrayList<>(); + private static List>> FORBIDDEN_STACKING_TAGS = new ArrayList<>(); + private static List>> ALLOWED_STACKING_TAGS = new ArrayList<>(); + + + private static Set> PROPERTY_EXCEPTION_CLASSES = new HashSet<>(); + + + public static boolean isPermitted(Block block) + { + if(Constants.COMMON_CONFIG.settings.useWhitelistBlocks) + return doCheck(block, ALLOWED_TILES, ALLOWED_TILES_TAGS); + else + return !doCheck(block, FORBIDDEN_TILES, FORBIDDEN_TILES_TAGS); + } + + public static boolean isPermitted(Entity entity) + { + if(Constants.COMMON_CONFIG.settings.useWhitelistEntities) + return doCheck(entity, ALLOWED_ENTITIES, ALLOWED_ENTITIES_TAGS); + else + return !doCheck(entity, FORBIDDEN_ENTITIES, FORBIDDEN_ENTITIES_TAGS); + } + + public static boolean isStackingPermitted(Entity entity) + { + if(Constants.COMMON_CONFIG.settings.useWhitelistStacking) + return doCheck(entity, ALLOWED_STACKING, ALLOWED_STACKING_TAGS); + else + return !doCheck(entity, FORBIDDEN_STACKING, FORBIDDEN_STACKING_TAGS); + } + + public static boolean isPropertyException(Property prop) + { + return PROPERTY_EXCEPTION_CLASSES.contains(prop.getValueClass()); + } + + private static boolean doCheck(Block block, Set regular, List> tags) + { + String name = Registry.BLOCK.getKey(block).toString(); + if(regular.contains(name)) + return true; + for(TagKey tag : tags) + if(block.defaultBlockState().is(tag)) + return true; + return false; + } + + private static boolean doCheck(Entity entity, Set regular, List>> tags) + { + String name = Registry.ENTITY_TYPE.getKey(entity.getType()).toString(); + if(regular.contains(name)) + return true; + for(TagKey> tag : tags) + if(entity.getType().is(tag)) + return true; + return false; + } + + public static void initConfigLists() + { + FORBIDDEN_ENTITIES.clear(); + FORBIDDEN_ENTITIES_TAGS.clear(); + FORBIDDEN_STACKING.clear(); + FORBIDDEN_STACKING_TAGS.clear(); + FORBIDDEN_TILES.clear(); + FORBIDDEN_TILES_TAGS.clear(); + ALLOWED_ENTITIES.clear(); + ALLOWED_ENTITIES_TAGS.clear(); + ALLOWED_STACKING.clear(); + ALLOWED_STACKING_TAGS.clear(); + ALLOWED_TILES.clear(); + ALLOWED_TILES_TAGS.clear(); + PROPERTY_EXCEPTION_CLASSES.clear(); + + Map> blocktags = Registry.BLOCK.getTagNames().collect(Collectors.toMap(t -> t.location(), t -> t)); + Map>> entitytags = Registry.ENTITY_TYPE.getTagNames().collect(Collectors.toMap(t -> t.location(), t -> t)); + + List forbidden = new ArrayList<>(List.of(Constants.COMMON_CONFIG.blacklist.forbiddenTiles)); + forbidden.add("#carryon:block_blacklist"); + addWithWildcards(forbidden, FORBIDDEN_TILES, Registry.BLOCK, blocktags, FORBIDDEN_TILES_TAGS); + + List forbiddenEntity = new ArrayList<>(List.of(Constants.COMMON_CONFIG.blacklist.forbiddenEntities)); + forbiddenEntity.add("#carryon:entity_blacklist"); + addWithWildcards(forbiddenEntity, FORBIDDEN_ENTITIES, Registry.ENTITY_TYPE, entitytags, FORBIDDEN_ENTITIES_TAGS); + + List allowedEntities = new ArrayList<>(List.of(Constants.COMMON_CONFIG.whitelist.allowedEntities)); + allowedEntities.add("#carryon:entity_whitelist"); + addWithWildcards(allowedEntities, ALLOWED_ENTITIES, Registry.ENTITY_TYPE, entitytags, ALLOWED_ENTITIES_TAGS); + + List allowedBlocks = new ArrayList<>(List.of(Constants.COMMON_CONFIG.whitelist.allowedBlocks)); + allowedBlocks.add("#carryon:block_whitelist"); + addWithWildcards(allowedBlocks, ALLOWED_TILES, Registry.BLOCK, blocktags, ALLOWED_TILES_TAGS); + + List forbiddenStacking = new ArrayList<>(List.of(Constants.COMMON_CONFIG.blacklist.forbiddenStacking)); + forbiddenStacking.add("#carryon:stacking_blacklist"); + addWithWildcards(forbiddenStacking, FORBIDDEN_STACKING, Registry.ENTITY_TYPE, entitytags, FORBIDDEN_STACKING_TAGS); + + List allowedStacking = new ArrayList<>(List.of(Constants.COMMON_CONFIG.whitelist.allowedStacking)); + allowedStacking.add("#carryon:stacking_whitelist"); + addWithWildcards(allowedStacking, ALLOWED_STACKING, Registry.ENTITY_TYPE, entitytags, ALLOWED_STACKING_TAGS); + + for(String propString : Constants.COMMON_CONFIG.settings.placementStateExceptions) + { + if(!propString.contains("[") || !propString.contains("]")) + continue; + String name = propString.substring(0, propString.indexOf("[")); + String propName = propString.substring(propString.indexOf("[") + 1, propString.indexOf("]")); + Block blk = Registry.BLOCK.get(new ResourceLocation(name)); + for(Property prop : blk.defaultBlockState().getProperties()) + { + if(prop.getName().equals(propName)) + PROPERTY_EXCEPTION_CLASSES.add(prop.getValueClass()); + } + } + + + } + + private static void addTag(String tag, Map> tagMap, List> tags) { + String sub = tag.substring(1); + TagKey t = tagMap.get(new ResourceLocation(sub)); + if (t != null) + tags.add(t); + } + + private static void addWithWildcards(List entries, Set toAddTo, Registry registry, Map> tags, List> toAddTags) { + + ResourceLocation[] keys = registry.keySet().toArray(new ResourceLocation[0]); + for (int i = 0; i < entries.size(); i++) + { + String curr = entries.get(i); + if (!curr.startsWith("#")) + { + if (curr.contains("*")) + { + String[] filter = curr.replace("*", ",").split(","); + + for (ResourceLocation key : keys) + { + if (containsAll(key.toString(), filter)) + { + toAddTo.add(key.toString()); + } + } + } + else + toAddTo.add(curr); + } + else + addTag(curr, tags, toAddTags); + } + } + + public static boolean containsAll(String str, String... strings) + { + boolean containsAll = true; + + for (String s : strings) + { + if (!str.contains(s)) + containsAll = false; + } + + return containsAll; + } + +} diff --git a/Common/src/main/java/tschipp/carryon/common/carry/PickupHandler.java b/Common/src/main/java/tschipp/carryon/common/carry/PickupHandler.java index a08c452..e7c185c 100644 --- a/Common/src/main/java/tschipp/carryon/common/carry/PickupHandler.java +++ b/Common/src/main/java/tschipp/carryon/common/carry/PickupHandler.java @@ -1,12 +1,15 @@ package tschipp.carryon.common.carry; import net.minecraft.core.BlockPos; +import net.minecraft.nbt.CompoundTag; import net.minecraft.server.level.ServerPlayer; import net.minecraft.sounds.SoundEvents; import net.minecraft.sounds.SoundSource; import net.minecraft.world.InteractionHand; +import net.minecraft.world.entity.AgeableMob; import net.minecraft.world.entity.Entity; import net.minecraft.world.entity.Entity.RemovalReason; +import net.minecraft.world.entity.MobCategory; import net.minecraft.world.entity.TamableAnimal; import net.minecraft.world.entity.animal.Animal; import net.minecraft.world.entity.player.Player; @@ -15,15 +18,12 @@ import net.minecraft.world.level.Level; import net.minecraft.world.level.block.entity.BlockEntity; import net.minecraft.world.level.block.state.BlockState; import net.minecraft.world.phys.Vec3; +import tschipp.carryon.Constants; import java.util.UUID; public class PickupHandler { - //TODO: CONFIG - private static final double range = 2.0; - - public static boolean canCarryGeneral(ServerPlayer player, Vec3 pos) { //TODO: Check carry key @@ -33,13 +33,14 @@ public class PickupHandler { if(!player.getMainHandItem().isEmpty() || !player.getOffhandItem().isEmpty()) return false; - if(player.position().distanceTo(pos) >= range) + if(player.position().distanceTo(pos) > Constants.COMMON_CONFIG.settings.maxDistance) return false; CarryOnData carry = CarryOnDataManager.getCarryData(player); if(carry.isCarrying()) return false; + //Needed so that we don't pick up and place in the same tick if(player.tickCount == carry.getTick()) return false; @@ -47,6 +48,7 @@ public class PickupHandler { return false; + return true; } @@ -56,12 +58,33 @@ public class PickupHandler { if(!canCarryGeneral(player, Vec3.atCenterOf(pos))) return false; - //TODO: Whitelist/Blacklist checks - - CarryOnData carry = CarryOnDataManager.getCarryData(player); BlockEntity blockEntity = level.getBlockEntity(pos); BlockState state = level.getBlockState(pos); + + if(!ListHandler.isPermitted(state.getBlock())) + return false; + + if(state.getDestroySpeed(level, pos) == -1 && !player.isCreative()) + return false; + + if(blockEntity == null && !Constants.COMMON_CONFIG.settings.pickupAllBlocks) + return false; + + //Check if TE is locked + if(blockEntity != null) + { + CompoundTag nbt = blockEntity.saveWithId(); + if(nbt.contains("Lock") && !nbt.getString("Lock").equals("")) + return false; + } + + //TODO: Script conditions + + //TODO: Gamestages conditions check + + //TODO: Protections + carry.setBlock(state, blockEntity); level.removeBlockEntity(pos); @@ -94,19 +117,37 @@ public class PickupHandler { return false; } - if (entity instanceof Animal) - ((Animal) entity).dropLeash(true, true); + if(!ListHandler.isPermitted(entity)) + { + //We can pick up baby animals even if the grown up animal is blacklisted. + if(!(entity instanceof AgeableMob ageableMob && Constants.COMMON_CONFIG.settings.allowBabies && (ageableMob.getAge() < 0 || ageableMob.isBaby()))) + return false; + } - //TODO: White and blacklist + //Non-Creative only guards + if(!player.isCreative()) + { + if(!Constants.COMMON_CONFIG.settings.pickupHostileMobs && entity.getType().getCategory() == MobCategory.MONSTER) + return false; + + if(Constants.COMMON_CONFIG.settings.maxEntityHeight > entity.getBbHeight() || Constants.COMMON_CONFIG.settings.maxEntityWidth > entity.getBbWidth()) + return false; + } + + //TODO: Script conditions + + //TODO: Gamestages conditions check //TODO: Protections CarryOnData carry = CarryOnDataManager.getCarryData(player); - entity.ejectPassengers(); + if (entity instanceof Animal animal) + animal.dropLeash(true, true); + carry.setEntity(entity); - entity.remove(RemovalReason.DISCARDED); + entity.remove(RemovalReason.UNLOADED_WITH_PLAYER); player.level.playSound(null, player.getOnPos(), SoundEvents.ARMOR_EQUIP_GENERIC, SoundSource.AMBIENT, 1.0f, 0.5f); CarryOnDataManager.setCarryData(player, carry); diff --git a/Common/src/main/java/tschipp/carryon/common/carry/PlacementHandler.java b/Common/src/main/java/tschipp/carryon/common/carry/PlacementHandler.java index 34dbe60..dccc4c8 100644 --- a/Common/src/main/java/tschipp/carryon/common/carry/PlacementHandler.java +++ b/Common/src/main/java/tschipp/carryon/common/carry/PlacementHandler.java @@ -2,7 +2,6 @@ package tschipp.carryon.common.carry; import net.minecraft.core.BlockPos; import net.minecraft.core.Direction; -import net.minecraft.core.Direction.Axis; import net.minecraft.server.level.ServerPlayer; import net.minecraft.sounds.SoundSource; import net.minecraft.world.InteractionHand; @@ -16,7 +15,6 @@ import net.minecraft.world.level.block.entity.BlockEntity; import net.minecraft.world.level.block.state.BlockState; import net.minecraft.world.level.block.state.properties.BlockStateProperties; import net.minecraft.world.level.block.state.properties.DirectionProperty; -import net.minecraft.world.level.block.state.properties.EnumProperty; import net.minecraft.world.level.block.state.properties.Property; import net.minecraft.world.phys.BlockHitResult; import net.minecraft.world.phys.Vec3; @@ -55,7 +53,7 @@ public class PlacementHandler return false; state = getPlacementState(state, player, context, pos); - boolean doPlace = placementCallback == null ? true : placementCallback.apply(pos, state); + boolean doPlace = placementCallback == null || placementCallback.apply(pos, state); if (!doPlace) return false; @@ -80,12 +78,12 @@ public class PlacementHandler if (prop instanceof DirectionProperty) { state = updateProperty(state, placementState, prop); } - if (prop instanceof EnumProperty) { - if (state.getValue(prop) instanceof Axis) - state = updateProperty(state, placementState, prop); + if (prop.getValueClass() == Direction.Axis.class) { + state = updateProperty(state, placementState, prop); } - //TODO: Add config for state variant names, which should be taken from the placementState - if (prop.getName().equals("type")) { + + //This is needed for certain blocks, otherwise we get problems like chests not connecting + if (ListHandler.isPropertyException(prop)) { state = updateProperty(state, placementState, prop); } } @@ -100,7 +98,7 @@ public class PlacementHandler return state; } - private static , V extends T> BlockState updateProperty(BlockState state, BlockState otherState, Property prop) + private static > BlockState updateProperty(BlockState state, BlockState otherState, Property prop) { var val = otherState.getValue(prop); return state.setValue(prop, val); @@ -127,7 +125,7 @@ public class PlacementHandler Entity entity = carry.getEntity(level); entity.setPos(placementPos); - boolean doPlace = placementCallback == null ? true : placementCallback.apply(placementPos, entity); + boolean doPlace = placementCallback == null || placementCallback.apply(placementPos, entity); if (!doPlace) return false; diff --git a/Common/src/main/java/tschipp/carryon/common/config/CarryConfig.java b/Common/src/main/java/tschipp/carryon/common/config/CarryConfig.java new file mode 100644 index 0000000..1fff280 --- /dev/null +++ b/Common/src/main/java/tschipp/carryon/common/config/CarryConfig.java @@ -0,0 +1,311 @@ +package tschipp.carryon.common.config; + +import tschipp.carryon.config.PropertyType; +import tschipp.carryon.config.annotations.Category; +import tschipp.carryon.config.annotations.Config; +import tschipp.carryon.config.annotations.Property; + +public class CarryConfig { + + @Config("carryon-common") + public static class Common { + //Settings + @Property( + type = PropertyType.CATEGORY, + description = "General Settings" + ) + public Settings settings = new Settings(); + + @Category("settings") + public static class Settings { + @Property( + type = PropertyType.DOUBLE, + description = "Maximum distance from where Blocks and Entities can be picked up", + minD = 0 + ) + public double maxDistance = 2.5; + + @Property( + type = PropertyType.DOUBLE, + description = "Max width of entities that can be picked up in survival mode", + minD = 0, + maxD = 10 + ) + public double maxEntityWidth = 1.5; + + @Property( + type = PropertyType.DOUBLE, + description = "Max height of entities that can be picked up in survival mode", + minD = 0, + maxD = 10 + ) + public double maxEntityHeight = 2.5; + + @Property( + type = PropertyType.DOUBLE, + description = "Slowness multiplier for blocks", + minD = 0 + ) + public double blockSlownessMultiplier = 1; + + @Property( + type = PropertyType.DOUBLE, + description = "Slowness multiplier for entities", + minD = 0 + ) + public double entitySlownessMultiplier = 1; + + @Property( + type = PropertyType.INT, + description = "Maximum stack limit for entities", + min = 1 + ) + public int maxEntityStackLimit = 10; + + @Property( + type = PropertyType.BOOLEAN, + description = "More complex Tile Entities slow down the player more" + ) + public boolean heavyTiles = true; + + @Property( + type = PropertyType.BOOLEAN, + description = "Allow all blocks to be picked up, not just Tile Entites. White/Blacklist will still be respected." + ) + public boolean pickupAllBlocks = false; + + @Property( + type = PropertyType.BOOLEAN, + description = "Whether Blocks and Entities slow the creative player down when carried" + ) + public boolean slownessInCreative = true; + + @Property( + type = PropertyType.BOOLEAN, + description = "Whether hostile mobs should be able to picked up in survival mode" + ) + public boolean pickupHostileMobs = false; + + @Property( + type = PropertyType.BOOLEAN, + description = "Larger Entities slow down the player more" + ) + public boolean heavyEntities = true; + + @Property( + type = PropertyType.BOOLEAN, + description = "Allow babies to be carried even when adult mob is blacklisted (or not whitelisted)" + ) + public boolean allowBabies = false; + + @Property( + type = PropertyType.BOOLEAN, + description = "Use Whitelist instead of Blacklist for Blocks" + ) + public boolean useWhitelistBlocks = false; + + @Property( + type = PropertyType.BOOLEAN, + description = "Use Whitelist instead of Blacklist for Entities" + ) + public boolean useWhitelistEntities = false; + + @Property( + type = PropertyType.BOOLEAN, + description = "Use Whitelist instead of Blacklist for Stacking" + ) + public boolean useWhitelistStacking = false; + + @Property( + type = PropertyType.BOOLEAN, + description = "Whether the player can hit blocks and entities while carrying or not" + ) + public boolean hitWhileCarrying = false; + + @Property( + type = PropertyType.BOOLEAN, + description = "Whether the player drops the carried object when hit or not" + ) + public boolean dropCarriedWhenHit = false; + + @Property( + type = PropertyType.BOOLEAN, + description = "Use custom Pickup Scripts. Having this set to false, will not allow you to run scripts, but will increase your performance" + ) + public boolean useScripts = false; + + @Property( + type = PropertyType.BOOLEAN, + description = "Allows entities to be stacked on top of each other" + ) + public boolean stackableEntities = true; + + @Property( + type = PropertyType.BOOLEAN, + description = "Whether entities' size matters when stacking or not. This means that larger entities cannot be stacked on smaller ones" + ) + public boolean entitySizeMattersStacking = true; + + @Property( + type = PropertyType.STRING_ARRAY, + description = "Usually all the block state information is retained when placing a block that was picked up. But some information is changed to a modified property, like rotation or orientation. In this list, add additional properties that should NOT be saved and instead be updated when placed. Format: modid:block[propertyname]. Note: You don't need to add an entry for every subtype of a same block. For example, we only add an entry for one type of slab, but the change is applied to all slabs." + ) + public String[] placementStateExceptions = { + "minecraft:chest[type]" + }; + } + + @Property( + type = PropertyType.CATEGORY, + description = "Whitelist. Read about the format here: https://github.com/Tschipp/CarryOn/wiki/Black---and-Whitelist-Config" + ) + + //Whitelist + public Whitelist whitelist = new Whitelist(); + @Category("whitelist") + public static class Whitelist { + @Property( + type = PropertyType.STRING_ARRAY, + description = "Entities that CAN be picked up (useWhitelistEntities must be true)" + ) + public String[] allowedEntities = {}; + + @Property( + type = PropertyType.STRING_ARRAY, + description = "Blocks that CAN be picked up (useWhitelistBlocks must be true)" + ) + public String[] allowedBlocks = {}; + + @Property( + type = PropertyType.STRING_ARRAY, + description = "Entities that CAN have other entities stacked on top of them (useWhitelistStacking must be true)" + ) + public String[] allowedStacking = {}; + } + + //Blacklist + @Property( + type = PropertyType.CATEGORY, + description = "Blacklist. Read about the format here: https://github.com/Tschipp/CarryOn/wiki/Black---and-Whitelist-Config" + ) + public Blacklist blacklist = new Blacklist(); + @Category("blacklist") + public static class Blacklist { + @Property( + type = PropertyType.STRING_ARRAY, + description = "Blocks that cannot be picked up" + ) + public String[] forbiddenTiles = { + "#forge:immovable", "#forge:relocation_not_supported", "minecraft:end_portal", + "minecraft:end_gateway", "minecraft:tall_grass", "minecraft:large_fern", "minecraft:peony", + "minecraft:rose_bush", "minecraft:lilac", "minecraft:sunflower", "minecraft:*_bed", + "minecraft:*_door", "minecraft:big_dripleaf_stem", "minecraft:waterlily", "minecraft:cake", + "minecraft:nether_portal", "minecraft:tall_seagrass", "animania:block_trough", + "animania:block_invisiblock", "colossalchests:*", "ic2:*", "bigreactors:*", "forestry:*", + "tconstruct:*", "rustic:*", "botania:*", "astralsorcery:*", "quark:colored_bed_*", + "immersiveengineering:*", "embers:block_furnace", "embers:ember_bore", + "embers:ember_activator", "embers:mixer", "embers:heat_coil", "embers:large_tank", + "embers:crystal_cell", "embers:alchemy_pedestal", "embers:boiler", "embers:combustor", + "embers:catalzyer", "embers:field_chart", "embers:inferno_forge", + "storagedrawers:framingtable", "skyresources:*", "lootbags:*", "exsartagine:*", + "aquamunda:tank", "opencomputers:*", "malisisdoors:*", "industrialforegoing:*", + "minecolonies:*", "thaumcraft:pillar*", "thaumcraft:infernal_furnace", + "thaumcraft:placeholder*", "thaumcraft:infusion_matrix", "thaumcraft:golem_builder", + "thaumcraft:thaumatorium*", "magneticraft:oil_heater", "magneticraft:solar_panel", + "magneticraft:steam_engine", "magneticraft:shelving_unit", "magneticraft:grinder", + "magneticraft:sieve", "magneticraft:solar_tower", "magneticraft:solar_mirror", + "magneticraft:container", "magneticraft:pumpjack", "magneticraft:solar_panel", + "magneticraft:refinery", "magneticraft:oil_heater", "magneticraft:hydraulic_press", + "magneticraft:multiblock_gap", "refinedstorage:*", "mcmultipart:*", "enderstorage:*", + "betterstorage:*", "practicallogistics2:*", "wearablebackpacks:*", "rftools:screen", + "rftools:creative_screen", "create:*", "magic_doorknob:*", "iceandfire:*", "ftbquests:*", + "waystones:*" + }; + + @Property( + type = PropertyType.STRING_ARRAY, + description = "Entities that cannot be picked up" + ) + public String[] forbiddenEntities = { + "minecraft:end_crystal", "minecraft:ender_dragon", "minecraft:ghast", + "minecraft:shulker", "minecraft:leash_knot", "minecraft:armor_stand", + "minecraft:item_frame", "minecraft:painting", "minecraft:shulker_bullet", + "animania:hamster", "animania:ferret*", "animania:hedgehog*", "animania:cart", + "animania:wagon", "mynko:*", "pixelmon:*", "mocreatures:*", "quark:totem", "vehicle:*" + }; + + @Property( + type = PropertyType.STRING_ARRAY, + description = "Entities that cannot have other entities stacked on top of them" + ) + public String[] forbiddenStacking = { + "minecraft:horse" + }; + } + + //Custom Pickup Conditions + @Property( + type = PropertyType.CATEGORY, + description = "Custom Pickup Conditions. Read about the format here: https://github.com/Tschipp/CarryOn/wiki/Custom-Pickup-Condition-Config" + ) + public CustomPickupConditions customPickupConditions = new CustomPickupConditions(); + @Category("customPickupConditions") + public static class CustomPickupConditions { + @Property( + type = PropertyType.STRING_ARRAY, + description = "Custom Pickup Conditions for Blocks" + ) + public String[] customPickupConditionsBlocks = {}; + + @Property( + type = PropertyType.STRING_ARRAY, + description = "Custom Pickup Conditions for Entities" + ) + public String[] customPickupConditionsEntities = {}; + } + } + + @Config("carryon-client") + public static class Client { + + @Property( + type = PropertyType.BOOLEAN, + description = "If the front of the Tile Entities should face the player or should face outward" + ) + public boolean facePlayer = false; + + @Property( + type = PropertyType.BOOLEAN, + description = "Arms should render on sides when carrying. Set to false if you experience issues with mods that replace the player model (like MoBends, etc)" + ) + public boolean renderArms = true; + + @Property( + type = PropertyType.STRING_ARRAY, + description = "Model Overrides based on NBT or Meta. Advanced users only! Read about the format here: https://github.com/Tschipp/CarryOn/wiki/Model-Override-Config" + ) + public String[] modelOverrides = { + "minecraft:hopper->(block)minecraft:hopper", + "minecraft:comparator->(block)minecraft:comparator", + "minecraft:repeater->(block)minecraft:repeater", + "minecraft:cauldron->(block)minecraft:cauldron", + "minecraft:brewing_stand->(item)minecraft:brewing_stand", + "minecraft:flower_pot->(block)minecraft:flower_pot", + "minecraft:sugar_cane->(block)minecraft:sugar_cane", + "minecraft:redstone_wire->(item)minecraft:redstone", + "animania:block_nest->(block)animania:block_nest", + "animania:cheese_mold;0->(block)animania:cheese_mold;0", + "animania:cheese_mold;1->(block)animania:cheese_mold;1", + "animania:cheese_mold;2->(block)animania:cheese_mold;2", + "animania:cheese_mold;3->(block)animania:cheese_mold;3", + "animania:cheese_mold;4->(block)animania:cheese_mold;4", + "animania:cheese_mold;5->(block)animania:cheese_mold;5", + "animania:cheese_mold;6->(block)animania:cheese_mold;6", + "animania:cheese_mold;7->(block)animania:cheese_mold;7", + "animania:cheese_mold;8->(block)animania:cheese_mold;8", + "animania:cheese_mold;9->(block)animania:cheese_mold;9", + "animania:cheese_mold;10->(block)animania:cheese_mold;10" + }; + } + +} diff --git a/Common/src/main/java/tschipp/carryon/config/AnnotationData.java b/Common/src/main/java/tschipp/carryon/config/AnnotationData.java new file mode 100644 index 0000000..06f7d63 --- /dev/null +++ b/Common/src/main/java/tschipp/carryon/config/AnnotationData.java @@ -0,0 +1,24 @@ +package tschipp.carryon.config; + + +import tschipp.carryon.config.annotations.Property; + +import java.lang.reflect.Field; + +public record AnnotationData( + PropertyType type, + String description, + int min, int max, + double minD, double maxD +) { + + public static AnnotationData getData(Field field) { + Property annotation = field.getAnnotation(Property.class); + return new AnnotationData( + annotation.type(), + annotation.description(), + annotation.min(), annotation.max(), + annotation.minD(), annotation.maxD() + ); + } +} diff --git a/Common/src/main/java/tschipp/carryon/config/BuiltCategory.java b/Common/src/main/java/tschipp/carryon/config/BuiltCategory.java new file mode 100644 index 0000000..b001281 --- /dev/null +++ b/Common/src/main/java/tschipp/carryon/config/BuiltCategory.java @@ -0,0 +1,37 @@ +package tschipp.carryon.config; + +import java.util.ArrayList; +import java.util.List; +import java.util.Optional; + +public class BuiltCategory { + + public final List properties = new ArrayList<>(); + public final List categories = new ArrayList<>(); + + public final String categoryDesc; + public final String category; + + public BuiltCategory(String categoryDesc, String category) { + this.categoryDesc = categoryDesc; + this.category = category; + } + + public Optional getProperty(String id) { + for (PropertyData property : properties) { + if (property.getId().equals(id)) { + return Optional.of(property); + } + } + return Optional.empty(); + } + + public Optional getCategory(String id) { + for (BuiltCategory category : categories) { + if (category.category.equals(id)) { + return Optional.of(category); + } + } + return Optional.empty(); + } +} diff --git a/Common/src/main/java/tschipp/carryon/config/BuiltConfig.java b/Common/src/main/java/tschipp/carryon/config/BuiltConfig.java new file mode 100644 index 0000000..cb950fb --- /dev/null +++ b/Common/src/main/java/tschipp/carryon/config/BuiltConfig.java @@ -0,0 +1,11 @@ +package tschipp.carryon.config; + +public class BuiltConfig extends BuiltCategory { + + public final String fileName; + + public BuiltConfig(String fileName) { + super(null, fileName); + this.fileName = fileName; + } +} diff --git a/Common/src/main/java/tschipp/carryon/config/ConfigLoader.java b/Common/src/main/java/tschipp/carryon/config/ConfigLoader.java new file mode 100644 index 0000000..ffe129a --- /dev/null +++ b/Common/src/main/java/tschipp/carryon/config/ConfigLoader.java @@ -0,0 +1,61 @@ +package tschipp.carryon.config; + +//Many Thanks to ThatGravyBoat for this template! + +import tschipp.carryon.common.carry.ListHandler; +import tschipp.carryon.config.annotations.Category; +import tschipp.carryon.config.annotations.Config; +import tschipp.carryon.config.annotations.Property; +import tschipp.carryon.platform.Services; + +import java.lang.reflect.Field; + +public class ConfigLoader { + + public static void registerConfig(Object object) { + BuiltCategory category; + try { + category = buildCategory(null, object); + } catch (Exception e) { + e.printStackTrace(); + category = null; + } + if (category instanceof BuiltConfig config) { + registerConfig(config); + } else { + throw new IllegalArgumentException("Config supplied does not have a @Config annotation"); + } + } + + public static void registerConfig(BuiltConfig config) { + Services.PLATFORM.registerConfig(config); + } + + public static void onConfigLoaded() { + ListHandler.initConfigLists(); + } + + public static BuiltCategory buildCategory(String categoryDesc, Object object) throws IllegalAccessException { + Class configClass = object.getClass(); + BuiltCategory category; + if (configClass.isAnnotationPresent(Config.class)) { + category = new BuiltConfig(configClass.getAnnotation(Config.class).value()); + } else if (configClass.isAnnotationPresent(Category.class)) { + category = new BuiltCategory(categoryDesc, configClass.getAnnotation(Category.class).value()); + } else { + throw new IllegalStateException("Config does not contain any @Config annotation or @Category"); + } + + for (Field field : configClass.getDeclaredFields()) { + if (field.isAnnotationPresent(Property.class) && field.canAccess(object)) { + PropertyType type = field.getAnnotation(Property.class).type(); + if (type.equals(PropertyType.CATEGORY)) { + category.categories.add(buildCategory(field.getAnnotation(Property.class).description(), field.get(object))); + } else { + category.properties.add(new PropertyData(object, field, AnnotationData.getData(field))); + } + } + } + return category; + } +} diff --git a/Common/src/main/java/tschipp/carryon/config/PropertyData.java b/Common/src/main/java/tschipp/carryon/config/PropertyData.java new file mode 100644 index 0000000..af16458 --- /dev/null +++ b/Common/src/main/java/tschipp/carryon/config/PropertyData.java @@ -0,0 +1,59 @@ +package tschipp.carryon.config; + +import java.lang.reflect.Field; + +public record PropertyData(Object fieldClass, Field field, AnnotationData data) { + + public String getId() { + return field().getName(); + } + + public boolean getBoolean() throws IllegalAccessException { + return field().getBoolean(fieldClass()); + } + + public void setBoolean(boolean _boolean) { + try { + field.setBoolean(fieldClass, _boolean); + } catch (Exception e) { + //Ignore + } + } + + public int getInt() throws IllegalAccessException { + return field().getInt(fieldClass()); + } + + public void setInt(int _int) { + try { + field.setInt(fieldClass, _int); + } catch (Exception e) { + //Ignore + } + } + + public double getDouble() throws IllegalAccessException { + return field().getDouble(fieldClass()); + } + + public void setDouble(double _double) { + try { + field.setDouble(fieldClass, _double); + } catch (Exception e) { + //Ignore + } + } + + public String[] getStringArray() throws IllegalAccessException { + return (String[])field().get(fieldClass()); + } + + public void setStringArray(String[] arr) + { + try { + field.set(fieldClass, arr); + } catch (Exception e) { + //Ignore + } + } +} diff --git a/Common/src/main/java/tschipp/carryon/config/PropertyType.java b/Common/src/main/java/tschipp/carryon/config/PropertyType.java new file mode 100644 index 0000000..9c985d2 --- /dev/null +++ b/Common/src/main/java/tschipp/carryon/config/PropertyType.java @@ -0,0 +1,9 @@ +package tschipp.carryon.config; + +public enum PropertyType { + INT, + DOUBLE, + BOOLEAN, + STRING_ARRAY, + CATEGORY +} diff --git a/Common/src/main/java/tschipp/carryon/config/annotations/Category.java b/Common/src/main/java/tschipp/carryon/config/annotations/Category.java new file mode 100644 index 0000000..e2cbd08 --- /dev/null +++ b/Common/src/main/java/tschipp/carryon/config/annotations/Category.java @@ -0,0 +1,12 @@ +package tschipp.carryon.config.annotations; + +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 Category { + String value(); +} diff --git a/Common/src/main/java/tschipp/carryon/config/annotations/Config.java b/Common/src/main/java/tschipp/carryon/config/annotations/Config.java new file mode 100644 index 0000000..897d47c --- /dev/null +++ b/Common/src/main/java/tschipp/carryon/config/annotations/Config.java @@ -0,0 +1,12 @@ +package tschipp.carryon.config.annotations; + +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 Config { + String value(); +} diff --git a/Common/src/main/java/tschipp/carryon/config/annotations/Property.java b/Common/src/main/java/tschipp/carryon/config/annotations/Property.java new file mode 100644 index 0000000..680949f --- /dev/null +++ b/Common/src/main/java/tschipp/carryon/config/annotations/Property.java @@ -0,0 +1,24 @@ +package tschipp.carryon.config.annotations; + +import tschipp.carryon.config.PropertyType; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +@Target({ElementType.FIELD}) +@Retention(RetentionPolicy.RUNTIME) +public @interface Property { + + + + PropertyType type(); + String description(); + + int min() default Integer.MIN_VALUE; + int max() default Integer.MAX_VALUE; + + double minD() default Double.MIN_VALUE; + double maxD() default Double.MAX_VALUE; +} diff --git a/Common/src/main/java/tschipp/carryon/mixin/HumanoidModelMixin.java b/Common/src/main/java/tschipp/carryon/mixin/HumanoidModelMixin.java new file mode 100644 index 0000000..0df344f --- /dev/null +++ b/Common/src/main/java/tschipp/carryon/mixin/HumanoidModelMixin.java @@ -0,0 +1,55 @@ +package tschipp.carryon.mixin; + +import net.minecraft.client.model.HumanoidModel; +import net.minecraft.client.model.geom.ModelPart; +import net.minecraft.world.entity.LivingEntity; +import net.minecraft.world.entity.player.Player; +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 tschipp.carryon.common.carry.CarryOnData; +import tschipp.carryon.common.carry.CarryOnDataManager; + +@Mixin(HumanoidModel.class) +public class HumanoidModelMixin { + + @Shadow + public ModelPart rightArm; + + @Shadow + public ModelPart leftArm; + + @Inject(at = @At("RETURN"), method = "setupAnim(Lnet/minecraft/world/entity/LivingEntity;FFFFF)V") + private void onSetupAnimations(LivingEntity living, float f1, float f2, float f3, float f4, float f5, CallbackInfo ci) + { + System.out.println("Reached model injectiob"); + if(living instanceof Player player) + { + System.out.println("Model is player"); + + CarryOnData carry = CarryOnDataManager.getCarryData(player); + if(carry.isCarrying() && !player.isVisuallySwimming() && !player.isFallFlying()) + { + System.out.println("Player is carrying"); + + boolean sneaking = !player.getAbilities().flying && player.isShiftKeyDown() || player.isCrouching(); + + float x = 1.0f + (sneaking ? 0.2f : 0.0f) - (carry.isCarrying(CarryOnData.CarryType.BLOCK) ? 0.0f : 0.3f); + float z = 0.15f; + + rightArm.yRot = 0; + leftArm.yRot = 0; + + rightArm.xRot = -x; + leftArm.xRot = -x; + + rightArm.zRot = z; + leftArm.zRot = -z; + } + + } + } + +} diff --git a/Common/src/main/java/tschipp/carryon/mixin/PlayerMixin.java b/Common/src/main/java/tschipp/carryon/mixin/PlayerMixin.java index f11a43c..9e31831 100644 --- a/Common/src/main/java/tschipp/carryon/mixin/PlayerMixin.java +++ b/Common/src/main/java/tschipp/carryon/mixin/PlayerMixin.java @@ -23,6 +23,7 @@ public abstract class PlayerMixin extends LivingEntity { @Inject(method = "defineSynchedData()V", at = @At("RETURN")) private void onDefineSynchedData(CallbackInfo info) { this.entityData.define(CarryOnDataManager.CARRY_DATA_KEY, new CompoundTag()); + System.out.println("Added Carry Data!"); } @Inject(method = "addAdditionalSaveData(Lnet/minecraft/nbt/CompoundTag;)V", at = @At("RETURN")) diff --git a/Common/src/main/java/tschipp/carryon/platform/services/IPlatformHelper.java b/Common/src/main/java/tschipp/carryon/platform/services/IPlatformHelper.java index b62b62e..ce27a98 100644 --- a/Common/src/main/java/tschipp/carryon/platform/services/IPlatformHelper.java +++ b/Common/src/main/java/tschipp/carryon/platform/services/IPlatformHelper.java @@ -1,5 +1,7 @@ package tschipp.carryon.platform.services; +import tschipp.carryon.config.BuiltConfig; + public interface IPlatformHelper { /** @@ -23,4 +25,6 @@ public interface IPlatformHelper { * @return True if in a development environment, false otherwise. */ boolean isDevelopmentEnvironment(); + + void registerConfig(BuiltConfig cfg); } diff --git a/Common/src/main/resources/assets/carryon/logo.png b/Common/src/main/resources/assets/carryon/logo.png new file mode 100644 index 0000000000000000000000000000000000000000..1b9a97859cd4353dd102e0580fbbf74e7773c4e8 GIT binary patch literal 173666 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ğKb!TC27S>i*g)>Yg7#|<==FVUbiRx+2 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 X( CONFIGS = new HashMap<>(); + + public static void initialize() throws IOException { + Path cfgPath = FabricLoader.getInstance().getConfigDir(); + + for (Map.Entry entry : CONFIGS.entrySet()) { + File cfgFile = new File(cfgPath.toFile(), entry.getValue().fileName+".json"); + if (!cfgFile.exists()) { + cfgPath.toFile().mkdirs(); + FileUtils.write(cfgFile, GSON.toJson(entry.getKey()), StandardCharsets.UTF_8); + } else { + JsonObject cfgJson = GSON.fromJson(FileUtils.readFileToString(cfgFile, StandardCharsets.UTF_8), JsonObject.class); + FileUtils.write(cfgFile, GSON.toJson(loadConfig(entry.getValue(), cfgJson)), StandardCharsets.UTF_8); + } + } + } + + private static JsonObject loadConfig(BuiltCategory category, JsonObject config) { + config.entrySet().forEach((entry) -> { + String id = entry.getKey(); + if (!id.startsWith("//")) { + JsonElement value = entry.getValue(); + if (value instanceof JsonPrimitive configValue) { + category.getProperty(id).ifPresent(data -> { + if (configValue.isBoolean() && data.data().type().equals(PropertyType.BOOLEAN)) + data.setBoolean(configValue.getAsBoolean()); + if (configValue.isNumber() && data.data().type().equals(PropertyType.INT)) { + int configInt = configValue.getAsInt(); + if (configInt > data.data().max() || configInt < data.data().min()) { + try { + config.addProperty(id, data.getInt()); + } catch (IllegalAccessException ignored) { + } + } else { + data.setInt(configInt); + } + } + if (configValue.isNumber() && data.data().type().equals(PropertyType.DOUBLE)) { + double configDouble = configValue.getAsDouble(); + if (configDouble > data.data().maxD() || configDouble < data.data().minD()) { + try { + config.addProperty(id, data.getDouble()); + } catch (IllegalAccessException ignored) { + } + } else { + data.setDouble(configDouble); + } + } + }); + } else if (value instanceof JsonObject subConfig) { + category.getCategory(id).ifPresent(cat -> loadConfig(cat, subConfig)); + } else if (value instanceof JsonArray list) { + category.getProperty(id).ifPresent(data -> { + if(data.data().type() == PropertyType.STRING_ARRAY) + { + List ls = new ArrayList<>(); + for(JsonElement arrEle : list) + { + if(arrEle instanceof JsonPrimitive p && p.isString()) + { + ls.add(p.getAsString()); + } + } + data.setStringArray(ls.toArray(new String[ls.size()])); + } + }); + } + } + }); + ConfigLoader.onConfigLoaded(); + return config; + } + + public static void registerConfig(BuiltConfig config) { + try { + JsonObject configJson = new JsonObject(); + for (PropertyData property : config.properties) buildProperty(configJson, property); + for (BuiltCategory category : config.categories) buildCategory(configJson, category); + CONFIGS.put(configJson, config); + }catch (Exception e) { + e.printStackTrace(); + } + } + + private static void buildCategory(JsonObject builder, BuiltCategory category) throws IllegalAccessException { + JsonObject categoryJson = new JsonObject(); + if (category.categoryDesc != null) categoryJson.addProperty("//"+category.category, category.categoryDesc); + for (PropertyData property : category.properties) buildProperty(categoryJson, property); + for (BuiltCategory builtCategory : category.categories) buildCategory(categoryJson, builtCategory); + builder.add(category.category, categoryJson); + } + + private static void buildProperty(JsonObject builder, PropertyData data) throws IllegalAccessException { + AnnotationData annotationData = data.data(); + builder.addProperty("//"+data.getId(), annotationData.description()); + + switch (annotationData.type()) { + case BOOLEAN -> builder.addProperty(data.getId(), data.getBoolean()); + case INT -> builder.addProperty(data.getId(), data.getInt()); + case DOUBLE -> builder.addProperty(data.getId(), data.getDouble()); + case STRING_ARRAY -> { + JsonArray arr = new JsonArray(); + for(String s : data.getStringArray()) + arr.add(s); + builder.add(data.getId(), arr); + } + default -> throw new IllegalAccessException("Unknown property type."); + } + } +} diff --git a/Fabric/src/main/java/tschipp/carryon/events/ClientEvents.java b/Fabric/src/main/java/tschipp/carryon/events/ClientEvents.java new file mode 100644 index 0000000..0efba9a --- /dev/null +++ b/Fabric/src/main/java/tschipp/carryon/events/ClientEvents.java @@ -0,0 +1,4 @@ +package tschipp.carryon.events; + +public class ClientEvents { +} diff --git a/Fabric/src/main/java/tschipp/carryon/events/CommonEvents.java b/Fabric/src/main/java/tschipp/carryon/events/CommonEvents.java new file mode 100644 index 0000000..5cd490c --- /dev/null +++ b/Fabric/src/main/java/tschipp/carryon/events/CommonEvents.java @@ -0,0 +1,75 @@ +package tschipp.carryon.events; + +import net.fabricmc.fabric.api.event.player.UseBlockCallback; +import net.fabricmc.fabric.api.event.player.UseEntityCallback; +import net.minecraft.core.BlockPos; +import net.minecraft.core.Direction; +import net.minecraft.server.level.ServerPlayer; +import net.minecraft.world.InteractionResult; +import tschipp.carryon.common.carry.CarryOnData; +import tschipp.carryon.common.carry.CarryOnDataManager; +import tschipp.carryon.common.carry.PickupHandler; +import tschipp.carryon.common.carry.PlacementHandler; + +public class CommonEvents { + + public static void registerEvents() { + + UseBlockCallback.EVENT.register((player, world, hand, hitResult) -> { + + if(world.isClientSide) + return InteractionResult.PASS; + + BlockPos pos = hitResult.getBlockPos(); + Direction facing = hitResult.getDirection(); + + CarryOnData carry = CarryOnDataManager.getCarryData(player); + if(!carry.isCarrying()) + { + if (PickupHandler.tryPickUpBlock((ServerPlayer) player, pos, world)) + return InteractionResult.SUCCESS; + return InteractionResult.PASS; + } + else + { + if(carry.isCarrying(CarryOnData.CarryType.BLOCK)) + { + if(PlacementHandler.tryPlaceBlock((ServerPlayer) player, pos, facing, null)) + return InteractionResult.SUCCESS; + } + else + { + if(PlacementHandler.tryPlaceEntity((ServerPlayer) player, pos, facing, null)) + return InteractionResult.SUCCESS; + } + + //Fail here, so that we don't interact with placed things + return InteractionResult.FAIL; + } + }); + + + + + UseEntityCallback.EVENT.register((player, level, hand, entity, hitResult) -> { + + if(level.isClientSide) + return InteractionResult.PASS; + + CarryOnData carry = CarryOnDataManager.getCarryData(player); + if (!carry.isCarrying()) { + if (PickupHandler.tryPickupEntity((ServerPlayer) player, entity)) { + return InteractionResult.SUCCESS; + } + } + else if(carry.isCarrying(CarryOnData.CarryType.ENTITY)) + { + //TODO: Stacking + } + + return InteractionResult.PASS; + }); + + } + +} diff --git a/Fabric/src/main/java/tschipp/carryon/platform/FabricPlatformHelper.java b/Fabric/src/main/java/tschipp/carryon/platform/FabricPlatformHelper.java index bd10051..93e37a3 100644 --- a/Fabric/src/main/java/tschipp/carryon/platform/FabricPlatformHelper.java +++ b/Fabric/src/main/java/tschipp/carryon/platform/FabricPlatformHelper.java @@ -1,5 +1,7 @@ package tschipp.carryon.platform; +import tschipp.carryon.config.BuiltConfig; +import tschipp.carryon.config.fabric.ConfigLoaderImpl; import tschipp.carryon.platform.services.IPlatformHelper; import net.fabricmc.loader.api.FabricLoader; @@ -21,4 +23,9 @@ public class FabricPlatformHelper implements IPlatformHelper { return FabricLoader.getInstance().isDevelopmentEnvironment(); } + + @Override + public void registerConfig(BuiltConfig cfg) { + ConfigLoaderImpl.registerConfig(cfg); + } } diff --git a/Fabric/src/main/resources/fabric.mod.json b/Fabric/src/main/resources/fabric.mod.json index 160567a..098c01b 100644 --- a/Fabric/src/main/resources/fabric.mod.json +++ b/Fabric/src/main/resources/fabric.mod.json @@ -1,12 +1,12 @@ { "schemaVersion": 1, - "id": "modid", + "id": "carryon", "version": "${version}", - "name": "Example Mod", + "name": "Carry On", "description": "This is an example description! Tell everyone what your mod is about!", "authors": [ - "Me!" + "Tschipp" ], "contact": { "homepage": "https://fabricmc.net/", @@ -14,7 +14,7 @@ }, "license": "CC0-1.0", - "icon": "assets/modid/icon.png", + "icon": "assets/carryon/logo.png", "environment": "*", "entrypoints": { @@ -23,7 +23,8 @@ ] }, "mixins": [ - "carryon.fabric.mixins.json" + "carryon.fabric.mixins.json", + "carryon.mixins.json" ], "depends": { @@ -31,9 +32,6 @@ "fabric": "*", "minecraft": "1.19.x", "java": ">=17" - }, - "suggests": { - "another-mod": "*" } } \ No newline at end of file diff --git a/Forge/src/main/java/tschipp/carryon/CarryOnForge.java b/Forge/src/main/java/tschipp/carryon/CarryOnForge.java index 46799c3..1684936 100644 --- a/Forge/src/main/java/tschipp/carryon/CarryOnForge.java +++ b/Forge/src/main/java/tschipp/carryon/CarryOnForge.java @@ -1,6 +1,7 @@ package tschipp.carryon; import net.minecraftforge.fml.common.Mod; +import tschipp.carryon.config.forge.ConfigLoaderImpl; @Mod(Constants.MOD_ID) public class CarryOnForge { @@ -13,6 +14,8 @@ public class CarryOnForge { // Use Forge to bootstrap the Common mod. Constants.LOG.info("Hello Forge world!"); + + ConfigLoaderImpl.initialize(); } } \ No newline at end of file diff --git a/Forge/src/main/java/tschipp/carryon/config/forge/ConfigLoaderImpl.java b/Forge/src/main/java/tschipp/carryon/config/forge/ConfigLoaderImpl.java new file mode 100644 index 0000000..754206b --- /dev/null +++ b/Forge/src/main/java/tschipp/carryon/config/forge/ConfigLoaderImpl.java @@ -0,0 +1,102 @@ +package tschipp.carryon.config.forge; + +import com.electronwill.nightconfig.core.AbstractConfig; +import com.electronwill.nightconfig.core.UnmodifiableConfig; +import net.minecraftforge.common.ForgeConfigSpec; +import net.minecraftforge.eventbus.api.IEventBus; +import net.minecraftforge.fml.ModLoadingContext; +import net.minecraftforge.fml.config.IConfigSpec; +import net.minecraftforge.fml.config.ModConfig; +import net.minecraftforge.fml.event.config.ModConfigEvent; +import net.minecraftforge.fml.javafmlmod.FMLJavaModLoadingContext; +import tschipp.carryon.config.*; + +import java.util.Arrays; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +public class ConfigLoaderImpl { + + public static final Map CONFIGS = new HashMap<>(); + + public static void initialize() { + IEventBus bus = FMLJavaModLoadingContext.get().getModEventBus(); + bus.addListener(ConfigLoaderImpl::onConfigLoad); + bus.addListener(ConfigLoaderImpl::onConfigReload); + + ConfigLoaderImpl.CONFIGS.forEach((spec, config) -> { + if(config.fileName.contains("client")) + ModLoadingContext.get().registerConfig(ModConfig.Type.CLIENT, spec, config.fileName+".toml"); + else + ModLoadingContext.get().registerConfig(ModConfig.Type.COMMON, spec, config.fileName+".toml"); + }); + } + + public static void onConfigLoad(ModConfigEvent.Loading loading) { + loadConfig(loading.getConfig().getSpec()); + ConfigLoader.onConfigLoaded(); + } + + public static void onConfigReload(ModConfigEvent.Reloading loading) { + loadConfig(loading.getConfig().getSpec()); + ConfigLoader.onConfigLoaded(); + } + + private static void loadConfig(IConfigSpec spec) { + BuiltConfig builtConfig = CONFIGS.get(spec.self()); + if (builtConfig == null) return; + loadConfig(builtConfig, spec.self().getValues()); + } + + private static void loadConfig(BuiltCategory category, UnmodifiableConfig config) { + config.valueMap().forEach((id, value) -> { + if (value instanceof ForgeConfigSpec.ConfigValue configValue) { + category.getProperty(id).ifPresent(data -> { + if (configValue instanceof ForgeConfigSpec.BooleanValue booleanValue) + data.setBoolean(booleanValue.get()); + if (configValue instanceof ForgeConfigSpec.IntValue intValue) + data.setInt(intValue.get()); + if (configValue instanceof ForgeConfigSpec.DoubleValue doubleValue) + data.setDouble(doubleValue.get()); + if(configValue.get() instanceof List listVal) + data.setStringArray(listVal.toArray(new String[listVal.size()])); + }); + } else if (value instanceof AbstractConfig subConfig) { + category.getCategory(id).ifPresent(cat -> loadConfig(cat, subConfig)); + } + }); + } + + public static void registerConfig(BuiltConfig config) { + try { + ForgeConfigSpec.Builder builder = new ForgeConfigSpec.Builder(); + for (PropertyData property : config.properties) buildProperty(builder, property); + for (BuiltCategory category : config.categories) buildCategory(builder, category); + CONFIGS.put(builder.build(), config); + }catch (Exception e) { + e.printStackTrace(); + } + } + + private static void buildCategory(ForgeConfigSpec.Builder builder, BuiltCategory category) throws IllegalAccessException { + builder.push(category.category); + if (category.categoryDesc != null) builder.comment(category.categoryDesc); + for (PropertyData property : category.properties) buildProperty(builder, property); + for (BuiltCategory builtCategory : category.categories) buildCategory(builder, builtCategory); + builder.pop(); + } + + private static void buildProperty(ForgeConfigSpec.Builder builder, PropertyData data) throws IllegalAccessException { + AnnotationData annotationData = data.data(); + builder.comment(annotationData.description()); + + switch (annotationData.type()) { + case BOOLEAN -> builder.define(data.getId(), data.getBoolean()); + case INT -> builder.defineInRange(data.getId(), data.getInt(), annotationData.min(), annotationData.max()); + case DOUBLE -> builder.defineInRange(data.getId(), data.getDouble(), annotationData.minD(), annotationData.maxD()); + case STRING_ARRAY -> builder.defineList(data.getId(), Arrays.asList(data.getStringArray()), obj -> obj instanceof String); + default -> throw new IllegalAccessException("Unknown property type."); + } + } +} diff --git a/Forge/src/main/java/tschipp/carryon/events/ClientEvents.java b/Forge/src/main/java/tschipp/carryon/events/ClientEvents.java index 233616d..05d6ec0 100644 --- a/Forge/src/main/java/tschipp/carryon/events/ClientEvents.java +++ b/Forge/src/main/java/tschipp/carryon/events/ClientEvents.java @@ -24,8 +24,9 @@ public class ClientEvents { MultiBufferSource buffer = event.getMultiBufferSource(); PoseStack matrix = event.getPoseStack(); int light = event.getPackedLight(); + float partialTicks = event.getPartialTick(); - if(CarriedObjectRender.drawFirstPerson(player, buffer, matrix, light) && CarryRenderHelper.getPerspective() == 0) + if(CarriedObjectRender.drawFirstPerson(player, buffer, matrix, light, partialTicks) && CarryRenderHelper.getPerspective() == 0) event.setCanceled(true); } } diff --git a/Forge/src/main/java/tschipp/carryon/events/CommonEvents.java b/Forge/src/main/java/tschipp/carryon/events/CommonEvents.java index f67beca..8c9961f 100644 --- a/Forge/src/main/java/tschipp/carryon/events/CommonEvents.java +++ b/Forge/src/main/java/tschipp/carryon/events/CommonEvents.java @@ -25,7 +25,6 @@ import tschipp.carryon.common.carry.PlacementHandler; @Mod.EventBusSubscriber(bus = Mod.EventBusSubscriber.Bus.FORGE, modid = Constants.MOD_ID) public class CommonEvents { - @SubscribeEvent(priority = EventPriority.HIGH) public static void onBlockClick(PlayerInteractEvent.RightClickBlock event) { @@ -39,12 +38,12 @@ public class CommonEvents if (level.isClientSide) return; - boolean cancel = false; + boolean success = false; CarryOnData carry = CarryOnDataManager.getCarryData(player); if (!carry.isCarrying()) { if (PickupHandler.tryPickUpBlock((ServerPlayer) player, pos, level)) { - cancel = true; + success = true; } } else { if (carry.isCarrying(CarryType.BLOCK)) { @@ -54,23 +53,23 @@ public class CommonEvents MinecraftForge.EVENT_BUS.post(event1); return !event1.isCanceled(); })) { - cancel = true; + success = true; } } else { + //TODO: Entity place perms if (PlacementHandler.tryPlaceEntity((ServerPlayer) player,pos, event.getFace(), null)) { - cancel = true; + success = true; } } } - if(cancel) + if(success) { event.setUseBlock(Event.Result.DENY); event.setUseItem(Event.Result.DENY); event.setCancellationResult(InteractionResult.SUCCESS); event.setCanceled(true); - return; } } diff --git a/Forge/src/main/java/tschipp/carryon/platform/ForgePlatformHelper.java b/Forge/src/main/java/tschipp/carryon/platform/ForgePlatformHelper.java index 8d24bb7..12f42ae 100644 --- a/Forge/src/main/java/tschipp/carryon/platform/ForgePlatformHelper.java +++ b/Forge/src/main/java/tschipp/carryon/platform/ForgePlatformHelper.java @@ -1,5 +1,7 @@ package tschipp.carryon.platform; +import tschipp.carryon.config.BuiltConfig; +import tschipp.carryon.config.forge.ConfigLoaderImpl; import tschipp.carryon.platform.services.IPlatformHelper; import net.minecraftforge.fml.ModList; import net.minecraftforge.fml.loading.FMLLoader; @@ -23,4 +25,9 @@ public class ForgePlatformHelper implements IPlatformHelper { return !FMLLoader.isProduction(); } + + @Override + public void registerConfig(BuiltConfig cfg) { + ConfigLoaderImpl.registerConfig(cfg); + } }