diff --git a/build.bat b/build.bat new file mode 100644 index 0000000..9691829 --- /dev/null +++ b/build.bat @@ -0,0 +1,2 @@ +gradlew build +pause \ No newline at end of file diff --git a/src/main/java/tschipp/carryon/client/event/RenderEvents.java b/src/main/java/tschipp/carryon/client/event/RenderEvents.java index db96a9e..6065f9f 100644 --- a/src/main/java/tschipp/carryon/client/event/RenderEvents.java +++ b/src/main/java/tschipp/carryon/client/event/RenderEvents.java @@ -3,20 +3,27 @@ package tschipp.carryon.client.event; import java.lang.reflect.Field; import net.minecraft.block.Block; +import net.minecraft.block.state.IBlockState; import net.minecraft.client.Minecraft; +import net.minecraft.client.entity.AbstractClientPlayer; import net.minecraft.client.gui.inventory.GuiContainer; +import net.minecraft.client.model.ModelBiped; +import net.minecraft.client.model.ModelRenderer; import net.minecraft.client.renderer.GlStateManager; -import net.minecraft.client.renderer.RenderHelper; +import net.minecraft.client.renderer.block.model.IBakedModel; +import net.minecraft.client.renderer.entity.RenderManager; import net.minecraft.client.renderer.entity.RenderPlayer; +import net.minecraft.client.resources.DefaultPlayerSkin; import net.minecraft.client.settings.GameSettings; import net.minecraft.client.settings.KeyBinding; import net.minecraft.entity.item.EntityItem; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.init.Blocks; import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; import net.minecraft.util.EnumHand; +import net.minecraft.util.ResourceLocation; import net.minecraft.util.math.BlockPos; -import net.minecraft.world.EnumSkyBlock; import net.minecraft.world.World; import net.minecraftforge.client.event.GuiOpenEvent; import net.minecraftforge.client.event.MouseEvent; @@ -27,12 +34,16 @@ import net.minecraftforge.fml.common.gameevent.InputEvent; import net.minecraftforge.fml.relauncher.Side; import net.minecraftforge.fml.relauncher.SideOnly; import tschipp.carryon.common.config.CarryOnConfig; +import tschipp.carryon.common.handler.ModelOverridesHandler; import tschipp.carryon.common.handler.RegistrationHandler; import tschipp.carryon.common.item.ItemTile; public class RenderEvents { + /* + * Prevents the Player from scrolling + */ @SideOnly(Side.CLIENT) @SubscribeEvent public void onScroll(MouseEvent event) @@ -48,6 +59,9 @@ public class RenderEvents } } + /* + * Prevents the Player from opening Guis + */ @SideOnly(Side.CLIENT) @SubscribeEvent public void onGuiOpen(GuiOpenEvent event) @@ -61,13 +75,16 @@ public class RenderEvents ItemStack stack = player.getHeldItem(EnumHand.MAIN_HAND); if (inventory && !stack.isEmpty() && stack.getItem() == RegistrationHandler.itemTile && ItemTile.hasTileData(stack)) { - event.setCanceled(true); - Minecraft.getMinecraft().currentScreen = null; + event.setCanceled(true); + Minecraft.getMinecraft().currentScreen = null; } } } } + /* + * Prevents the Player from switching Slots + */ @SideOnly(Side.CLIENT) @SubscribeEvent public void inputEvent(InputEvent event) throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException @@ -96,11 +113,13 @@ public class RenderEvents } } + /* + * Renders the Block in First Person + */ @SideOnly(Side.CLIENT) @SubscribeEvent public void renderHand(RenderHandEvent event) { - World world = Minecraft.getMinecraft().world; EntityPlayer player = Minecraft.getMinecraft().player; ItemStack stack = player.getHeldItemMainhand(); @@ -109,9 +128,11 @@ public class RenderEvents { Block block = ItemTile.getBlock(stack); BlockPos pos = player.getPosition(); - stack = ItemTile.getItemStack(stack); + NBTTagCompound tag = ItemTile.getTileData(stack); + IBlockState state = ItemTile.getBlockState(stack); + + ItemStack tileStack = ItemTile.getItemStack(stack); - int perspective = Minecraft.getMinecraft().gameSettings.thirdPersonView; GlStateManager.pushMatrix(); @@ -126,18 +147,19 @@ public class RenderEvents else GlStateManager.rotate(8, 1f, 0, 0); - if (perspective == 0) - Minecraft.getMinecraft().getRenderItem().renderItem(stack, Minecraft.getMinecraft().getRenderItem().getItemModelWithOverrides(stack, world, player)); - + Minecraft.getMinecraft().getRenderItem().renderItem(tileStack.isEmpty() ? stack : tileStack, ModelOverridesHandler.hasCustomOverrideModel(state, tag) ? ModelOverridesHandler.getCustomOverrideModel(state, tag) : Minecraft.getMinecraft().getRenderItem().getItemModelWithOverrides(tileStack, world, player)); + GlStateManager.scale(1, 1, 1); GlStateManager.popMatrix(); event.setCanceled(true); - } } + /* + * Renders the Block in Third Person + */ @SideOnly(Side.CLIENT) @SubscribeEvent public void onPlayerRenderPost(RenderPlayerEvent.Post event) @@ -145,55 +167,102 @@ public class RenderEvents World world = Minecraft.getMinecraft().world; EntityPlayer player = Minecraft.getMinecraft().player; ItemStack stack = player.getHeldItemMainhand(); - if (!stack.isEmpty() && stack.getItem() == RegistrationHandler.itemTile && ItemTile.hasTileData(stack)) { Block block = ItemTile.getBlock(stack); - stack = ItemTile.getItemStack(stack); + IBlockState state = ItemTile.getBlockState(stack); + NBTTagCompound tag = ItemTile.getTileData(stack); + + ItemStack tileItem = ItemTile.getItemStack(stack); EntityItem entityItem = new EntityItem(Minecraft.getMinecraft().world, 0, 0, 0); entityItem.hoverStart = 0; - entityItem.setEntityItemStack(stack); + entityItem.setEntityItemStack(tileItem); float rotation = -player.renderYawOffset; int perspective = Minecraft.getMinecraft().gameSettings.thirdPersonView; GlStateManager.pushMatrix(); - GlStateManager.scale(2.2, 2.2, 2.2); + GlStateManager.scale(0.6, 0.6, 0.6); if (CarryOnConfig.settings.facePlayer ? !isChest(block) : isChest(block)) { GlStateManager.rotate(rotation, 0, 1.0f, 0); - GlStateManager.translate(0, 0.1, 0.2); + GlStateManager.translate(0, 1.6, 0.65); } else { GlStateManager.rotate(rotation + 180, 0, 1.0f, 0); - GlStateManager.translate(0, 0.1, -0.2); + GlStateManager.translate(0, 1.6, -0.65); } if (player.isSneaking()) - GlStateManager.translate(0, -0.08, 0); + GlStateManager.translate(0, -0.3, 0); + + IBakedModel model = ModelOverridesHandler.hasCustomOverrideModel(state, tag) ? ModelOverridesHandler.getCustomOverrideModel(state, tag) : Minecraft.getMinecraft().getRenderItem().getItemModelWithOverrides(tileItem, world, player); + Minecraft.getMinecraft().getRenderItem().renderItem(tileItem.isEmpty() ? stack : tileItem, model); - Minecraft.getMinecraft().getRenderManager().doRenderEntity(entityItem, event.getX(), event.getY(), event.getZ(), 0, 0, true); GlStateManager.scale(1, 1, 1); - GlStateManager.popMatrix(); + GlStateManager.popMatrix(); } } + /* + * Renders correct arm rotation + */ @SideOnly(Side.CLIENT) @SubscribeEvent public void onPlayerRenderPre(RenderPlayerEvent.Pre event) { EntityPlayer player = Minecraft.getMinecraft().player; + AbstractClientPlayer aplayer = Minecraft.getMinecraft().player; ItemStack stack = player.getHeldItemMainhand(); RenderPlayer renderer = event.getRenderer(); + ModelBiped model = getPlayerModel(aplayer); + + ResourceLocation skinLoc = DefaultPlayerSkin.getDefaultSkin(player.getPersistentID()); if (!stack.isEmpty() && stack.getItem() == RegistrationHandler.itemTile && ItemTile.hasTileData(stack)) - { + { + model.bipedLeftArm.isHidden = true; + model.bipedRightArm.isHidden = true; + + Minecraft.getMinecraft().getTextureManager().bindTexture(skinLoc); + RenderPlayer renderPlayer = (RenderPlayer)renderer; + float rotation = -player.renderYawOffset; + ModelRenderer fakeLeftArm = new ModelRenderer(model, 40, 16); + fakeLeftArm.mirror = true; + if (aplayer.getSkinType().equals("default")) { + fakeLeftArm.addBox(model.bipedLeftArm.offsetX + 4.2F, model.bipedLeftArm.offsetY, model.bipedLeftArm.offsetZ, 4, 12, 4, .08F); + } else { + fakeLeftArm.addBox(model.bipedLeftArm.offsetX + 4.2F, model.bipedLeftArm.offsetY, model.bipedLeftArm.offsetZ, 3, 12, 4, .08F); + } + ModelRenderer fakeRightArm = new ModelRenderer(model, 40, 16); + fakeRightArm.mirror = true; + if (aplayer.getSkinType().equals("default")) { + fakeRightArm.addBox(model.bipedRightArm.offsetX - 7.9F, model.bipedRightArm.offsetY, model.bipedRightArm.offsetZ, 4, 12, 4, .08F); + } else { + fakeRightArm.addBox(model.bipedRightArm.offsetX - 7.2F, model.bipedRightArm.offsetY, model.bipedRightArm.offsetZ, 3, 12, 4, .08F); + } + + fakeRightArm.rotateAngleX = -.9F; + fakeLeftArm.rotateAngleX = -.9F; + model.bipedBody.addChild(fakeLeftArm); + model.bipedBody.addChild(fakeRightArm); + + } else { + model.bipedLeftArm.isHidden = false; + model.bipedRightArm.isHidden = false; + if (model.bipedBody.childModels != null && !model.bipedBody.childModels.isEmpty()) { + model.bipedBody.childModels.clear(); + model.bipedBody.childModels.add(model.bipedLeftArm); + model.bipedBody.childModels.add(model.bipedRightArm); + + } } + } private boolean isChest(Block block) @@ -201,4 +270,18 @@ public class RenderEvents return block == Blocks.CHEST || block == Blocks.ENDER_CHEST || block == Blocks.TRAPPED_CHEST; } + @SideOnly(Side.CLIENT) + private static RenderPlayer getRenderPlayer(AbstractClientPlayer player) + { + Minecraft mc = Minecraft.getMinecraft(); + RenderManager manager = mc.getRenderManager(); + return manager.getSkinMap().get(player.getSkinType()); + } + + @SideOnly(Side.CLIENT) + private static ModelBiped getPlayerModel(AbstractClientPlayer player) + { + return getRenderPlayer(player).getMainModel(); + } + } diff --git a/src/main/java/tschipp/carryon/common/CommonProxy.java b/src/main/java/tschipp/carryon/common/CommonProxy.java index f0faac5..3edebe9 100644 --- a/src/main/java/tschipp/carryon/common/CommonProxy.java +++ b/src/main/java/tschipp/carryon/common/CommonProxy.java @@ -20,6 +20,7 @@ public class CommonProxy @EventHandler public void init(FMLInitializationEvent event) { + RegistrationHandler.regOverrideList(); } @EventHandler diff --git a/src/main/java/tschipp/carryon/common/config/CarryOnConfig.java b/src/main/java/tschipp/carryon/common/config/CarryOnConfig.java index 060b26b..f990af3 100644 --- a/src/main/java/tschipp/carryon/common/config/CarryOnConfig.java +++ b/src/main/java/tschipp/carryon/common/config/CarryOnConfig.java @@ -26,6 +26,10 @@ public class CarryOnConfig { @Config.LangKey(CarryOn.MODID) @Config.Comment("Tile Entities that the Player is not allowed to pick up") public static Configs.ForbiddenTiles forbiddenTiles = new Configs.ForbiddenTiles(); + + @Config.LangKey(CarryOn.MODID) + @Config.Comment("Model Overrides based on NBT or on Meta. Advanced Users Only!") + public static Configs.ModelOverrides modelOverrides = new Configs.ModelOverrides(); @Mod.EventBusSubscriber public static class EventHandler { diff --git a/src/main/java/tschipp/carryon/common/config/Configs.java b/src/main/java/tschipp/carryon/common/config/Configs.java index d4508bd..f7e817d 100644 --- a/src/main/java/tschipp/carryon/common/config/Configs.java +++ b/src/main/java/tschipp/carryon/common/config/Configs.java @@ -11,7 +11,7 @@ public class Configs { public boolean facePlayer = false; @Comment("More complex Tile Entities slow down the player more") - public boolean heavyTiles = false; + public boolean heavyTiles = true; } public static class ForbiddenTiles @@ -20,9 +20,15 @@ public class Configs { @Comment("Tile Entities that cannot be picked up") public String[] forbiddenTiles = new String[] { + "minecraft:end_portal", + "minecraft:end_gateway", "animania:block_trough", "animania:block_invisiblock", + "colossalchests:*", "ic2:*", + "bigreactors:*", + "forestry:*", + "tconstruct:*", "immersiveengineering:*", "embers:block_furnace", "embers:ember_bore", @@ -36,10 +42,54 @@ public class Configs { "embers:combustor", "embers:catalzyer", "embers:field_chart", - "embers:inferno_forge" - + "embers:inferno_forge", + "storagedrawers:framingtable", }; + } + public static class ModelOverrides + { + @Config.RequiresMcRestart() + @Comment("Model Overrides based on NBT or on Meta. Advanced Users Only!") + public String[] modelOverrides = new String[] + { + "minecraft:lit_furnace->minecraft:furnace", + "quark:custom_chest{type:\"spruce\"}->quark:custom_chest;0", + "quark:custom_chest{type:\"birch\"}->quark:custom_chest;1", + "quark:custom_chest{type:\"jungle\"}->quark:custom_chest;2", + "quark:custom_chest{type:\"acacia\"}->quark:custom_chest;3", + "quark:custom_chest{type:\"dark_oak\"}->quark:custom_chest;4", + "quark:custom_chest_trap{type:\"spruce\"}->quark:custom_chest_trap;0", + "quark:custom_chest_trap{type:\"birch\"}->quark:custom_chest_trap;1", + "quark:custom_chest_trap{type:\"jungle\"}->quark:custom_chest_trap;2", + "quark:custom_chest_trap{type:\"acacia\"}->quark:custom_chest_trap;3", + "quark:custom_chest_trap{type:\"dark_oak\"}->quark:custom_chest_trap;4", + "storagedrawers:basicdrawers;0{Mat:\"spruce\"}->storagedrawers:basicdrawers;0{material:\"spruce\"}", + "storagedrawers:basicdrawers;0{Mat:\"birch\"}->storagedrawers:basicdrawers;0{material:\"birch\"}", + "storagedrawers:basicdrawers;0{Mat:\"jungle\"}->storagedrawers:basicdrawers;0{material:\"jungle\"}", + "storagedrawers:basicdrawers;0{Mat:\"acacia\"}->storagedrawers:basicdrawers;0{material:\"acacia\"}", + "storagedrawers:basicdrawers;0{Mat:\"dark_oak\"}->storagedrawers:basicdrawers;0{material:\"dark_oak\"}", + "storagedrawers:basicdrawers;1{Mat:\"spruce\"}->storagedrawers:basicdrawers;1{material:\"spruce\"}", + "storagedrawers:basicdrawers;1{Mat:\"birch\"}->storagedrawers:basicdrawers;1{material:\"birch\"}", + "storagedrawers:basicdrawers;1{Mat:\"jungle\"}->storagedrawers:basicdrawers;1{material:\"jungle\"}", + "storagedrawers:basicdrawers;1{Mat:\"acacia\"}->storagedrawers:basicdrawers;1{material:\"acacia\"}", + "storagedrawers:basicdrawers;1{Mat:\"dark_oak\"}->storagedrawers:basicdrawers;1{material:\"dark_oak\"}", + "storagedrawers:basicdrawers;2{Mat:\"spruce\"}->storagedrawers:basicdrawers;2{material:\"spruce\"}", + "storagedrawers:basicdrawers;2{Mat:\"birch\"}->storagedrawers:basicdrawers;2{material:\"birch\"}", + "storagedrawers:basicdrawers;2{Mat:\"jungle\"}->storagedrawers:basicdrawers;2{material:\"jungle\"}", + "storagedrawers:basicdrawers;2{Mat:\"acacia\"}->storagedrawers:basicdrawers;2{material:\"acacia\"}", + "storagedrawers:basicdrawers;2{Mat:\"dark_oak\"}->storagedrawers:basicdrawers;2{material:\"dark_oak\"}", + "storagedrawers:basicdrawers;3{Mat:\"spruce\"}->storagedrawers:basicdrawers;3{material:\"spruce\"}", + "storagedrawers:basicdrawers;3{Mat:\"birch\"}->storagedrawers:basicdrawers;3{material:\"birch\"}", + "storagedrawers:basicdrawers;3{Mat:\"jungle\"}->storagedrawers:basicdrawers;3{material:\"jungle\"}", + "storagedrawers:basicdrawers;3{Mat:\"acacia\"}->storagedrawers:basicdrawers;3{material:\"acacia\"}", + "storagedrawers:basicdrawers;3{Mat:\"dark_oak\"}->storagedrawers:basicdrawers;3{material:\"dark_oak\"}", + "storagedrawers:basicdrawers;4{Mat:\"spruce\"}->storagedrawers:basicdrawers;4{material:\"spruce\"}", + "storagedrawers:basicdrawers;4{Mat:\"birch\"}->storagedrawers:basicdrawers;4{material:\"birch\"}", + "storagedrawers:basicdrawers;4{Mat:\"jungle\"}->storagedrawers:basicdrawers;4{material:\"jungle\"}", + "storagedrawers:basicdrawers;4{Mat:\"acacia\"}->storagedrawers:basicdrawers;4{material:\"acacia\"}", + "storagedrawers:basicdrawers;4{Mat:\"dark_oak\"}->storagedrawers:basicdrawers;4{material:\"dark_oak\"}" + }; } } diff --git a/src/main/java/tschipp/carryon/common/event/ItemEvents.java b/src/main/java/tschipp/carryon/common/event/ItemEvents.java index 8855800..0303f99 100644 --- a/src/main/java/tschipp/carryon/common/event/ItemEvents.java +++ b/src/main/java/tschipp/carryon/common/event/ItemEvents.java @@ -95,7 +95,7 @@ public class ItemEvents if (!ItemTile.isLocked(pos, world)) { - if (ItemTile.storeTileData(te, state, stack)) + if (ItemTile.storeTileData(te, state.getActualState(world, pos), stack)) { world.removeTileEntity(pos); world.setBlockToAir(pos); diff --git a/src/main/java/tschipp/carryon/common/handler/ForbiddenTileHandler.java b/src/main/java/tschipp/carryon/common/handler/ForbiddenTileHandler.java index 2193577..1618017 100644 --- a/src/main/java/tschipp/carryon/common/handler/ForbiddenTileHandler.java +++ b/src/main/java/tschipp/carryon/common/handler/ForbiddenTileHandler.java @@ -8,7 +8,6 @@ import tschipp.carryon.common.config.CarryOnConfig; public class ForbiddenTileHandler { - public static final List FORBIDDEN_TILES; public static boolean isForbidden(Block block) diff --git a/src/main/java/tschipp/carryon/common/handler/ModelOverridesHandler.java b/src/main/java/tschipp/carryon/common/handler/ModelOverridesHandler.java new file mode 100644 index 0000000..62e0691 --- /dev/null +++ b/src/main/java/tschipp/carryon/common/handler/ModelOverridesHandler.java @@ -0,0 +1,188 @@ +package tschipp.carryon.common.handler; + +import java.util.HashMap; +import java.util.Set; + +import org.apache.commons.lang3.StringUtils; + +import net.minecraft.block.Block; +import net.minecraft.block.state.IBlockState; +import net.minecraft.client.Minecraft; +import net.minecraft.client.renderer.block.model.IBakedModel; +import net.minecraft.init.Blocks; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.JsonToNBT; +import net.minecraft.nbt.NBTException; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.nbt.NBTUtil; +import net.minecraft.util.IntHashMap; +import net.minecraftforge.fml.common.registry.IForgeRegistryEntry; +import net.minecraftforge.fml.common.registry.IForgeRegistryEntry.Impl; +import net.minecraftforge.fml.relauncher.Side; +import net.minecraftforge.fml.relauncher.SideOnly; +import tschipp.carryon.common.config.CarryOnConfig; +import tschipp.carryon.common.helper.InvalidConfigException; +import tschipp.carryon.common.helper.StringParser; + +public class ModelOverridesHandler +{ + public static HashMap OVERRIDE_OBJECTS = new HashMap(); + + /* + * This class is really ugly, will probably be replaced by something else + * - Tschipp + */ + public static void initOverrides() + { + String[] overrides = CarryOnConfig.modelOverrides.modelOverrides; + + for (int i = 0; i < overrides.length; i++) + { + Object toOverrideObject; + Object overrideObject; + NBTTagCompound tag = new NBTTagCompound(); + + String currentline = overrides[i]; + if (StringUtils.isEmpty(currentline) || !StringUtils.contains(currentline, "->")) + throw new InvalidConfigException("Missing Override Model at line " + i + " : " + currentline); + + String[] sa = currentline.split("->"); + String toOverride = ""; + String override = ""; + try + { + toOverride = sa[0]; + override = sa[1]; + } + catch (ArrayIndexOutOfBoundsException e) + { + throw new InvalidConfigException("Missing Override Model at line " + i + " : " + currentline); + } + + if (toOverride.contains("{")) + { + if (!toOverride.contains("}")) + throw new InvalidConfigException("Missing } at line " + i + " : " + currentline); + + String nbt = toOverride.substring(toOverride.indexOf("{")); + toOverride = toOverride.replace(nbt, ""); + try + { + tag = JsonToNBT.getTagFromJson(nbt); + } + catch (NBTException e) + { + throw new InvalidConfigException("Error while parsing NBT at line " + i + " : " + e.getMessage()); + } + + } + else if (toOverride.contains("}")) + throw new InvalidConfigException("Missing { at line " + i + " : " + currentline); + + int meta = StringParser.getMeta(toOverride); + if (meta == 0) + toOverrideObject = StringParser.getBlock(toOverride); + else + toOverrideObject = StringParser.getBlockState(toOverride); + + overrideObject = StringParser.getItem(override); + if (Block.getBlockFromItem((Item) overrideObject) != Blocks.AIR) + overrideObject = StringParser.getItemStack(override); + else + overrideObject = StringParser.getBlockState(override); + + NBTTagCompound keyComp = new NBTTagCompound(); + keyComp.setTag("nbttag", tag); + if (toOverrideObject instanceof Block) + { + keyComp.setString("block", ((Block) toOverrideObject).getRegistryName().toString()); + } + else + { + keyComp.setInteger("stateid", Block.getStateId((IBlockState) toOverrideObject)); + keyComp.setString("block", ((IBlockState) toOverrideObject).getBlock().getRegistryName().toString()); + } + OVERRIDE_OBJECTS.put(keyComp, overrideObject); + } + } + + public static boolean hasCustomOverrideModel(IBlockState state, NBTTagCompound tag) + { + if (OVERRIDE_OBJECTS.isEmpty()) + return false; + + int stateid = Block.getStateId(state); + NBTTagCompound[] keys = new NBTTagCompound[OVERRIDE_OBJECTS.size()]; + OVERRIDE_OBJECTS.keySet().toArray(keys); + for (NBTTagCompound key : keys) + { + int id = key.getInteger("stateid"); + Block block = StringParser.getBlock(key.getString("block")); + if (id == 0 ? block == state.getBlock() : id == stateid) + { + NBTTagCompound toCheckForCompound = key.getCompoundTag("nbttag"); + Set kSetToCheck = toCheckForCompound.getKeySet(); + Set kSetTile = tag.getKeySet(); + + boolean flag = true; + if (kSetTile.containsAll(kSetToCheck)) + { + for (String skey : kSetToCheck) + { + if (!NBTUtil.areNBTEquals(tag.getTag(skey), toCheckForCompound.getTag(skey), true)) + flag = false; + } + if (flag) + return true; + } + } + } + + return false; + } + + @SideOnly(Side.CLIENT) + public static IBakedModel getCustomOverrideModel(IBlockState state, NBTTagCompound tag) + { + int stateid = Block.getStateId(state); + NBTTagCompound[] keys = new NBTTagCompound[OVERRIDE_OBJECTS.size()]; + OVERRIDE_OBJECTS.keySet().toArray(keys); + for (NBTTagCompound key : keys) + { + int id = key.getInteger("stateid"); + Block block = StringParser.getBlock(key.getString("block")); + if (id == 0 ? block == state.getBlock() : id == stateid) + { + NBTTagCompound toCheckForCompound = key.getCompoundTag("nbttag"); + Set kSetToCheck = toCheckForCompound.getKeySet(); + Set kSetTile = tag.getKeySet(); + + boolean flag = true; + if (kSetTile.containsAll(kSetToCheck)) + { + for (String skey : kSetToCheck) + { + if (!NBTUtil.areNBTEquals(tag.getTag(skey), toCheckForCompound.getTag(skey), true)) + flag = false; + } + if (flag) + { + Object override = OVERRIDE_OBJECTS.get(key); + + if (override == null) + return null; + + if (override instanceof IBlockState) + return Minecraft.getMinecraft().getBlockRendererDispatcher().getModelForState((IBlockState) override); + else + return Minecraft.getMinecraft().getRenderItem().getItemModelMesher().getItemModel((ItemStack) override); + } + } + } + } + return null; + + } + +} diff --git a/src/main/java/tschipp/carryon/common/handler/RegistrationHandler.java b/src/main/java/tschipp/carryon/common/handler/RegistrationHandler.java index 64cc71d..2a4984d 100644 --- a/src/main/java/tschipp/carryon/common/handler/RegistrationHandler.java +++ b/src/main/java/tschipp/carryon/common/handler/RegistrationHandler.java @@ -32,5 +32,10 @@ public class RegistrationHandler { MinecraftForge.EVENT_BUS.register(new RenderEvents()); } + + public static void regOverrideList() + { + ModelOverridesHandler.initOverrides(); + } } diff --git a/src/main/java/tschipp/carryon/common/helper/InvalidConfigException.java b/src/main/java/tschipp/carryon/common/helper/InvalidConfigException.java new file mode 100644 index 0000000..f6b6097 --- /dev/null +++ b/src/main/java/tschipp/carryon/common/helper/InvalidConfigException.java @@ -0,0 +1,11 @@ +package tschipp.carryon.common.helper; + +public class InvalidConfigException extends RuntimeException +{ + + public InvalidConfigException(String cause) + { + super(cause); + } + +} diff --git a/src/main/java/tschipp/carryon/common/helper/StringParser.java b/src/main/java/tschipp/carryon/common/helper/StringParser.java new file mode 100644 index 0000000..8aec2c8 --- /dev/null +++ b/src/main/java/tschipp/carryon/common/helper/StringParser.java @@ -0,0 +1,126 @@ +package tschipp.carryon.common.helper; + +import javax.annotation.Nullable; + +import net.minecraft.block.Block; +import net.minecraft.block.state.IBlockState; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.JsonToNBT; +import net.minecraft.nbt.NBTException; +import net.minecraft.nbt.NBTTagCompound; + +public class StringParser +{ + + public static Block getBlock(String string) + { + NBTTagCompound tag = getTagCompound(string); + if(tag != null) + string = string.replace(tag.toString(), ""); + + if (string.contains(";")) + string = string.replace(string.substring(string.indexOf(";")), ""); + + Block block = Block.getBlockFromName(string); + if(block == null) + throw new InvalidConfigException("Block Parsing Error. Invalid Name: " + string); + + return block; + } + + public static int getMeta(String string) + { + NBTTagCompound tag = getTagCompound(string); + if(tag != null) + string = string.replace(tag.toString(), ""); + + + if (string.contains(";")) + { + int meta = 0; + try + { + meta = Integer.parseInt(string.substring(string.indexOf(";")).replace(";", "")); + } + catch (Exception e) + { + throw new InvalidConfigException("Meta Parsing Error at: " + string + " : " + e.getMessage()); + } + + return meta; + } + return 0; + } + + public static IBlockState getBlockState(String string) + { + NBTTagCompound tag = getTagCompound(string); + if(tag != null) + string = string.replace(tag.toString(), ""); + + int meta = getMeta(string); + if(meta == 0) + return getBlock(string).getDefaultState(); + try + { + return getBlock(string).getStateFromMeta(meta); + } + catch (Exception e) + { + throw new InvalidConfigException("Blockstate parsing Exception at: " + string + " : " + e.getMessage()); + } + } + + public static Item getItem(String string) + { + NBTTagCompound tag = getTagCompound(string); + if(tag != null) + string = string.replace(tag.toString(), ""); + + if(string.contains(";")) + string = string.replace(string.substring(string.indexOf(";")), ""); + + return Item.getByNameOrId(string); + } + + public static ItemStack getItemStack(String string) + { + ItemStack stack = new ItemStack(getItem(string), 1, getMeta(string)); + NBTTagCompound tag = getTagCompound(string); + if(tag != null) + stack.setTagCompound(tag); + + return stack; + } + + @Nullable + public static NBTTagCompound getTagCompound(String string) + { + NBTTagCompound tag = null; + if (string.contains("{")) + { + if (!string.contains("}")) + throw new InvalidConfigException("Missing } at : " + string); + + String nbt = string.substring(string.indexOf("{")); + string = string.replace(nbt, ""); + try + { + tag = JsonToNBT.getTagFromJson(nbt); + } + catch (NBTException e) + { + throw new InvalidConfigException("Error while parsing NBT: " + e.getMessage()); + } + + } + else if (string.contains("}")) + throw new InvalidConfigException("Missing { at : " + string); + + + return tag; + } + + +} diff --git a/src/main/java/tschipp/carryon/common/item/ItemTile.java b/src/main/java/tschipp/carryon/common/item/ItemTile.java index 7f3f55c..df2842b 100644 --- a/src/main/java/tschipp/carryon/common/item/ItemTile.java +++ b/src/main/java/tschipp/carryon/common/item/ItemTile.java @@ -66,6 +66,7 @@ public class ItemTile extends Item BlockPos pos2 = pos; Block containedblock = getBlock(stack); int meta = getMeta(stack); + IBlockState containedstate = getBlockState(stack); if (!world.getBlockState(pos2).getBlock().isReplaceable(world, pos2)) { pos2 = pos.offset(facing); @@ -100,11 +101,11 @@ public class ItemTile extends Item } if(hasAllDirection) - world.setBlockState(pos2, containedblock.getStateFromMeta(meta).withProperty(BlockDirectional.FACING, facing2.getOpposite())); + world.setBlockState(pos2, containedstate.withProperty(BlockDirectional.FACING, facing2.getOpposite())); else if (hasDirection) - world.setBlockState(pos2, containedblock.getStateFromMeta(meta).withProperty(BlockHorizontal.FACING, facing2.getOpposite())); + world.setBlockState(pos2, containedstate.withProperty(BlockHorizontal.FACING, facing2.getOpposite())); else - world.setBlockState(pos2, containedblock.getStateFromMeta(meta)); + world.setBlockState(pos2, containedstate); TileEntity tile = world.getTileEntity(pos2); if (tile != null) @@ -147,7 +148,7 @@ public class ItemTile extends Item if (stack.hasTagCompound()) { NBTTagCompound tag = stack.getTagCompound(); - return tag.hasKey(TILE_DATA_KEY) && tag.hasKey("block") && tag.hasKey("meta"); + return tag.hasKey(TILE_DATA_KEY) && tag.hasKey("block") && tag.hasKey("meta") && tag.hasKey("stateid"); } return false; } @@ -169,9 +170,12 @@ public class ItemTile extends Item tag.setTag(TILE_DATA_KEY, chest); + ItemStack drop = state.getBlock().getItem(tile.getWorld(), tile.getPos(), state); + tag.setString("block", state.getBlock().getRegistryName().toString()); Item item = Item.getItemFromBlock(state.getBlock()); - tag.setInteger("meta", item.getHasSubtypes() ? state.getBlock().getMetaFromState(state) : 0); + tag.setInteger("meta", drop.getItemDamage()); + tag.setInteger("stateid", Block.getStateId(state)); stack.setTagCompound(tag); return true; } @@ -184,7 +188,7 @@ public class ItemTile extends Item tag.removeTag(TILE_DATA_KEY); tag.removeTag("block"); tag.removeTag("meta"); - + tag.removeTag("stateid"); } } @@ -227,7 +231,13 @@ public class ItemTile extends Item public static IBlockState getBlockState(ItemStack stack) { - return getBlock(stack).getStateFromMeta(getMeta(stack)); + if (stack.hasTagCompound()) + { + NBTTagCompound tag = stack.getTagCompound(); + int id = tag.getInteger("stateid"); + return Block.getStateById(id); + } + return Blocks.AIR.getDefaultState(); } diff --git a/src/main/resources/assets/carryon/lang/en_US.lang b/src/main/resources/assets/carryon/lang/en_US.lang index eb3cbf8..7bcdd2d 100644 --- a/src/main/resources/assets/carryon/lang/en_US.lang +++ b/src/main/resources/assets/carryon/lang/en_US.lang @@ -1,4 +1,5 @@ carryon.category.settings=Settings carryon.category.forbiddentiles=Forbidden Tile Entities +carryon.category.modeloverrides=Model Overrides (Advanced) -carryon.general.forbiddentiles.forbiddentiles=Tile Entities that the Player cannot pick up \ No newline at end of file +carryon.general.modeloverrides.modeloverrides=Model Overrides \ No newline at end of file diff --git a/src/main/resources/mcmod.info b/src/main/resources/mcmod.info index 2962efa..b873305 100644 --- a/src/main/resources/mcmod.info +++ b/src/main/resources/mcmod.info @@ -4,9 +4,9 @@ "name" : "Carry On", "version" : "1.0", "mcversion" : "1.11.2", "url" : "", - "credits" : "Main Development by Tschipp, Rendering and Idea by Purplicious_Cow and cy4n", + "credits" : "Tschipp, Purplicious_Cow, cy4n", "authorList" : ["Tschipp, Purplicious_Cow, cy4n"], - "description": "A simple mod that lets you pick up Tile Entities", + "description": "Carry On is a simple mod that improves game interaction by allowing players to pick up, carry, and place single block Tile Entities using only their empty hands.", "logoFile" : "assets/carryon/textures/logo.png", "updateUrl" : "", "parent" : "",