From 240c5a9ada79315dc50546e4499f7dc531e421e5 Mon Sep 17 00:00:00 2001 From: Trent Patterson Date: Sun, 19 Nov 2017 20:45:12 -0500 Subject: [PATCH] Add files via upload --- build.gradle | 63 ++++ .../com/jtrent238/jtrent238bags/BagMod.java | 142 ++++++++ .../jtrent238bags/ForgeSubscribe.java | 9 + .../jtrent238/jtrent238bags/ItemLoader.java | 37 ++ .../com/jtrent238/jtrent238bags/OreDict.java | 43 +++ .../com/jtrent238/jtrent238bags/Recipes.java | 58 ++++ .../jtrent238/jtrent238bags/bags/ItemBag.java | 123 +++++++ .../jtrent238bags/client/ClientProxy.java | 9 + .../jtrent238bags/common/CommonProxy.java | 39 +++ .../jtrent238bags/container/ContainerBag.java | 319 ++++++++++++++++++ .../jtrent238bags/gui/GuiBagInventory.java | 115 +++++++ .../jtrent238bags/inventory/InventoryBag.java | 207 ++++++++++++ .../jtrent238bags/items/ItemDebug.java | 38 +++ .../assets/jtrent238bags/lang/en_US.lang | 18 + .../textures/gui/InventoryBag.png | Bin 0 -> 3672 bytes .../jtrent238bags/textures/gui/Thumbs.db | Bin 0 -> 3584 bytes .../jtrent238bags/textures/items/ItemBag.png | Bin 0 -> 297 bytes .../textures/items/ItemBag_Cow.png | Bin 0 -> 376 bytes .../textures/items/ItemBag_JSQ.png | Bin 0 -> 460 bytes .../textures/items/ItemBag_Plain.png | Bin 0 -> 297 bytes .../textures/items/ItemBag__MrGregor_.png | Bin 0 -> 398 bytes .../textures/items/ItemBag_blue.png | Bin 0 -> 299 bytes .../textures/items/ItemBag_cyan.png | Bin 0 -> 287 bytes .../textures/items/ItemBag_green.png | Bin 0 -> 286 bytes .../textures/items/ItemBag_jtrent238.png | Bin 0 -> 595 bytes .../textures/items/ItemBag_lightBlue.png | Bin 0 -> 287 bytes .../textures/items/ItemBag_lime.png | Bin 0 -> 286 bytes .../textures/items/ItemBag_magenta.png | Bin 0 -> 290 bytes .../textures/items/ItemBag_orange.png | Bin 0 -> 288 bytes .../textures/items/ItemBag_pink.png | Bin 0 -> 293 bytes .../textures/items/ItemBag_purple.png | Bin 0 -> 292 bytes .../textures/items/ItemBag_red.png | Bin 0 -> 289 bytes .../textures/items/ItemBag_white.png | Bin 0 -> 286 bytes .../textures/items/ItemBag_yellow.png | Bin 0 -> 287 bytes .../textures/items/ItemDebug.png | Bin 0 -> 232 bytes src/main/resources/mcmod.info | 16 + 36 files changed, 1236 insertions(+) create mode 100644 build.gradle create mode 100644 src/main/java/com/jtrent238/jtrent238bags/BagMod.java create mode 100644 src/main/java/com/jtrent238/jtrent238bags/ForgeSubscribe.java create mode 100644 src/main/java/com/jtrent238/jtrent238bags/ItemLoader.java create mode 100644 src/main/java/com/jtrent238/jtrent238bags/OreDict.java create mode 100644 src/main/java/com/jtrent238/jtrent238bags/Recipes.java create mode 100644 src/main/java/com/jtrent238/jtrent238bags/bags/ItemBag.java create mode 100644 src/main/java/com/jtrent238/jtrent238bags/client/ClientProxy.java create mode 100644 src/main/java/com/jtrent238/jtrent238bags/common/CommonProxy.java create mode 100644 src/main/java/com/jtrent238/jtrent238bags/container/ContainerBag.java create mode 100644 src/main/java/com/jtrent238/jtrent238bags/gui/GuiBagInventory.java create mode 100644 src/main/java/com/jtrent238/jtrent238bags/inventory/InventoryBag.java create mode 100644 src/main/java/com/jtrent238/jtrent238bags/items/ItemDebug.java create mode 100644 src/main/resources/assets/jtrent238bags/lang/en_US.lang create mode 100644 src/main/resources/assets/jtrent238bags/textures/gui/InventoryBag.png create mode 100644 src/main/resources/assets/jtrent238bags/textures/gui/Thumbs.db create mode 100644 src/main/resources/assets/jtrent238bags/textures/items/ItemBag.png create mode 100644 src/main/resources/assets/jtrent238bags/textures/items/ItemBag_Cow.png create mode 100644 src/main/resources/assets/jtrent238bags/textures/items/ItemBag_JSQ.png create mode 100644 src/main/resources/assets/jtrent238bags/textures/items/ItemBag_Plain.png create mode 100644 src/main/resources/assets/jtrent238bags/textures/items/ItemBag__MrGregor_.png create mode 100644 src/main/resources/assets/jtrent238bags/textures/items/ItemBag_blue.png create mode 100644 src/main/resources/assets/jtrent238bags/textures/items/ItemBag_cyan.png create mode 100644 src/main/resources/assets/jtrent238bags/textures/items/ItemBag_green.png create mode 100644 src/main/resources/assets/jtrent238bags/textures/items/ItemBag_jtrent238.png create mode 100644 src/main/resources/assets/jtrent238bags/textures/items/ItemBag_lightBlue.png create mode 100644 src/main/resources/assets/jtrent238bags/textures/items/ItemBag_lime.png create mode 100644 src/main/resources/assets/jtrent238bags/textures/items/ItemBag_magenta.png create mode 100644 src/main/resources/assets/jtrent238bags/textures/items/ItemBag_orange.png create mode 100644 src/main/resources/assets/jtrent238bags/textures/items/ItemBag_pink.png create mode 100644 src/main/resources/assets/jtrent238bags/textures/items/ItemBag_purple.png create mode 100644 src/main/resources/assets/jtrent238bags/textures/items/ItemBag_red.png create mode 100644 src/main/resources/assets/jtrent238bags/textures/items/ItemBag_white.png create mode 100644 src/main/resources/assets/jtrent238bags/textures/items/ItemBag_yellow.png create mode 100644 src/main/resources/assets/jtrent238bags/textures/items/ItemDebug.png create mode 100644 src/main/resources/mcmod.info diff --git a/build.gradle b/build.gradle new file mode 100644 index 0000000..c9d0ce8 --- /dev/null +++ b/build.gradle @@ -0,0 +1,63 @@ +buildscript { + repositories { + mavenCentral() + maven { + name = "forge" + url = "http://files.minecraftforge.net/maven" + } + maven { + name = "sonatype" + url = "https://oss.sonatype.org/content/repositories/snapshots/" + } + } + dependencies { + classpath 'net.minecraftforge.gradle:ForgeGradle:1.2-SNAPSHOT' + } +} + +apply plugin: 'forge' + +version = "1.0.0.0" +group= "com.jtrent238.jtrent238bags" // http://maven.apache.org/guides/mini/guide-naming-conventions.html +archivesBaseName = "jtrent238bags" + +minecraft { + version = "1.7.10-10.13.4.1448-1.7.10" + runDir = "eclipse" +} + +dependencies { + // you may put jars on which you depend on in ./libs + // or you may define them like so.. + //compile "some.group:artifact:version:classifier" + //compile "some.group:artifact:version" + + // real examples + //compile 'com.mod-buildcraft:buildcraft:6.0.8:dev' // adds buildcraft to the dev env + //compile 'com.googlecode.efficient-java-matrix-library:ejml:0.24' // adds ejml to the dev env + + // for more info... + // http://www.gradle.org/docs/current/userguide/artifact_dependencies_tutorial.html + // http://www.gradle.org/docs/current/userguide/dependency_management.html + +} + +processResources +{ + // this will ensure that this task is redone when the versions change. + inputs.property "version", project.version + inputs.property "mcversion", project.minecraft.version + + // replace stuff in mcmod.info, nothing else + from(sourceSets.main.resources.srcDirs) { + include 'mcmod.info' + + // replace version and mcversion + expand 'version':project.version, 'mcversion':project.minecraft.version + } + + // copy everything else, thats not the mcmod.info + from(sourceSets.main.resources.srcDirs) { + exclude 'mcmod.info' + } +} diff --git a/src/main/java/com/jtrent238/jtrent238bags/BagMod.java b/src/main/java/com/jtrent238/jtrent238bags/BagMod.java new file mode 100644 index 0000000..c0a3fc8 --- /dev/null +++ b/src/main/java/com/jtrent238/jtrent238bags/BagMod.java @@ -0,0 +1,142 @@ +package com.jtrent238.jtrent238bags; + + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +import com.jtrent238.jtrent238bags.common.CommonProxy; +import com.jtrent238.jtrent238bags.inventory.InventoryBag; +import com.jtrent238.jtrent238bags.client.ClientProxy; +import com.jtrent238.jtrent238bags.ForgeSubscribe; +import com.jtrent238.jtrent238bags.bags.ItemBag; + +import cpw.mods.fml.common.Loader; +import cpw.mods.fml.common.Mod; +import cpw.mods.fml.common.Mod.EventHandler; +import cpw.mods.fml.common.Mod.Instance; +import cpw.mods.fml.common.ModContainer; +import cpw.mods.fml.common.SidedProxy; +import cpw.mods.fml.common.event.FMLInitializationEvent; +import cpw.mods.fml.common.event.FMLPostInitializationEvent; +import cpw.mods.fml.common.event.FMLPreInitializationEvent; +import cpw.mods.fml.common.event.FMLServerStartingEvent; +import cpw.mods.fml.common.eventhandler.EventPriority; +import cpw.mods.fml.common.network.IGuiHandler; +import cpw.mods.fml.common.network.NetworkRegistry; +import cpw.mods.fml.common.registry.GameRegistry; +import cpw.mods.fml.common.registry.LanguageRegistry; +import net.minecraft.block.Block; +import net.minecraft.command.ICommandManager; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.init.Items; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.server.MinecraftServer; +import net.minecraft.util.WeightedRandomChestContent; +import net.minecraft.world.World; +import net.minecraftforge.client.event.RenderGameOverlayEvent; +import net.minecraftforge.common.ChestGenHooks; + +@Mod(modid = BagMod.MODID, name = BagMod.MODNAME, version = BagMod.MODVERSION) +public final class BagMod +{ + + public static final String MODID = "jtrent238bags"; + + @Instance(MODID) + public static BagMod instance; + public static final String MODVERSION = "1.0.0.0"; + public static final String MODNAME = "jtrent238's Bag Mod"; + public static final String MODAUTHOR = "jtrent238"; + public static final String MC = "1.7.10"; + + @SidedProxy(clientSide="com.jtrent238.jtrent238bags.client.ClientProxy", serverSide="com.jtrent238.jtrent238bags.common.CommonProxy") + public static CommonProxy proxy; + + /** This is used to keep track of GUIs that we make*/ + private static int modGuiIndex = 0; + + /** Set our custom inventory Gui index to the next available Gui index */ + public static final int GUI_ITEM_INV = modGuiIndex++; + + // ITEMS ETC. + public static Item ItemBag; + + public static CreativeTabs BagTab = new CreativeTabs("BagTab") + + { + public Item getTabIconItem() { + + return new ItemStack(ItemLoader.ItemBag).getItem(); + } + + public boolean hasSearchBar(){ + return false; + } + /* + @SideOnly(Side.CLIENT) + public String getBackgroundImageName() + { + return "EpicProportionsMod_Halloween.png"; + } + + @SideOnly(Side.CLIENT) + public boolean drawInForegroundOfTab() + { + return false; + } + */ + + }; + + private List List; + + private Collection Colection; + + @EventHandler + public void preInit(FMLPreInitializationEvent event) + { + ItemLoader.LoadItems(); + //BlockLoader.loadBlocks(); + Recipes.registerRecpies(); + //EntityLoader.LoadEntitys(); + OreDict.addores(); + //Achievements.loadAchievements(); + //Stats.RegisterStats(); + //ChestGen.registerItems(); + } + + @EventHandler + public void load(FMLInitializationEvent event) + { + // no renderers or entities to register, but whatever + proxy.registerRenderers(); + // register CommonProxy as our GuiHandler + NetworkRegistry.INSTANCE.registerGuiHandler(this, new CommonProxy()); + + Recipes.registerRecpies(); + } + + @EventHandler + public void postInit(FMLPostInitializationEvent event) + { + Recipes.registerRecpies(); + } + + @EventHandler + public void serverStart(FMLServerStartingEvent event) + { + MinecraftServer server = MinecraftServer.getServer(); + // Get's the current server instance + + ICommandManager command = server.getCommandManager(); + //ServerCommandManager manager = (ServerCommandManager) command; + + //manager.registerCommand(new CommandModInfo()); + //manager.registerCommand(new CommandChangelog()); + } + + +} \ No newline at end of file diff --git a/src/main/java/com/jtrent238/jtrent238bags/ForgeSubscribe.java b/src/main/java/com/jtrent238/jtrent238bags/ForgeSubscribe.java new file mode 100644 index 0000000..5f4ef5c --- /dev/null +++ b/src/main/java/com/jtrent238/jtrent238bags/ForgeSubscribe.java @@ -0,0 +1,9 @@ +package com.jtrent238.jtrent238bags; + +import cpw.mods.fml.common.eventhandler.EventPriority; + +public @interface ForgeSubscribe { + + EventPriority priority(); + +} diff --git a/src/main/java/com/jtrent238/jtrent238bags/ItemLoader.java b/src/main/java/com/jtrent238/jtrent238bags/ItemLoader.java new file mode 100644 index 0000000..07b7b75 --- /dev/null +++ b/src/main/java/com/jtrent238/jtrent238bags/ItemLoader.java @@ -0,0 +1,37 @@ +package com.jtrent238.jtrent238bags; + +import com.jtrent238.jtrent238bags.bags.ItemBag; +import com.jtrent238.jtrent238bags.items.ItemDebug; + +import cpw.mods.fml.common.registry.GameRegistry; +import cpw.mods.fml.common.registry.LanguageRegistry; +import net.minecraft.item.Item; + +public class ItemLoader { + + public static Item ItemBag; + public static Item ItemDebug; + + + public static void LoadItems() { + + ItemBag = new ItemBag(0, 0, ItemBag, null, null, null).setUnlocalizedName("ItemBag").setTextureName(BagMod.MODID + ":" + "ItemBag").setCreativeTab(BagMod.BagTab); + ItemDebug = new ItemDebug().setUnlocalizedName("ItemDebug").setTextureName(BagMod.MODID + ":" + "ItemDebug"); + + registerItems(); + } + + private static void registerItems() { + + GameRegistry.registerItem(ItemBag, ItemBag.getUnlocalizedName().substring(5)); + GameRegistry.registerItem(ItemDebug, ItemDebug.getUnlocalizedName().substring(5)); + + + } + + + + + + +} diff --git a/src/main/java/com/jtrent238/jtrent238bags/OreDict.java b/src/main/java/com/jtrent238/jtrent238bags/OreDict.java new file mode 100644 index 0000000..d6116d9 --- /dev/null +++ b/src/main/java/com/jtrent238/jtrent238bags/OreDict.java @@ -0,0 +1,43 @@ +package com.jtrent238.jtrent238bags; + +import java.util.HashMap; +import java.util.Map; +import java.util.logging.Level; + +import com.jtrent238.jtrent238bags.bags.ItemBag; + +import cpw.mods.fml.common.Loader; +import cpw.mods.fml.common.registry.GameRegistry; +import net.minecraft.init.Blocks; +import net.minecraft.init.Items; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraftforge.common.MinecraftForge; +import net.minecraftforge.oredict.OreDictionary; + +public class OreDict { + + public static void addores() { + + OreDictionary.registerOre("bag" + ItemBag.field_150923_a[0].toUpperCase(), new ItemStack(ItemLoader.ItemBag, 0)); + OreDictionary.registerOre("bag" + ItemBag.field_150923_a[1].toUpperCase(), new ItemStack(ItemLoader.ItemBag, 1)); + OreDictionary.registerOre("bag" + ItemBag.field_150923_a[2].toUpperCase(), new ItemStack(ItemLoader.ItemBag, 2)); + OreDictionary.registerOre("bag" + ItemBag.field_150923_a[3].toUpperCase(), new ItemStack(ItemLoader.ItemBag, 3)); + OreDictionary.registerOre("bag" + ItemBag.field_150923_a[4].toUpperCase(), new ItemStack(ItemLoader.ItemBag, 4)); + OreDictionary.registerOre("bag" + ItemBag.field_150923_a[5].toUpperCase(), new ItemStack(ItemLoader.ItemBag, 5)); + OreDictionary.registerOre("bag" + ItemBag.field_150923_a[6].toUpperCase(), new ItemStack(ItemLoader.ItemBag, 6)); + OreDictionary.registerOre("bag" + ItemBag.field_150923_a[7].toUpperCase(), new ItemStack(ItemLoader.ItemBag, 7)); + OreDictionary.registerOre("bag" + ItemBag.field_150923_a[8].toUpperCase(), new ItemStack(ItemLoader.ItemBag, 8)); + OreDictionary.registerOre("bag" + ItemBag.field_150923_a[9].toUpperCase(), new ItemStack(ItemLoader.ItemBag, 9)); + OreDictionary.registerOre("bag" + ItemBag.field_150923_a[10].toUpperCase(), new ItemStack(ItemLoader.ItemBag, 10)); + OreDictionary.registerOre("bag" + ItemBag.field_150923_a[11].toUpperCase(), new ItemStack(ItemLoader.ItemBag, 11)); + OreDictionary.registerOre("bag" + ItemBag.field_150923_a[12].toUpperCase(), new ItemStack(ItemLoader.ItemBag, 12)); + OreDictionary.registerOre("bag" + ItemBag.field_150923_a[13].toUpperCase(), new ItemStack(ItemLoader.ItemBag)); + OreDictionary.registerOre("bag" + ItemBag.field_150923_a[14].toUpperCase(), new ItemStack(ItemLoader.ItemBag, 14)); + OreDictionary.registerOre("bag" + ItemBag.field_150923_a[15].toUpperCase(), new ItemStack(ItemLoader.ItemBag, 15)); + OreDictionary.registerOre("bag" + ItemBag.field_150923_a[16].toUpperCase(), new ItemStack(ItemLoader.ItemBag, 16)); + //OreDictionary.registerOre("bag" + ItemBag.field_150923_a[17], ItemLoader.ItemBag.getItemById(17)); + + } + +} diff --git a/src/main/java/com/jtrent238/jtrent238bags/Recipes.java b/src/main/java/com/jtrent238/jtrent238bags/Recipes.java new file mode 100644 index 0000000..66cdb3a --- /dev/null +++ b/src/main/java/com/jtrent238/jtrent238bags/Recipes.java @@ -0,0 +1,58 @@ +package com.jtrent238.jtrent238bags; + + +import cpw.mods.fml.common.registry.GameRegistry; +import net.minecraft.init.Items; +import net.minecraft.item.ItemStack; + +public class Recipes { + + + /** + * Register Recipes with Game Registry. + */ + public static void registerRecpies(){ + addShaplessRecpies(); + addShapedRecpies(); + addsmeltigrecipies(); + } + + /** + * Add Shaped Recipes. + */ + private static void addShapedRecpies(){ + GameRegistry.addShapedRecipe(new ItemStack(ItemLoader.ItemBag, 1, 0), "SXS", "XBX", "XXX", 'X', Items.leather, 'S', Items.string); + GameRegistry.addShapedRecipe(new ItemStack(ItemLoader.ItemBag, 1, 1), "XXX", "XBX", "XXX", 'X', new ItemStack(Items.dye, 1, 1), 'B', ItemLoader.ItemBag); + GameRegistry.addShapedRecipe(new ItemStack(ItemLoader.ItemBag, 1, 2), "XXX", "XBX", "XXX", 'X', new ItemStack(Items.dye, 1, 2), 'B', ItemLoader.ItemBag); + GameRegistry.addShapedRecipe(new ItemStack(ItemLoader.ItemBag, 1, 3), "XXX", "XBX", "XXX", 'X', new ItemStack(Items.dye, 1, 4), 'B', ItemLoader.ItemBag); + GameRegistry.addShapedRecipe(new ItemStack(ItemLoader.ItemBag, 1, 4), "XXX", "XBX", "XXX", 'X', new ItemStack(Items.dye, 1, 5), 'B', ItemLoader.ItemBag); + GameRegistry.addShapedRecipe(new ItemStack(ItemLoader.ItemBag, 1, 5), "XXX", "XBX", "XXX", 'X', new ItemStack(Items.dye, 1, 6), 'B', ItemLoader.ItemBag); + GameRegistry.addShapedRecipe(new ItemStack(ItemLoader.ItemBag, 1, 6), "XXX", "XBX", "XXX", 'X', new ItemStack(Items.dye, 1, 9), 'B', ItemLoader.ItemBag); + GameRegistry.addShapedRecipe(new ItemStack(ItemLoader.ItemBag, 1, 7), "XXX", "XBX", "XXX", 'X', new ItemStack(Items.dye, 1, 10), 'B', ItemLoader.ItemBag); + GameRegistry.addShapedRecipe(new ItemStack(ItemLoader.ItemBag, 1, 8), "XXX", "XBX", "XXX", 'X', new ItemStack(Items.dye, 1, 11), 'B', ItemLoader.ItemBag); + GameRegistry.addShapedRecipe(new ItemStack(ItemLoader.ItemBag, 1, 9), "XXX", "XBX", "XXX", 'X', new ItemStack(Items.dye, 1, 12), 'B', ItemLoader.ItemBag); + GameRegistry.addShapedRecipe(new ItemStack(ItemLoader.ItemBag, 1, 10), "XXX", "XBX", "XXX", 'X', new ItemStack(Items.dye, 1, 13), 'B', ItemLoader.ItemBag); + GameRegistry.addShapedRecipe(new ItemStack(ItemLoader.ItemBag, 1, 11), "XXX", "XBX", "XXX", 'X', new ItemStack(Items.dye, 1, 14), 'B', ItemLoader.ItemBag); + GameRegistry.addShapedRecipe(new ItemStack(ItemLoader.ItemBag, 1, 12), "XXX", "XBX", "XXX", 'X', new ItemStack(Items.dye, 1, 15), 'B', ItemLoader.ItemBag); + + + } + + /** + * Add Shapeless Recipes. + */ + private static void addShaplessRecpies(){ + + } + /** + * Add Smelting Recipes + */ + private static void addsmeltigrecipies(){ + + } + + } + + + + diff --git a/src/main/java/com/jtrent238/jtrent238bags/bags/ItemBag.java b/src/main/java/com/jtrent238/jtrent238bags/bags/ItemBag.java new file mode 100644 index 0000000..7230fae --- /dev/null +++ b/src/main/java/com/jtrent238/jtrent238bags/bags/ItemBag.java @@ -0,0 +1,123 @@ +package com.jtrent238.jtrent238bags.bags; + +import java.util.Collection; +import java.util.List; + +import com.jtrent238.jtrent238bags.BagMod; +import com.jtrent238.jtrent238bags.inventory.InventoryBag; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.init.Items; +import net.minecraft.inventory.IInventory; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.util.IIcon; +import net.minecraft.util.MathHelper; +import net.minecraft.world.World; + +public class ItemBag extends Item +{ + public static final String[] field_150923_a = new String[] {"Plain", "red", "green","blue", "purple", "cyan", "pink", "lime", "yellow", "lightBlue", "magenta", "orange", "white", "Cow", "JSQ", "_MrGregor_", "jtrent238"}; + public static final String[] field_150921_b = new String[] {"Plain", "red", "green","blue", "purple", "cyan", "pink", "lime", "yellow", "lightBlue", "magenta", "orange", "white", "Cow", "JSQ", "_MrGregor_", "jtrent238"}; + public static final int[] field_150922_c = new int[] {1973019, 11743532, 3887386, 5320730, 2437522, 8073150, 2651799, 11250603, 4408131, 14188952, 4312372, 14602026, 6719955, 12801229, 15435844, 15790320}; + @SideOnly(Side.CLIENT) + private IIcon[] field_150920_d; + private IInventory Inventory; + private static final String __OBFID = "CL_00000022"; + + public ItemBag(int par1,int p_77647_1_, Item p_150895_1_, CreativeTabs p_150895_2_, List p_150895_3_, Collection c) + { + super(); + // ItemStacks that store an NBT Tag Compound are limited to stack size of 1 + setMaxStackSize(1); + // you'll want to set a creative tab as well, so you can get your item + setCreativeTab(BagMod.BagTab); + this.getMetadata(p_77647_1_); + //this.setMaxDamage(0); + this.setHasSubtypes(true); + } + + /** + * returns a list of items with the same ID, but different meta (eg: dye returns 16 items) + */ + @SideOnly(Side.CLIENT) + public void getSubItems(Item p_150895_1_, CreativeTabs p_150895_2_, List p_150895_3_) + { + //for (int i = 0; i < [AmountOfBags]; ++i) + for (int i = 0; i < 17; ++i) + { + p_150895_3_.add(new ItemStack(p_150895_1_, 1, i)); + } + } + + /** + * Returns the unlocalized name of this item. This version accepts an ItemStack so different stacks can have + * different names based on their damage or NBT. + */ + public String getUnlocalizedName(ItemStack p_77667_1_) + { + int i = MathHelper.clamp_int(p_77667_1_.getItemDamage(), 0, 17); + return super.getUnlocalizedName() + "." + field_150923_a[i]; + } + + /** + * Gets an icon index based on an item's damage value + */ + @SideOnly(Side.CLIENT) + public IIcon getIconFromDamage(int p_77617_1_) + { + int j = MathHelper.clamp_int(p_77617_1_, 0, 17); + return this.field_150920_d[j]; + } + + @SideOnly(Side.CLIENT) + public void registerIcons(IIconRegister p_94581_1_) + { + this.field_150920_d = new IIcon[field_150921_b.length]; + + for (int i = 0; i < field_150921_b.length; ++i) + { + this.field_150920_d[i] = p_94581_1_.registerIcon(this.getIconString() + "_" + field_150921_b[i]); + } + } + + /* + @Override + @SideOnly(Side.CLIENT) + public void registerIcons(IIconRegister iconRegister) + { + this.itemIcon = iconRegister.registerIcon(BagMod.MODID + ":" + this.getUnlocalizedName().substring(5)); + } + */ + + // Without this method, your inventory will NOT work!!! + @Override + public int getMaxItemUseDuration(ItemStack stack) { + return 1; // return any value greater than zero + } + + @Override + public ItemStack onItemRightClick(ItemStack itemstack, World world, EntityPlayer player) + { + if (!world.isRemote) + { + // If player not sneaking, open the inventory gui + if (!player.isSneaking()) { + player.openGui(BagMod.instance, BagMod.GUI_ITEM_INV, world, 0, 0, 0); + } + + // Otherwise, stealthily place some diamonds in there for a nice surprise next time you open it up :) + else { + new InventoryBag(player.getHeldItem()).setInventorySlotContents(0, new ItemStack(Items.diamond,4)); + } + } + + return itemstack; + } + + +} \ No newline at end of file diff --git a/src/main/java/com/jtrent238/jtrent238bags/client/ClientProxy.java b/src/main/java/com/jtrent238/jtrent238bags/client/ClientProxy.java new file mode 100644 index 0000000..190c2d4 --- /dev/null +++ b/src/main/java/com/jtrent238/jtrent238bags/client/ClientProxy.java @@ -0,0 +1,9 @@ +package com.jtrent238.jtrent238bags.client; + +import com.jtrent238.jtrent238bags.common.CommonProxy; + +public class ClientProxy extends CommonProxy +{ + @Override + public void registerRenderers() {} +} \ No newline at end of file diff --git a/src/main/java/com/jtrent238/jtrent238bags/common/CommonProxy.java b/src/main/java/com/jtrent238/jtrent238bags/common/CommonProxy.java new file mode 100644 index 0000000..83f28d7 --- /dev/null +++ b/src/main/java/com/jtrent238/jtrent238bags/common/CommonProxy.java @@ -0,0 +1,39 @@ +package com.jtrent238.jtrent238bags.common; + +import com.jtrent238.jtrent238bags.BagMod; +import com.jtrent238.jtrent238bags.container.ContainerBag; +import com.jtrent238.jtrent238bags.gui.GuiBagInventory; +import com.jtrent238.jtrent238bags.inventory.InventoryBag; + +import cpw.mods.fml.common.network.IGuiHandler; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.world.World; + +public class CommonProxy implements IGuiHandler +{ + public void registerRenderers() {} + + @Override + public Object getServerGuiElement(int guiId, EntityPlayer player, World world, int x, int y, int z) + { + // Hooray, no 'magic' numbers - we know exactly which Gui this refers to + if (guiId == BagMod.GUI_ITEM_INV) + { + // Use the player's held item to create the inventory + return new ContainerBag(player, player.inventory, new InventoryBag(player.getHeldItem())); + } + return null; + } + + @Override + public Object getClientGuiElement(int guiId, EntityPlayer player, World world, int x, int y, int z) + { + if (guiId == BagMod.GUI_ITEM_INV) + { + // We have to cast the new container as our custom class + // and pass in currently held item for the inventory + return new GuiBagInventory((ContainerBag) new ContainerBag(player, player.inventory, new InventoryBag(player.getHeldItem()))); + } + return null; + } +} diff --git a/src/main/java/com/jtrent238/jtrent238bags/container/ContainerBag.java b/src/main/java/com/jtrent238/jtrent238bags/container/ContainerBag.java new file mode 100644 index 0000000..6f1e498 --- /dev/null +++ b/src/main/java/com/jtrent238/jtrent238bags/container/ContainerBag.java @@ -0,0 +1,319 @@ +package com.jtrent238.jtrent238bags.container; + +import com.jtrent238.jtrent238bags.bags.ItemBag; +import com.jtrent238.jtrent238bags.inventory.InventoryBag; + +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.entity.player.InventoryPlayer; +import net.minecraft.inventory.Container; +import net.minecraft.inventory.IInventory; +import net.minecraft.inventory.Slot; +import net.minecraft.item.ItemStack; + +public class ContainerBag extends Container +{ + /** The Item Inventory for this Container, only needed if you want to reference isUseableByPlayer */ + public final InventoryBag inventory; + + /** Using these will make transferStackInSlot easier to understand and implement + * INV_START is the index of the first slot in the Player's Inventory, so our + * InventoryItem's number of slots (e.g. 5 slots is array indices 0-4, so start at 5) + * Notice how we don't have to remember how many slots we made? We can just use + * InventoryItem.INV_SIZE and if we ever change it, the Container updates automatically. */ + private static final int INV_START = InventoryBag.INV_SIZE, INV_END = INV_START+26, + HOTBAR_START = INV_END+1, HOTBAR_END = HOTBAR_START+8; + + // If you're planning to add armor slots, put those first like this: + // ARMOR_START = InventoryItem.INV_SIZE, ARMOR_END = ARMOR_START+3, + // INV_START = ARMOR_END+1, and then carry on like above. + + public ContainerBag(EntityPlayer par1Player, InventoryPlayer inventoryPlayer, InventoryBag inventoryItem) + { + this.inventory = inventoryItem; + + int i; + + // ITEM INVENTORY - you'll need to adjust the slot locations to match your texture file + // I have them set vertically in columns of 4 to the right of the player model + for (i = 0; i < InventoryBag.INV_SIZE; ++i) + { + // You can make a custom Slot if you need different behavior, + // such as only certain item types can be put into this slot + // We made a custom slot to prevent our inventory-storing item + // from being stored within itself, but if you want to allow that and + // you followed my advice at the end of the above step, then you + // could get away with using the vanilla Slot class + this.addSlotToContainer(new SlotItemInv(this.inventory, i, 80 + (18 * (int)(i/4)), 8 + (18*(i%4)))); + } + + // If you want, you can add ARMOR SLOTS here as well, but you need to + // make a public version of SlotArmor. I won't be doing that in this tutorial. + /* + for (i = 0; i < 4; ++i) + { + // These are the standard positions for survival inventory layout + this.addSlotToContainer(new SlotArmor(this.player, inventoryPlayer, inventoryPlayer.getSizeInventory() - 1 - i, 8, 8 + i * 18, i)); + } + */ + + // PLAYER INVENTORY - uses default locations for standard inventory texture file + for (i = 0; i < 3; ++i) + { + for (int j = 0; j < 9; ++j) + { + this.addSlotToContainer(new Slot(inventoryPlayer, j + i * 9 + 9, 8 + j * 18, 84 + i * 18)); + } + } + + // PLAYER ACTION BAR - uses default locations for standard action bar texture file + for (i = 0; i < 9; ++i) + { + this.addSlotToContainer(new Slot(inventoryPlayer, i, 8 + i * 18, 142)); + } + } + + @Override + public boolean canInteractWith(EntityPlayer entityplayer) + { + // be sure to return the inventory's isUseableByPlayer method + // if you defined special behavior there: + return inventory.isUseableByPlayer(entityplayer); + } + + /** + * Called when a player shift-clicks on a slot. You must override this or you will crash when someone does that. + */ + public ItemStack transferStackInSlot(EntityPlayer par1EntityPlayer, int index) + { + ItemStack itemstack = null; + Slot slot = (Slot) this.inventorySlots.get(index); + + if (slot != null && slot.getHasStack()) + { + ItemStack itemstack1 = slot.getStack(); + itemstack = itemstack1.copy(); + + // If item is in our custom Inventory or armor slot + if (index < INV_START) + { + // try to place in player inventory / action bar + if (!this.mergeItemStack(itemstack1, INV_START, HOTBAR_END+1, true)) + { + return null; + } + + slot.onSlotChange(itemstack1, itemstack); + } + // Item is in inventory / hotbar, try to place in custom inventory or armor slots + else + { + /* + If your inventory only stores certain instances of Items, + you can implement shift-clicking to your inventory like this: + + // Check that the item is the right type + if (itemstack1.getItem() instanceof ItemCustom) + { + // Try to merge into your custom inventory slots + // We use 'InventoryItem.INV_SIZE' instead of INV_START just in case + // you also add armor or other custom slots + if (!this.mergeItemStack(itemstack1, 0, InventoryItem.INV_SIZE, false)) + { + return null; + } + } + // If you added armor slots, check them here as well: + // Item being shift-clicked is armor - try to put in armor slot + if (itemstack1.getItem() instanceof ItemArmor) + { + int type = ((ItemArmor) itemstack1.getItem()).armorType; + if (!this.mergeItemStack(itemstack1, ARMOR_START + type, ARMOR_START + type + 1, false)) + { + return null; + } + } + Otherwise, you have basically 2 choices: + 1. shift-clicking between player inventory and custom inventory + 2. shift-clicking between action bar and inventory + + Be sure to choose only ONE of the following implementations!!! + */ + /** + * Implementation number 1: Shift-click into your custom inventory + */ + if (index >= INV_START) + { + // place in custom inventory + if (!this.mergeItemStack(itemstack1, 0, INV_START, false)) + { + return null; + } + } + + /** + * Implementation number 2: Shift-click items between action bar and inventory + */ + // item is in player's inventory, but not in action bar + if (index >= INV_START && index < HOTBAR_START) + { + // place in action bar + if (!this.mergeItemStack(itemstack1, HOTBAR_START, HOTBAR_END+1, false)) + { + return null; + } + } + // item in action bar - place in player inventory + else if (index >= HOTBAR_START && index < HOTBAR_END+1) + { + if (!this.mergeItemStack(itemstack1, INV_START, INV_END+1, false)) + { + return null; + } + } + } + + if (itemstack1.stackSize == 0) + { + slot.putStack((ItemStack) null); + } + else + { + slot.onSlotChanged(); + } + + if (itemstack1.stackSize == itemstack.stackSize) + { + return null; + } + + slot.onPickupFromSlot(par1EntityPlayer, itemstack1); + } + + return itemstack; + } + + /** + * You should override this method to prevent the player from moving the stack that + * opened the inventory, otherwise if the player moves it, the inventory will not + * be able to save properly + */ + @Override + public ItemStack slotClick(int slot, int button, int flag, EntityPlayer player) { + // this will prevent the player from interacting with the item that opened the inventory: + if (slot >= 0 && getSlot(slot) != null && getSlot(slot).getStack() == player.getHeldItem()) { + return null; + } + return super.slotClick(slot, button, flag, player); + } + + +/* +Special note: If your custom inventory's stack limit is 1 and you allow shift-clicking itemstacks into it, +you will need to override mergeStackInSlot to avoid losing all the items but one in a stack when you shift-click. +*/ +/** + * Vanilla mergeItemStack method doesn't correctly handle inventories whose + * max stack size is 1 when you shift-click into the inventory. + * This is a modified method I wrote to handle such cases. + * Note you only need it if your slot / inventory's max stack size is 1 + */ +@Override +protected boolean mergeItemStack(ItemStack stack, int start, int end, boolean backwards) +{ + boolean flag1 = false; + int k = (backwards ? end - 1 : start); + Slot slot; + ItemStack itemstack1; + + if (stack.isStackable()) + { + while (stack.stackSize > 0 && (!backwards && k < end || backwards && k >= start)) + { + slot = (Slot) inventorySlots.get(k); + itemstack1 = slot.getStack(); + + if (!slot.isItemValid(stack)) { + k += (backwards ? -1 : 1); + continue; + } + + if (itemstack1 != null && itemstack1.getItem() == stack.getItem() && + (!stack.getHasSubtypes() || stack.getItemDamage() == itemstack1.getItemDamage()) && ItemStack.areItemStackTagsEqual(stack, itemstack1)) + { + int l = itemstack1.stackSize + stack.stackSize; + + if (l <= stack.getMaxStackSize() && l <= slot.getSlotStackLimit()) { + stack.stackSize = 0; + itemstack1.stackSize = l; + inventory.markDirty(); + flag1 = true; + } else if (itemstack1.stackSize < stack.getMaxStackSize() && l < slot.getSlotStackLimit()) { + stack.stackSize -= stack.getMaxStackSize() - itemstack1.stackSize; + itemstack1.stackSize = stack.getMaxStackSize(); + inventory.markDirty(); + flag1 = true; + } + } + + k += (backwards ? -1 : 1); + } + } + if (stack.stackSize > 0) + { + k = (backwards ? end - 1 : start); + while (!backwards && k < end || backwards && k >= start) { + slot = (Slot) inventorySlots.get(k); + itemstack1 = slot.getStack(); + + if (!slot.isItemValid(stack)) { + k += (backwards ? -1 : 1); + continue; + } + + if (itemstack1 == null) { + int l = stack.stackSize; + if (l <= slot.getSlotStackLimit()) { + slot.putStack(stack.copy()); + stack.stackSize = 0; + inventory.markDirty(); + flag1 = true; + break; + } else { + putStackInSlot(k, new ItemStack(stack.getItem(), slot.getSlotStackLimit(), stack.getItemDamage())); + stack.stackSize -= slot.getSlotStackLimit(); + inventory.markDirty(); + flag1 = true; + } + } + + k += (backwards ? -1 : 1); + } + } + + return flag1; +} +/* +Making the custom slot is very simple, if you're going that route: +*/ +public class SlotItemInv extends Slot +{ + public SlotItemInv(IInventory inv, int index, int xPos, int yPos) + { + super(inv, index, xPos, yPos); + } + + // This is the only method we need to override so that + // we can't place our inventory-storing Item within + // its own inventory (thus making it permanently inaccessible) + // as well as preventing abuse of storing backpacks within backpacks + /** + * Check if the stack is a valid item for this slot. + */ + @Override + public boolean isItemValid(ItemStack itemstack) + { + // Everything returns true except an instance of our Item + return !(itemstack.getItem() instanceof ItemBag); + } +} +} \ No newline at end of file diff --git a/src/main/java/com/jtrent238/jtrent238bags/gui/GuiBagInventory.java b/src/main/java/com/jtrent238/jtrent238bags/gui/GuiBagInventory.java new file mode 100644 index 0000000..8694db3 --- /dev/null +++ b/src/main/java/com/jtrent238/jtrent238bags/gui/GuiBagInventory.java @@ -0,0 +1,115 @@ +package com.jtrent238.jtrent238bags.gui; + +import org.lwjgl.opengl.GL11; +import org.lwjgl.opengl.GL12; + +import com.jtrent238.jtrent238bags.BagMod; +import com.jtrent238.jtrent238bags.container.ContainerBag; +import com.jtrent238.jtrent238bags.inventory.InventoryBag; + +import net.minecraft.client.gui.inventory.GuiContainer; +import net.minecraft.client.renderer.OpenGlHelper; +import net.minecraft.client.renderer.RenderHelper; +import net.minecraft.client.renderer.entity.RenderManager; +import net.minecraft.client.resources.I18n; +import net.minecraft.entity.EntityLivingBase; +import net.minecraft.util.ResourceLocation; + +public class GuiBagInventory extends GuiContainer +{ + /** x and y size of the inventory window in pixels. Defined as float, passed as int + * These are used for drawing the player model. */ + private float xSize_lo; + private float ySize_lo; + + /** ResourceLocation takes 2 parameters: ModId, path to texture at the location: + * "src/minecraft/assets/modid/" + * + * I have provided a sample texture file that works with this tutorial. Download it + * from Forge_Tutorials/textures/gui/ + */ + private static final ResourceLocation iconLocation = new ResourceLocation(BagMod.MODID, "textures/gui/InventoryBag.png"); + + /** The inventory to render on screen */ + private final InventoryBag inventory; + + public GuiBagInventory(ContainerBag containerItem) + { + super(containerItem); + this.inventory = containerItem.inventory; + } + + /** + * Draws the screen and all the components in it. + */ + public void drawScreen(int par1, int par2, float par3) + { + super.drawScreen(par1, par2, par3); + this.xSize_lo = (float)par1; + this.ySize_lo = (float)par2; + } + + /** + * Draw the foreground layer for the GuiContainer (everything in front of the items) + */ + protected void drawGuiContainerForegroundLayer(int par1, int par2) + { + //String s = this.inventory.isInvNameLocalized() ? this.inventory.getInventoryName() : I18n.getString(this.inventory.getInventoryName()); + //this.fontRendererObj.drawString(s, this.xSize / 2 - this.fontRendererObj.getStringWidth(s) / 2, 0, 4210752); + //this.fontRendererObj.drawString(I18n.getString("container.inventory"), 26, this.ySize - 96 + 4, 4210752); + } + + /** + * Draw the background layer for the GuiContainer (everything behind the items) + */ + protected void drawGuiContainerBackgroundLayer(float par1, int par2, int par3) + { + GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F); + this.mc.getTextureManager().bindTexture(iconLocation); + int k = (this.width - this.xSize) / 2; + int l = (this.height - this.ySize) / 2; + this.drawTexturedModalRect(k, l, 0, 0, this.xSize, this.ySize); + int i1; + drawPlayerModel(k + 51, l + 75, 30, (float)(k + 51) - this.xSize_lo, (float)(l + 75 - 50) - this.ySize_lo, this.mc.thePlayer); + } + + /** + * This renders the player model in standard inventory position (in later versions of Minecraft / Forge, you can + * simply call GuiInventory.drawEntityOnScreen directly instead of copying this code) + */ + public static void drawPlayerModel(int x, int y, int scale, float yaw, float pitch, EntityLivingBase entity) { + GL11.glEnable(GL11.GL_COLOR_MATERIAL); + GL11.glPushMatrix(); + GL11.glTranslatef(x, y, 50.0F); + GL11.glScalef(-scale, scale, scale); + GL11.glRotatef(180.0F, 0.0F, 0.0F, 1.0F); + float f2 = entity.renderYawOffset; + float f3 = entity.rotationYaw; + float f4 = entity.rotationPitch; + float f5 = entity.prevRotationYawHead; + float f6 = entity.rotationYawHead; + GL11.glRotatef(135.0F, 0.0F, 1.0F, 0.0F); + RenderHelper.enableStandardItemLighting(); + GL11.glRotatef(-135.0F, 0.0F, 1.0F, 0.0F); + GL11.glRotatef(-((float) Math.atan(pitch / 40.0F)) * 20.0F, 1.0F, 0.0F, 0.0F); + entity.renderYawOffset = (float) Math.atan(yaw / 40.0F) * 20.0F; + entity.rotationYaw = (float) Math.atan(yaw / 40.0F) * 40.0F; + entity.rotationPitch = -((float) Math.atan(pitch / 40.0F)) * 20.0F; + entity.rotationYawHead = entity.rotationYaw; + entity.prevRotationYawHead = entity.rotationYaw; + GL11.glTranslatef(0.0F, entity.yOffset, 0.0F); + RenderManager.instance.playerViewY = 180.0F; + RenderManager.instance.renderEntityWithPosYaw(entity, 0.0D, 0.0D, 0.0D, 0.0F, 1.0F); + entity.renderYawOffset = f2; + entity.rotationYaw = f3; + entity.rotationPitch = f4; + entity.prevRotationYawHead = f5; + entity.rotationYawHead = f6; + GL11.glPopMatrix(); + RenderHelper.disableStandardItemLighting(); + GL11.glDisable(GL12.GL_RESCALE_NORMAL); + OpenGlHelper.setActiveTexture(OpenGlHelper.lightmapTexUnit); + GL11.glDisable(GL11.GL_TEXTURE_2D); + OpenGlHelper.setActiveTexture(OpenGlHelper.defaultTexUnit); + } +} diff --git a/src/main/java/com/jtrent238/jtrent238bags/inventory/InventoryBag.java b/src/main/java/com/jtrent238/jtrent238bags/inventory/InventoryBag.java new file mode 100644 index 0000000..5474bb2 --- /dev/null +++ b/src/main/java/com/jtrent238/jtrent238bags/inventory/InventoryBag.java @@ -0,0 +1,207 @@ +package com.jtrent238.jtrent238bags.inventory; + +import com.jtrent238.jtrent238bags.bags.ItemBag; + +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.inventory.IInventory; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.nbt.NBTTagList; + +public class InventoryBag implements IInventory +{ + private String name = "Inventory Item"; + + /** Provides NBT Tag Compound to reference */ + private final ItemStack invItem; + + /** Defining your inventory size this way is handy */ + public static final int INV_SIZE = 8; + + /** Inventory's size must be same as number of slots you add to the Container class */ + private ItemStack[] inventory = new ItemStack[INV_SIZE]; + + /** + * @param itemstack - the ItemStack to which this inventory belongs + */ + public InventoryBag(ItemStack stack) + { + invItem = stack; + + // Create a new NBT Tag Compound if one doesn't already exist, or you will crash + if (!stack.hasTagCompound()) { + stack.setTagCompound(new NBTTagCompound()); + } + // note that it's okay to use stack instead of invItem right there + // both reference the same memory location, so whatever you change using + // either reference will change in the other + + // Read the inventory contents from NBT + readFromNBT(stack.getTagCompound()); + } + + @Override + public int getSizeInventory() + { + return inventory.length; + } + + @Override + public ItemStack getStackInSlot(int slot) + { + return inventory[slot]; + } + + @Override + public ItemStack decrStackSize(int slot, int amount) + { + ItemStack stack = getStackInSlot(slot); + if(stack != null) + { + if(stack.stackSize > amount) + { + stack = stack.splitStack(amount); + // Don't forget this line or your inventory will not be saved! + markDirty(); + } + else + { + // this method also calls onInventoryChanged, so we don't need to call it again + setInventorySlotContents(slot, null); + } + } + return stack; + } + + @Override + public ItemStack getStackInSlotOnClosing(int slot) + { + ItemStack stack = getStackInSlot(slot); + setInventorySlotContents(slot, null); + return stack; + } + + @Override + public void setInventorySlotContents(int slot, ItemStack stack) + { + inventory[slot] = stack; + + if (stack != null && stack.stackSize > getInventoryStackLimit()) + { + stack.stackSize = getInventoryStackLimit(); + } + + // Don't forget this line or your inventory will not be saved! + markDirty(); + } + + @Override + public String getInventoryName() + { + return name; + } + + @Override + public boolean hasCustomInventoryName() + { + return name.length() > 0; + } + + @Override + public int getInventoryStackLimit() + { + return 64; + } + + /** + * This is the method that will handle saving the inventory contents, as it is called (or should be called!) + * anytime the inventory changes. Perfect. Much better than using onUpdate in an Item, as this will also + * let you change things in your inventory without ever opening a Gui, if you want. + */ + @Override + public void markDirty() + { + for (int i = 0; i < getSizeInventory(); ++i) + { + if (getStackInSlot(i) != null && getStackInSlot(i).stackSize == 0) { + inventory[i] = null; + } + } + + // This line here does the work: + writeToNBT(invItem.getTagCompound()); + } + + @Override + public boolean isUseableByPlayer(EntityPlayer entityplayer) + { + return true; + } + + public void openInventory() {} + + public void closeInventory() {} + + /** + * This method doesn't seem to do what it claims to do, as + * items can still be left-clicked and placed in the inventory + * even when this returns false + */ + @Override + public boolean isItemValidForSlot(int slot, ItemStack itemstack) + { + // Don't want to be able to store the inventory item within itself + // Bad things will happen, like losing your inventory + // Actually, this needs a custom Slot to work + return !(itemstack.getItem() instanceof ItemBag); + } + + /** + * A custom method to read our inventory from an ItemStack's NBT compound + */ + public void readFromNBT(NBTTagCompound compound) + { + // Gets the custom taglist we wrote to this compound, if any + // 1.7.2+ change to compound.getTagList("ItemInventory", Constants.NBT.TAG_COMPOUND); + NBTTagList items = compound.getTagList("BagInventory", 0); + + for (int i = 0; i < items.tagCount(); ++i) + { + // 1.7.2+ change to items.getCompoundTagAt(i) + NBTTagCompound item = (NBTTagCompound) items.getCompoundTagAt(i); + int slot = item.getInteger("Slot"); + + // Just double-checking that the saved slot index is within our inventory array bounds + if (slot >= 0 && slot < getSizeInventory()) { + inventory[slot] = ItemStack.loadItemStackFromNBT(item); + } + } + } + + /** + * A custom method to write our inventory to an ItemStack's NBT compound + */ + public void writeToNBT(NBTTagCompound tagcompound) + { + // Create a new NBT Tag List to store itemstacks as NBT Tags + NBTTagList items = new NBTTagList(); + + for (int i = 0; i < getSizeInventory(); ++i) + { + // Only write stacks that contain items + if (getStackInSlot(i) != null) + { + // Make a new NBT Tag Compound to write the itemstack and slot index to + NBTTagCompound item = new NBTTagCompound(); + item.setInteger("Slot", i); + // Writes the itemstack in slot(i) to the Tag Compound we just made + getStackInSlot(i).writeToNBT(item); + + // add the tag compound to our tag list + items.appendTag(tagcompound); + } + } + // Add the TagList to the ItemStack's Tag Compound with the name "ItemInventory" + tagcompound.setTag("BagInventory", items); + } +} \ No newline at end of file diff --git a/src/main/java/com/jtrent238/jtrent238bags/items/ItemDebug.java b/src/main/java/com/jtrent238/jtrent238bags/items/ItemDebug.java new file mode 100644 index 0000000..3dcd044 --- /dev/null +++ b/src/main/java/com/jtrent238/jtrent238bags/items/ItemDebug.java @@ -0,0 +1,38 @@ +package com.jtrent238.jtrent238bags.items; + +import com.jtrent238.jtrent238bags.inventory.InventoryBag; + +import net.minecraft.client.Minecraft; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.world.World; + +public class ItemDebug extends Item{ + + @Override + public ItemStack onItemRightClick(ItemStack itemstack, World world, EntityPlayer player) + { + if (!world.isRemote) + { + System.out.println("++++++++++++++++++++++++++++++++++++++++++++++"); + System.out.println("++++++++++++++++++++++++++DEBUG+++++++++++++++"); + System.out.println("++++++++++++++++++++++++++++++++++++++++++++++"); + System.out.println(player.inventoryContainer.inventorySlots.toString()); + System.out.println("Player DisplayName: " + player.getDisplayName().toString()); + //System.out.println("Player Bed Location: " + player.getBedLocation().posX + ", " + player.getBedLocation().posY + ", " + player.getBedLocation().posZ); + System.out.println("Player PersistentID: " + player.getPersistentID().toString()); + System.out.println("Player UniqueID: " + player.getUniqueID().toString()); + System.out.println("Minecraft Debug Information: " + Minecraft.getMinecraft().debug.toString()); + System.out.println("Amount of Entitys in World: " + Minecraft.getMinecraft().debugInfoEntities().toString()); + System.out.println("InfoRenders: " + Minecraft.getMinecraft().debugInfoRenders().toString()); + System.out.println("WorldProviderName: " + Minecraft.getMinecraft().getWorldProviderName().toString()); + System.out.println("++++++++++++++++++++++++++++++++++++++++++++++"); + System.out.println("++++++++++++++++++++++++++++++++++++++++++++++"); + + + } + + return itemstack; + } +} diff --git a/src/main/resources/assets/jtrent238bags/lang/en_US.lang b/src/main/resources/assets/jtrent238bags/lang/en_US.lang new file mode 100644 index 0000000..1b9760d --- /dev/null +++ b/src/main/resources/assets/jtrent238bags/lang/en_US.lang @@ -0,0 +1,18 @@ +itemGroup.BagTab=jtrent238's Bag Mod +item.ItemBag.Plain.name=Plain Bag +item.ItemBag.red.name=Red Bag +item.ItemBag.green.name=Green Bag +item.ItemBag.blue.name=Blue Bag +item.ItemBag.purple.name=Purple Bag +item.ItemBag.cyan.name=Cyan Bag +item.ItemBag.pink.name=Pink Bag +item.ItemBag.lime.name=Lime Bag +item.ItemBag.yellow.name=Yellow Bag +item.ItemBag.lightBlue.name=Light Blue Bag +item.ItemBag.magenta.name=Magenta Bag +item.ItemBag.orange.name=Orange Bag +item.ItemBag.white.name=White Bag +item.ItemBag.Cow.name=Cow Bag +item.ItemBag.JSQ.name=xJSQ Bag +item.ItemBag._MrGregor_.name=_MrGregor_ Bag +item.ItemBag.jtrent238.name=jtrent238 Bag \ No newline at end of file diff --git a/src/main/resources/assets/jtrent238bags/textures/gui/InventoryBag.png b/src/main/resources/assets/jtrent238bags/textures/gui/InventoryBag.png new file mode 100644 index 0000000000000000000000000000000000000000..d392830883e227b800d69509013d54f56b76d70c GIT binary patch literal 3672 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 Kpv#aB;eQ9@t~MV4 literal 0 HcmV?d00001 diff --git a/src/main/resources/assets/jtrent238bags/textures/gui/Thumbs.db b/src/main/resources/assets/jtrent238bags/textures/gui/Thumbs.db new file mode 100644 index 0000000000000000000000000000000000000000..d5c3ae1dcd884fecb40b4ff420f5696417243db0 GIT binary patch literal 3584 zcmca`Uhu)fjZzO8(10BSGsD0CoD6J8;*3Bx2!nwD0|OI~0pkDr|NlQkkbwcn90fxt z1pWfu3W`4vW&uVbD>OcbkQYXsN;Sr0E8 zaOm7{FgC9-@iHSbP~HKQ(15^*!IZ&_As&d684Q4AB10Nb#1e>;8BBm8$qXq#Hg2H7 zz{Ci%A4KC;i7LYhwI5ZKJRUjrlV=llU6j}liZf6-4vG_4{s)!$>_E%`#GF9P1;pGy z%mc){K+Ffk{6Gw>0vH5=SO|!Pfmj5HLFLFO7&;*!0gN+H+mw_O4%WsI}*mgF=mgqhBr-g!HzHC^?6zroJu z9vrv4{H6MTibTKKd-Kop=MSyd-2MMPn$1W2({ufH`NX?nGn0EuR~^TJ+qZ8&RF7D`zwXbC`v1S5F0K9Snc(o7<%9nIKNFrhGc@QhF&wnp z!#u;D$;QS;rq1eq+3vf0{?vu-)(Wj(cdGc^`}h3+OYZJrUa?uCp)9$#qNe7~oqPB4 z?%lu7|NoiQmh5Z)VnVMke>7)Gxdl_eab*S;VFnI01_2)ig&7PE28;~}K=WA`nmDma z?5bv1zkdDi|L1G2Y<)fxPr%3=*2e8Cpl?GV~+o}DcCBKrpOip#tVYbG*W`N#na z>(~33SH!T&J)N^J+b(@y*&A7)Lm0N~ZxDR@_S>y%#dAOJG@WO>U!QeBpF2t3JG9ld zVej3%?+;(UeEIT2{4tB==PheL|NeCTZQ1{;@9y5;Zt#2)M~T|=FQM~*PAk%3ntRf+ zcIxv8mR&OMiAoW0KVSdG@a@@Y?P*!R=3EXhJ@;qd7LJhPN*87Vd6j*x3r=rDvStr6 z{$vI>6p}DwZZqGQt-n5E)yrbP_^Xzme_v7xnEOtFW6eaz30889u!P&ac){XZ8cVL; zK5w~v{oG{HA4Ou!7ydE1MeKbG)MtHM>%-Fu7Sb(VzdmX;$N;d#S_K#uKZu@b_b)iP zsxC`EJSJwJ=zE4^zVjLK-o1OrXMgC|&!?cuhc@8BsvNWb3><!lvI6;>1s;*b z3=DkxK$!8B)5ZfpL5ULAh!V%rl8pQ!hTP1&)a0VXw35ucw0ynf{M`F#>fS&#k{~s~ z`DrEPiAAXl1&Nt?C3<XRb>)4U6^91^U0I#Y==6t zvCu?E(Tz`%B}KpO?byJOBBseCD7h!!>+SC0X@hQZU-&t;ucLK6TUIA78L literal 0 HcmV?d00001 diff --git a/src/main/resources/assets/jtrent238bags/textures/items/ItemBag_Cow.png b/src/main/resources/assets/jtrent238bags/textures/items/ItemBag_Cow.png new file mode 100644 index 0000000000000000000000000000000000000000..feee8bc9bbf9128a3c2c57ac92be3fc2818fe1da GIT binary patch literal 376 zcmeAS@N?(olHy`uVBq!ia0vp^0wB!61|;P_|4#%`Ea{HEjtmSN`?>!lvI6;>1s;*b z3=DkxK$!8B)5ZfpL5ULAh!V%rl8pQ!hTP1&)a0VXw35ucw0ynf{M`F#>fS&#k{~s~ z`DrEPiAAXl1&Nt?C3<Cali%!Uh56rkLw=_9J`_L)Z72T?%(&*Bd>hfHGkRp&yx-q3%kG4 z>NWkx*O~l#RjbMUGq-Lp$o?C4AdN%1a9_Le++z|>nyx(ClV^2qn;-C?K_*+bQDBDP znZ2$aau4>Z8=R4TaITb(;be@6I!EbR)42>z`tx0DMGv&;p1PUEu+O|@!-GQGFYE^z zN{<(+6u9^Pce1no-lEZc&eF(Blk<+?g#9`*BP%x_J$1%ual3_`cZYthb~x*%n!lvI6;>1s;*b z3=DjGL736~_k^`TL5ULAh!V%rl8pQ!hTP1&)a0VXw35ucw0ynf{M`F#>fS&#k{~s~ z`DrEPiAAXl1&Nt?C3<lFzvG7kmz~*%2=)cE@0#t7> z`Uu*atB3h)QM_T&Y~Xm-py8}Qm&suRN9PZjZHaT*1QtuSuvTuAU=p&}y@7p=!wmV| zZVQYo*jBn4vfN}Ssj2+AzIEDewd_8!;@A%i-9>=$^La-~71g-{U9FX6*UyzwUoM+X{&zY@N*p9=txbZHx+k z-v7M&|5%fQbYq3PKkE%q1v3wsmc&;N?lA}|@ENsf-ntUTRN^W-hyRfHbianx%+d_p z>=O=5lsx;t{CoJ{_ge=djd@#JFb0Mo+^9uKbUIrpD^*_HqH7F!v6 y9N#2wjyh<<)68@50uQqSXOcmPrGS9}1H*@(1;?Hn_gMl%mBG{1&t;ucLK6V6>#HsR literal 0 HcmV?d00001 diff --git a/src/main/resources/assets/jtrent238bags/textures/items/ItemBag_Plain.png b/src/main/resources/assets/jtrent238bags/textures/items/ItemBag_Plain.png new file mode 100644 index 0000000000000000000000000000000000000000..2b979d88ae92dcfedc276b0d2bd9b78d61188293 GIT binary patch literal 297 zcmeAS@N?(olHy`uVBq!ia0vp^0wB!61|;P_|4#%`Ea{HEjtmSN`?>!lvI6;>1s;*b z3=DkxK$!8B)5ZfpL5ULAh!V%rl8pQ!hTP1&)a0VXw35ucw0ynf{M`F#>fS&#k{~s~ z`DrEPiAAXl1&Nt?C3<XRb>)4U6^91^U0I#Y==6t zvCu?E(Tz`%B}KpO?byJOBBseCD7h!!>+SC0X@hQZU-&t;ucLK6TUIA78L literal 0 HcmV?d00001 diff --git a/src/main/resources/assets/jtrent238bags/textures/items/ItemBag__MrGregor_.png b/src/main/resources/assets/jtrent238bags/textures/items/ItemBag__MrGregor_.png new file mode 100644 index 0000000000000000000000000000000000000000..4fd7689dffcefcbfaef03178449d6d04819a8c0d GIT binary patch literal 398 zcmeAS@N?(olHy`uVBq!ia0vp^0wB!61|;P_|4#%`Ea{HEjtmSN`?>!lvI6;>1s;*b z3=DjGL736~_k^`TL5ULAh!V%rl8pQ!hTP1&)a0VXw35ucw0ynf{M`F#>fS&#k{~s~ z`DrEPiAAXl1&Nt?C3<Eak-;lFgkZQer$Jg&3DgS{$i zHZo-gq$TkG`{C@=Bs;UgvM2Yb@2zD^g{Jj&yt*U&SSft^W5#71;h$8eZ!wA#^Dat! zlpdj_{!?4$&y+K*t)85wQ!e@N+;9*Hs8{LKU!KV9)_tI?sB(dNClimNSThUfnnFjB zqb}+mhebXeb9(EQmMZvX?T6XRUGaGp{c`Z6Xn;eEu8Db}!@2Ozrx6&7~d` zrhmJ4c-xnne{Vz{r?FZv_TIkHP;A3EH~Uw%ho#7p>IX{|RlFuH725J7E<$Ur3U`~N kP5+^wD-ljR`a(tGH*vgJJ)KSSEzrvhp00i_>zopr08Ffu4gdfE literal 0 HcmV?d00001 diff --git a/src/main/resources/assets/jtrent238bags/textures/items/ItemBag_blue.png b/src/main/resources/assets/jtrent238bags/textures/items/ItemBag_blue.png new file mode 100644 index 0000000000000000000000000000000000000000..80ea9749bf20d6e6cc06d3a8b309d4ceabe92272 GIT binary patch literal 299 zcmeAS@N?(olHy`uVBq!ia0vp^0wB!61|;P_|4#%`Ea{HEjtmSN`?>!lvI6;>1s;*b z3=DjGL736~_k^`TL5ULAh!V%rl8pQ!hTP1&)a0VXw35ucw0ynf{M`F#>fS&#k{~s~ z`DrEPiAAXl1&Nt?C3<K5A$Xp$%e>N zT5GPT-e^f|aQmvf_OjcdOSK)f3N5Pn&mUjZve9^36nIF;Y@N<=j>&(dnwO@Sv8_`v zVrxDkE&np?MzL}tQ_svJ97S5sI+zx}U!n4;>_T}ABiB8N?<*HP>Maaz{MX*ul6cJH liT42mw^xcztLp_T8E@>bS|gF~n+J3cgQu&X%Q~loCIDr!lvI6;>1s;*b z3=DjGL736~_k^`TL5ULAh!V%rl8pQ!hTP1&)a0VXw35ucw0ynf{M`F#>fS&#k{~s~ z`DrEPiAAXl1&Nt?C3<K5A$Z0-}XN@ z1g5{>aq#NlD!t^v;r(6FZnaaywA{P4YYr7p&sw^~ea0G})Rx|wNe4?*CN)}5nt0IQ z(W#{|6W;d=S~1M*{lcs%xyS14-}D1q>vFzVIDAamZF>DLzu?}UC2>hSMvK~c!t9lc Z7`C!7RB5xY8UWqE;OXk;vd$@?2>@WCV}t+z literal 0 HcmV?d00001 diff --git a/src/main/resources/assets/jtrent238bags/textures/items/ItemBag_green.png b/src/main/resources/assets/jtrent238bags/textures/items/ItemBag_green.png new file mode 100644 index 0000000000000000000000000000000000000000..aa2249d2a09e59ea30a92b157637317fd8542005 GIT binary patch literal 286 zcmeAS@N?(olHy`uVBq!ia0vp^0wB!61|;P_|4#%`Ea{HEjtmSN`?>!lvI6;>1s;*b z3=DjGL736~_k^`TL5ULAh!V%rl8pQ!hTP1&)a0VXw35ucw0ynf{M`F#>fS&#k{~s~ z`DrEPiAAXl1&Nt?C3<K53@BR|FHy> zX^CuVY(Y0y1gQ76Y$%a`v{|d`)TVRo>{?dknX^@13aUyw&kR(apJF7_newPFCFN4@ zj!%3?z8~+9S+K_KR^t?(xVf+X88!qoF Y&|jl7q8FWQhbW?9;ba!ELWdLwtX>N2bZe?^JG%heMF*(%MvSa`N0jxd2ik~-+XWOQ6oza^`V)&kjCZ#58APC)QLz|L)0Q9 z_H>#1H%Y8O2(A*sS;CUtjj2t-h2!@ZVcqkEPHmx5YZ4(m$^Sl z7!cnzFkkW`k|Qad*L)q0eAbjib(V64XUe^p-XeJg?;64zD&fT9Q5WWlIuiRngw_cY zD^4L3apXPc6|RniH!PDSk0l8d)<9_;@mdOWW`f4We%T>cIFEoAENy1nkr};DfP$i6 zz=y7i0G$YeejjM81sk>PI;P93kXYv7tBsCI4@Rn^4pB&Rl$@H#Jgn4VJ%aD7 zXYUuFbJ0~?K?rm_reW}Q7}p<_<_gqs?mnyVUA2KaMPa~oUSFD+xCwbUPl1|)8jk%^ zM(!yOEn>oYE};B&41LZ-s~tf0(fT<=Wt>Qs48$xk?Yv+9Z+<-7EuL?ek0`oB@>TvQ hR>lYaaThL(=nL>lLFu*kI(7g6002ovPDHLkV1km_{-^)| literal 0 HcmV?d00001 diff --git a/src/main/resources/assets/jtrent238bags/textures/items/ItemBag_lightBlue.png b/src/main/resources/assets/jtrent238bags/textures/items/ItemBag_lightBlue.png new file mode 100644 index 0000000000000000000000000000000000000000..dfa6eb39616d75677177a323969fe288384169c6 GIT binary patch literal 287 zcmeAS@N?(olHy`uVBq!ia0vp^0wB!61|;P_|4#%`Ea{HEjtmSN`?>!lvI6;>1s;*b z3=DjGL736~_k^`TL5ULAh!V%rl8pQ!hTP1&)a0VXw35ucw0ynf{M`F#>fS&#k{~s~ z`DrEPiAAXl1&Nt?C3<K53@1a6LH5=H0j-XiK%)pGJwfZL4|>XJO}N|HO2B_&Ig z*X?;H{^WOZ3!g)p@>>Tlw)K9c|0OpxY2UV$3$VGFceV7tvx~O!%IOkwdtN9uUp?O; Zv(W88!?Z=hjX*arc)I$ztaD0e0su{)V>$o; literal 0 HcmV?d00001 diff --git a/src/main/resources/assets/jtrent238bags/textures/items/ItemBag_lime.png b/src/main/resources/assets/jtrent238bags/textures/items/ItemBag_lime.png new file mode 100644 index 0000000000000000000000000000000000000000..da724fb0572ae340f43810e15d20feb5962c55c7 GIT binary patch literal 286 zcmeAS@N?(olHy`uVBq!ia0vp^0wB!61|;P_|4#%`Ea{HEjtmSN`?>!lvI6;>1s;*b z3=DjGL736~_k^`TL5ULAh!V%rl8pQ!hTP1&)a0VXw35ucw0ynf{M`F#>fS&#k{~s~ z`DrEPiAAXl1&Nt?C3<K53@1rqtnwx zB_}s>X&P!>@l;mSx!e9@4Oe31_LUV8tZGr^@=-Mf|r#m)`v^aPgGKD^)jj<*E}2UyYU6 Y7f6+B&g<8y20DSk)78&qol`;+00l;3`Tzg` literal 0 HcmV?d00001 diff --git a/src/main/resources/assets/jtrent238bags/textures/items/ItemBag_magenta.png b/src/main/resources/assets/jtrent238bags/textures/items/ItemBag_magenta.png new file mode 100644 index 0000000000000000000000000000000000000000..83963bab43a6e6010d3558adc5a798292d98f5d7 GIT binary patch literal 290 zcmeAS@N?(olHy`uVBq!ia0vp^0wB!61|;P_|4#%`Ea{HEjtmSN`?>!lvI6;>1s;*b z3=DjGL736~_k^`TL5ULAh!V%rl8pQ!hTP1&)a0VXw35ucw0ynf{M`F#>fS&#k{~s~ z`DrEPiAAXl1&Nt?C3<Sk@m*Y-UbDaSqwy+~2hx4H5; c-DwA7uZ!KXM)%}upfeaeUHx3vIVCg!0G_XA!lvI6;>1s;*b z3=DjGL736~_k^`TL5ULAh!V%rl8pQ!hTP1&)a0VXw35ucw0ynf{M`F#>fS&#k{~s~ z`DrEPiAAXl1&Nt?C3<K&yi1w=4=nn z_nbK-;={P*O8+HqX->hD@3!QkoY=d#Wzp$Py10b(@( literal 0 HcmV?d00001 diff --git a/src/main/resources/assets/jtrent238bags/textures/items/ItemBag_pink.png b/src/main/resources/assets/jtrent238bags/textures/items/ItemBag_pink.png new file mode 100644 index 0000000000000000000000000000000000000000..bedd3339ceed9ff3005a78452589d94b434175a1 GIT binary patch literal 293 zcmeAS@N?(olHy`uVBq!ia0vp^0wB!61|;P_|4#%`Ea{HEjtmSN`?>!lvI6;>1s;*b z3=DjGK$vmro+3}6phSslM2TZ*Nk)DVLvChXYI0FxT1jSJTE1R#e(wD=b#I^=NsyZ0 z{Irtt#G+J&g2c?c61}|C5(N`I13g2_E7vxq02S4Fx;Tbd_-~!y$kkxL!}2?C{k^{} z?>}!lvI6;>1s;*b z3=DjGL736~_k^`TL5ULAh!V%rl8pQ!hTP1&)a0VXw35ucw0ynf{M`F#>fS&#k{~s~ z`DrEPiAAXl1&Nt?C3<#wPV_h8QMQ#l z)8XExmUObv()d-iXdq*X=t?Fz$$RFOpS&BGz0>aVs_4v&<%{^g&|TGd-gF0L}Z=_){nFnGH9xvX!lvI6;>1s;*b z3=DkxK$!8B)5ZfpL5ULAh!V%rl8pQ!hTP1&)a0VXw35ucw0ynf{M`F#>fS&#k{~s~ z`DrEPiAAXl1&Nt?C3<!lvI6;>1s;*b z3=DjGL736~_k^`TL5ULAh!V%rl8pQ!hTP1&)a0VXw35ucw0ynf{M`F#>fS&#k{~s~ z`DrEPiAAXl1&Nt?C3<Fdie}N=_f6!lvI6;>1s;*b z3=DjGL736~_k^`TL5ULAh!V%rl8pQ!hTP1&)a0VXw35ucw0ynf{M`F#>fS&#k{~s~ z`DrEPiAAXl1&Nt?C3<K&yi1wb<-L} zXEe%6FlDTiUpn1PNNJM2$~G;ZvsV7g-7PO3zPNFwicDZpl7_L?C(pLTCF;%6ohL51 z*i^>LUHPuHi0On@5UY~Wp8TRG(;3+3o!KYtQDL-O=EFbdey=no{YJO6OG-|b`;Wh2 YD#?C))6uAFE6@!Lp00i_>zopr0Q+8H#sB~S literal 0 HcmV?d00001 diff --git a/src/main/resources/assets/jtrent238bags/textures/items/ItemDebug.png b/src/main/resources/assets/jtrent238bags/textures/items/ItemDebug.png new file mode 100644 index 0000000000000000000000000000000000000000..0a6b87674684fae131809e309ffc895d08d060ba GIT binary patch literal 232 zcmeAS@N?(olHy`uVBq!ia0vp^0wB!61|;P_|4#%`jKx9jP7LeL$-D$|SkfJR9T^xl z_H+M9WCij$3p^r=85sBugD~Uq{1qucLCF%=h?3y^w370~qEv>0#LT=By}Z;C1rt33 zJwr2>%=KS^iXuE+978PplNH2GOicd#KR@BS{3%sl2b23h`4=s8I>J0*nJ>@(lh@xk zcBZkJdYSkybopH0W#TVkaJGwi$xZeZb92t#*0}iRKbz{T%_pw#Fge6N$xcg1U|{I= WElTSzG~of-!QkoY=d#Wzp$P!HGE77O literal 0 HcmV?d00001 diff --git a/src/main/resources/mcmod.info b/src/main/resources/mcmod.info new file mode 100644 index 0000000..f480667 --- /dev/null +++ b/src/main/resources/mcmod.info @@ -0,0 +1,16 @@ +[ +{ + "modid": "examplemod", + "name": "Example Mod", + "description": "Example placeholder mod.", + "version": "${version}", + "mcversion": "${mcversion}", + "url": "", + "updateUrl": "", + "authorList": ["ExampleDude"], + "credits": "The Forge and FML guys, for making this example", + "logoFile": "", + "screenshots": [], + "dependencies": [] +} +]