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 0000000..d392830 Binary files /dev/null and b/src/main/resources/assets/jtrent238bags/textures/gui/InventoryBag.png differ 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 0000000..d5c3ae1 Binary files /dev/null and b/src/main/resources/assets/jtrent238bags/textures/gui/Thumbs.db differ diff --git a/src/main/resources/assets/jtrent238bags/textures/items/ItemBag.png b/src/main/resources/assets/jtrent238bags/textures/items/ItemBag.png new file mode 100644 index 0000000..2b979d8 Binary files /dev/null and b/src/main/resources/assets/jtrent238bags/textures/items/ItemBag.png differ 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 0000000..feee8bc Binary files /dev/null and b/src/main/resources/assets/jtrent238bags/textures/items/ItemBag_Cow.png differ diff --git a/src/main/resources/assets/jtrent238bags/textures/items/ItemBag_JSQ.png b/src/main/resources/assets/jtrent238bags/textures/items/ItemBag_JSQ.png new file mode 100644 index 0000000..d0a5d08 Binary files /dev/null and b/src/main/resources/assets/jtrent238bags/textures/items/ItemBag_JSQ.png differ 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 0000000..2b979d8 Binary files /dev/null and b/src/main/resources/assets/jtrent238bags/textures/items/ItemBag_Plain.png differ 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 0000000..4fd7689 Binary files /dev/null and b/src/main/resources/assets/jtrent238bags/textures/items/ItemBag__MrGregor_.png differ 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 0000000..80ea974 Binary files /dev/null and b/src/main/resources/assets/jtrent238bags/textures/items/ItemBag_blue.png differ diff --git a/src/main/resources/assets/jtrent238bags/textures/items/ItemBag_cyan.png b/src/main/resources/assets/jtrent238bags/textures/items/ItemBag_cyan.png new file mode 100644 index 0000000..61366ce Binary files /dev/null and b/src/main/resources/assets/jtrent238bags/textures/items/ItemBag_cyan.png differ 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 0000000..aa2249d Binary files /dev/null and b/src/main/resources/assets/jtrent238bags/textures/items/ItemBag_green.png differ diff --git a/src/main/resources/assets/jtrent238bags/textures/items/ItemBag_jtrent238.png b/src/main/resources/assets/jtrent238bags/textures/items/ItemBag_jtrent238.png new file mode 100644 index 0000000..8de519c Binary files /dev/null and b/src/main/resources/assets/jtrent238bags/textures/items/ItemBag_jtrent238.png differ 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 0000000..dfa6eb3 Binary files /dev/null and b/src/main/resources/assets/jtrent238bags/textures/items/ItemBag_lightBlue.png differ 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 0000000..da724fb Binary files /dev/null and b/src/main/resources/assets/jtrent238bags/textures/items/ItemBag_lime.png differ 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 0000000..83963ba Binary files /dev/null and b/src/main/resources/assets/jtrent238bags/textures/items/ItemBag_magenta.png differ diff --git a/src/main/resources/assets/jtrent238bags/textures/items/ItemBag_orange.png b/src/main/resources/assets/jtrent238bags/textures/items/ItemBag_orange.png new file mode 100644 index 0000000..c9da435 Binary files /dev/null and b/src/main/resources/assets/jtrent238bags/textures/items/ItemBag_orange.png differ 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 0000000..bedd333 Binary files /dev/null and b/src/main/resources/assets/jtrent238bags/textures/items/ItemBag_pink.png differ diff --git a/src/main/resources/assets/jtrent238bags/textures/items/ItemBag_purple.png b/src/main/resources/assets/jtrent238bags/textures/items/ItemBag_purple.png new file mode 100644 index 0000000..c4b2d21 Binary files /dev/null and b/src/main/resources/assets/jtrent238bags/textures/items/ItemBag_purple.png differ diff --git a/src/main/resources/assets/jtrent238bags/textures/items/ItemBag_red.png b/src/main/resources/assets/jtrent238bags/textures/items/ItemBag_red.png new file mode 100644 index 0000000..3279295 Binary files /dev/null and b/src/main/resources/assets/jtrent238bags/textures/items/ItemBag_red.png differ diff --git a/src/main/resources/assets/jtrent238bags/textures/items/ItemBag_white.png b/src/main/resources/assets/jtrent238bags/textures/items/ItemBag_white.png new file mode 100644 index 0000000..267979d Binary files /dev/null and b/src/main/resources/assets/jtrent238bags/textures/items/ItemBag_white.png differ diff --git a/src/main/resources/assets/jtrent238bags/textures/items/ItemBag_yellow.png b/src/main/resources/assets/jtrent238bags/textures/items/ItemBag_yellow.png new file mode 100644 index 0000000..c60be3f Binary files /dev/null and b/src/main/resources/assets/jtrent238bags/textures/items/ItemBag_yellow.png differ 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 0000000..0a6b876 Binary files /dev/null and b/src/main/resources/assets/jtrent238bags/textures/items/ItemDebug.png differ 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": [] +} +]