Java 类net.minecraft.item.ItemArmor.ArmorMaterial 实例源码

public static void applyBackers(List<MaterialDefinition> definitions) {
    for (MaterialDefinition definition : definitions) {
        ToolMaterial toolMaterial = definition.getToolMaterial();
        ArmorMaterial armorMaterial = definition.getArmorMaterial();

        RandoresItemData itemData = definition.getData();

        RandoresItems.hoe.registerBacker(itemData, new ItemHoe(toolMaterial));
        RandoresItems.sword.registerBacker(itemData, new ItemSword(toolMaterial));
        RandoresItems.axe.registerBacker(itemData, new ConstructableAxe(toolMaterial, toolMaterial.getDamageVsEntity() + 5f, -3f));
        RandoresItems.shovel.registerBacker(itemData, new ItemSpade(toolMaterial));
        RandoresItems.pickaxe.registerBacker(itemData, new ConstructablePickaxe(toolMaterial));
        RandoresItems.battleaxe.registerBacker(itemData, new ConstructableAxe(toolMaterial, toolMaterial.getDamageVsEntity() + 8f, -3.5f));
        RandoresItems.helmet.registerBacker(itemData, armorMaterial);
        RandoresItems.chestplate.registerBacker(itemData, armorMaterial);
        RandoresItems.leggings.registerBacker(itemData, armorMaterial);
        RandoresItems.boots.registerBacker(itemData, armorMaterial);
    }
}

public ItemCGArmor(String id, ArmorMaterial armorMaterial, String armorName, int renderIndex, EntityEquipmentSlot armorType)
{
    super(armorMaterial, renderIndex, armorType);

    this.armorName = armorName;
    this.itemClass = EnumItemClass.MEDIUM_ARMOR;
    this.isAirMask = false;
    this.minAirToStartRefil = 0;
    this.rarity = EnumRarity.COMMON;

    setUnlocalizedName(id);

    ItemsCG.registerItem(this, new ResourceLocation(ModInfo.MODID, id)); // Put into registry.

    if (CompositeGear.ic2Tab != null) {
        setCreativeTab(CompositeGear.ic2Tab);
    }
}

private static void registerPurpleMaterial() {
  ArmorMaterial mimicArmor = ArmorMaterial.DIAMOND;
  MaterialRegistry.powerArmorMaterial = EnumHelper.addArmorMaterial(MATERIALNAME, Const.MODRES + MATERIALNAME,
      diamondDurability * 2, // affects DURABILITY . 15 is the same as iron
      new int[] {
          mimicArmor.getDamageReductionAmount(EntityEquipmentSlot.FEET) + 1,
          mimicArmor.getDamageReductionAmount(EntityEquipmentSlot.LEGS) + 1,
          mimicArmor.getDamageReductionAmount(EntityEquipmentSlot.CHEST) + 1,
          mimicArmor.getDamageReductionAmount(EntityEquipmentSlot.HEAD) + 2
      },
      mimicArmor.getEnchantability() / 4,
      mimicArmor.getSoundEvent(),
      mimicArmor.getToughness() + 2);
  MaterialRegistry.powerArmorMaterial.repairMaterial = new ItemStack(Blocks.OBSIDIAN);
  //now the tool material
  MaterialRegistry.powerToolMaterial = EnumHelper.addToolMaterial(MATERIALNAME,
      ToolMaterial.DIAMOND.getHarvestLevel(),
      ToolMaterial.DIAMOND.getMaxUses() * 4, //was  - 261
      ToolMaterial.DIAMOND.getEfficiencyOnProperMaterial(),
      ToolMaterial.DIAMOND.getDamageVsEntity() * 8, //best draconic evolution sword is 35 base, so this is not that crazy
      ToolMaterial.GOLD.getEnchantability() * 2);
  MaterialRegistry.powerToolMaterial.setRepairItem(MaterialRegistry.powerArmorMaterial.repairMaterial);
}

private static void registerEmeraldMaterial() {
  MaterialRegistry.emeraldArmorMaterial = EnumHelper.addArmorMaterial(emeraldName, Const.MODRES + emeraldName,
      diamondDurability + 30, //was -2 affects DURABILITY 
      new int[] {
          ArmorMaterial.DIAMOND.getDamageReductionAmount(EntityEquipmentSlot.FEET),
          ArmorMaterial.DIAMOND.getDamageReductionAmount(EntityEquipmentSlot.LEGS),
          ArmorMaterial.DIAMOND.getDamageReductionAmount(EntityEquipmentSlot.CHEST),
          ArmorMaterial.DIAMOND.getDamageReductionAmount(EntityEquipmentSlot.HEAD)
      },
      ArmorMaterial.GOLD.getEnchantability(),
      ArmorMaterial.DIAMOND.getSoundEvent(),
      ArmorMaterial.DIAMOND.getToughness() + 1);//was  / 2
  MaterialRegistry.emeraldArmorMaterial.repairMaterial = new ItemStack(Items.EMERALD);
  //max uses is durability ex The number of uses this material allows.
  //as of 1.9.4 :  (wood = 59, stone = 131, iron = 250, diamond = 1561, gold = 32)
  MaterialRegistry.emeraldToolMaterial = EnumHelper.addToolMaterial(emeraldName,
      ToolMaterial.DIAMOND.getHarvestLevel(),
      ToolMaterial.DIAMOND.getMaxUses(), //was  - 261
      ToolMaterial.DIAMOND.getEfficiencyOnProperMaterial(),
      ToolMaterial.DIAMOND.getDamageVsEntity(), //was  - 0.25F
      ToolMaterial.GOLD.getEnchantability());
  MaterialRegistry.emeraldToolMaterial.setRepairItem(MaterialRegistry.emeraldArmorMaterial.repairMaterial);
}

protected static void registerMaterial(String name, MetalMaterial m){

        allMaterials.put(name, m);

        String enumName = m.getEnumName();
        String texName = m.getName();
        int[] protection = m.getDamageReductionArray();
        int durability = m.getArmorMaxDamageFactor();
        ArmorMaterial am = EnumHelper.addArmorMaterial(enumName, texName, durability, protection, m.getEnchantability(), SoundEvents.ITEM_ARMOR_EQUIP_IRON, (m.hardness > 10 ? (int)(m.hardness / 5) : 0));
        if(am == null){
            // uh-oh
            FMLLog.severe("Failed to create armor material enum for "+m);
        }
        armorMaterialMap.put(m, am);
        FMLLog.info("Created armor material enum "+am);

        ToolMaterial tm = EnumHelper.addToolMaterial(enumName, m.getToolHarvestLevel(), m.getToolDurability(), m.getToolEfficiency(), m.getBaseAttackDamage(), m.getEnchantability());
        if(tm == null){
            // uh-oh
            FMLLog.severe("Failed to create tool material enum for "+m);
        }
        toolMaterialMap.put(m, tm);
        FMLLog.info("Created tool material enum "+tm);
    }

public static int getArmorExtraHealthBoost(ItemStack stack) {
    if (stack != null && stack.getItem() instanceof ItemArmor) {
        ArmorMaterial armmat = ((ItemArmor)stack.getItem()).getArmorMaterial();
        String name = armmat.name().toLowerCase(Locale.ROOT);

        if (name.equals("leather")) {
            return 2;
        }
        if (name.equals("coppervc")) {
            return 3; 
        }
        if (name.equals("tinbronzevc")) {
            return 4;
        }
        if (name.equals("bismuthbronzevc")) {
            return 4;
        }
        if (name.equals("ironvc")) {
            return 5;
        }

        //System.out.println("armor material " + name + " not found");

    }
    return 0;
}

private static ItemType fromMCArmorMaterial(ArmorMaterial material) {
    switch (material) {
        case DIAMOND:
            return ItemType.DIAMOND;
        case IRON:
        case CHAIN:
            return ItemType.IRON_INGOT;
        case GOLD:
            return ItemType.GOLD_INGOT;
        case LEATHER:
            return ItemType.LEATHER;
        default:
            throw new CIE("This piece of armor is made of a material that I don't recognize! Is Corundum running with a Minecraft server version higher than "
                    + CorundumServer.getInstance().getMCVersion() + "?", "unidentified tool material", "material=" + material.toString());
    }
}

@Override
public void onEquippedOrLoadedIntoWorld(ItemStack stack, EntityLivingBase player) {

    attributes.clear();
    armorCount = 0;
    for (ItemStack armor : ((EntityPlayer)player).inventory.armorInventory) {
        if (armor != null && armor.getItem() instanceof ItemArmor) {
            if (((ItemArmor)armor.getItem()).getArmorMaterial() != ArmorMaterial.LEATHER)
                armorCount++;
        }
    }
    fillModifiers(attributes, stack);
    player.getAttributeMap().applyAttributeModifiers(attributes);
}

public ItemSetArmour(String texturePrefix, ArmorMaterial material) {
    this.texturePrefix = texturePrefix;
    this.material = material;

    this.helmet = new ItemArmour(material.name() + "Helmet", 7, 0);
    this.chestplate = new ItemArmour(material.name()  + "Chestplate", 7, 1);
    this.leggings = new ItemArmour(material.name()  + "Leggings", 7, 2);
    this.boots = new ItemArmour(material.name()  + "Boots", 7, 3);

    try {
        registerRenderer();
    } catch(NoSuchMethodError e) {
    //  e.printStackTrace();
    }
}

private void renderArmor(EntityLivingBase entity, float limbSwing, float limbSwingAmount, float partialTicks, float ageInTicks, float netHeadYaw, float headPitch, float scale, EntityEquipmentSlot armorSlot) {
    ItemStack itemstack = entity.getItemStackFromSlot(armorSlot);

    if (!itemstack.isEmpty() && itemstack.getItem() instanceof ItemArmor) {

        ItemArmor itemarmor = (ItemArmor) itemstack.getItem();

        AbstractPonyModel modelbase;
        if (armorSlot == EntityEquipmentSlot.LEGS) {
            modelbase = pony.getArmor().modelArmor;
        } else {
            modelbase = pony.getArmor().modelArmorChestplate;
        }
        modelbase = getArmorModel(entity, itemstack, armorSlot, modelbase);
        modelbase.setModelAttributes(this.pony.getModel());
        modelbase.setRotationAngles(limbSwing, limbSwingAmount, ageInTicks, netHeadYaw, headPitch, scale, entity);

        Tuple<ResourceLocation, Boolean> armors = getArmorTexture(entity, itemstack, armorSlot, null);
        prepareToRender((ModelPonyArmor) modelbase, armorSlot, armors.getSecond());

        this.getRenderer().bindTexture(armors.getFirst());
        if (itemarmor.getArmorMaterial() == ArmorMaterial.LEATHER) {
            int color = itemarmor.getColor(itemstack);
            float r = (color >> 16 & 255) / 255.0F;
            float g = (color >> 8 & 255) / 255.0F;
            float b = (color & 255) / 255.0F;
            GlStateManager.color(r, g, b, 1);
            modelbase.render(entity, limbSwing, limbSwingAmount, ageInTicks, netHeadYaw, headPitch, scale);
            armors = getArmorTexture(entity, itemstack, armorSlot, "overlay");
            this.getRenderer().bindTexture(armors.getFirst());
        }
        GlStateManager.color(1, 1, 1, 1);
        modelbase.render(entity, limbSwing, limbSwingAmount, ageInTicks, netHeadYaw, headPitch, scale);

        if (itemstack.isItemEnchanted()) {
            this.renderEnchantment(entity, modelbase, limbSwing, limbSwingAmount, partialTicks, ageInTicks, netHeadYaw, headPitch, scale);
        }
    }
}

/** Get an armor material's repair stack */
public static ItemStack getRepairStack(ArmorMaterial mat) {
    if(matMap.containsKey(mat)) {
        return matMap.get(mat);
    } else {
        return null;
    }
}

public SetArmor(String type,ArmorMaterial material) {
    this.Type=type;
    this.Material=material;
    this.Helm=new ItemBasicArmor(material, 0, EntityEquipmentSlot.HEAD, type);
    this.Chest=new ItemBasicArmor(material, 1, EntityEquipmentSlot.CHEST, type);
    this.Legs=new ItemBasicArmor(material, 2, EntityEquipmentSlot.LEGS, type);
    this.Boots=new ItemBasicArmor(material, 3, EntityEquipmentSlot.FEET, type);
}

public static void addMaterial(String type,ToolMaterial toolMat,ArmorMaterial armorMat){
    Ingot.Metal.add(type);
    Dust.Metal.add(type);
    Nugget.Metal.add(type);
    Gear.Metal.add(type);
    Plate.Metal.add(type);
    Rod.Metal.add(type);
    if(toolMat!=null&&Config.IsToolsEnabled){
        Tools.add(new SetTools(type, toolMat));
    }
    if(armorMat!=null&&Config.IsArmorEnebled){
        Armor.add(new SetArmor(type, armorMat));
    }
    Types.add(type);
}

public static void addMaterial(String type,ToolMaterial toolMat,ArmorMaterial armorMat,boolean shears){
    Ingot.Metal.add(type);
    Dust.Metal.add(type);
    Nugget.Metal.add(type);
    Gear.Metal.add(type);
    Plate.Metal.add(type);
    Rod.Metal.add(type);
    if(toolMat!=null&&Config.IsToolsEnabled){
        Tools.add(new SetTools(type, toolMat,true));
    }
    if(armorMat!=null&&Config.IsArmorEnebled){
        Armor.add(new SetArmor(type, armorMat));
    }
    Types.add(type);
}

public static void addSecondary(String type,ToolMaterial toolMat,ArmorMaterial armorMat,boolean shears){
    if(toolMat!=null&&Config.IsToolsEnabled){
        Tools.add(new SetTools(type, toolMat,shears));
    }
    if(armorMat!=null&&Config.IsArmorEnebled){
        Armor.add(new SetArmor(type, armorMat));
    }
}

private static void registerGlowingMaterials() {
  ArmorMaterial mimicArmor = ArmorMaterial.IRON;
  MaterialRegistry.glowingArmorMaterial = EnumHelper.addArmorMaterial(GLOWING, Const.MODRES + GLOWING,
      ironDurability, // affects DURABILITY  
      new int[] {
          mimicArmor.getDamageReductionAmount(EntityEquipmentSlot.FEET),
          mimicArmor.getDamageReductionAmount(EntityEquipmentSlot.LEGS),
          mimicArmor.getDamageReductionAmount(EntityEquipmentSlot.CHEST),
          mimicArmor.getDamageReductionAmount(EntityEquipmentSlot.HEAD)
      },
      mimicArmor.getEnchantability() + 1,
      mimicArmor.getSoundEvent(),
      mimicArmor.getToughness() + 1);
  MaterialRegistry.glowingArmorMaterial.repairMaterial = new ItemStack(Blocks.GLOWSTONE);
}

static void registerArmor() {
    ArrayList<String> materials = new ArrayList<String>();

    for (int i = 0; i < ItemArmorVC.armorTypes.length; i++) {
        String armorpiece = ItemArmorVC.armorTypes[i];

        for (EnumMetal metal : EnumMetal.values()) {
            if (!metal.hasArmor) continue;

            String ucfirstmaterial = metal.getName().substring(0, 1).toUpperCase(Locale.ROOT) + metal.getName().substring(1);
            String unlocalizedname = metal.getName() + "_" + armorpiece;

            try {
                ArmorMaterial armormat = (ArmorMaterial)ItemArmorVC.class.getField(metal.getName().toUpperCase(Locale.ROOT)+"VC").get(null);

                ItemArmorVC item = ItemArmorVC.class.getDeclaredConstructor(ArmorMaterial.class, String.class, int.class, int.class).newInstance(armormat, metal.getName(), 0, i);
                item.setUnlocalizedName(unlocalizedname);
                GameRegistry.registerItem(item, unlocalizedname);

                VintageCraft.proxy.addVariantName(item, ModInfo.ModID + ":armor/" + unlocalizedname);

                armor.put(unlocalizedname, item);

            } catch (Exception e) {
                System.out.println(e.toString());
                e.printStackTrace();
            }       
        }
    }
}

public static void loadItems() {
        NetworkItems.tablet = new ItemTablet().setCreativeTab(NetworkCore.Network);
        registerItem(NetworkItems.tablet);

        //TODO add this back
//        NetworkItems.serverCart = new ItemBlockCart(15).setCreativeTab(NetworkCore.Network).setUnlocalizedName(prefix + "serverCart");
//        registerItem(NetworkItems.serverCart);

        NetworkItems.wifiGoggles = new ItemArmor(ArmorMaterial.IRON, 0, 0).setCreativeTab(NetworkCore.Network).setUnlocalizedName(prefix + "wifiGoggles").setTextureName("network:wifiGoggles");
        registerItem(NetworkItems.wifiGoggles);

        NetworkItems.ItemBattery = new itemBattery(100000, 2048, 0).setCreativeTab(NetworkCore.Network).setUnlocalizedName(prefix + "ItemBattery").setTextureName("network:Battery");
        registerItem(NetworkItems.ItemBattery);

        NetworkItems.parts = new ItemPart().setCreativeTab(NetworkCore.Network).setUnlocalizedName(prefix + "ItemPart").setTextureName("network:ItemPart");
        registerItem(NetworkItems.parts);

        NetworkItems.drone = new ItemDrone().setCreativeTab(NetworkCore.Network).setUnlocalizedName(prefix + "drone").setTextureName("network:drone");
        registerItem(NetworkItems.drone);

        NetworkItems.pinPad = new ItemPinPad().setCreativeTab(NetworkCore.Network).setUnlocalizedName(prefix + "pinPad").setTextureName("network:pinPad");
        registerItem(NetworkItems.pinPad);

        NetworkItems.networkTool = new NetworkTool(200000, 4096, 0).setCreativeTab(NetworkCore.Network).setUnlocalizedName(prefix + "networkTool").setTextureName("network:networkTool");
        registerItem(NetworkItems.networkTool);

    }

public ItemRunningShoes(ArmorMaterial material, int render, int type) 
{
    super(material, render, type);
    this.type = type;
    this.maxStackSize = 1;
    // TODO Auto-generated constructor stub
}

public DarkMatterArmor(ArmorMaterial material, int id,
        int slot) {
    super(material, id, slot);
    this.setCreativeTab(WorldModule.WorldTab);
    ;
    if(slot == 0) {
        this.setTextureName(Draconix.modid + ":armor/DMHelm");
    }else if (slot == 1) {
        this.setTextureName(Draconix.modid + ":armor/DMChest");
    }else if (slot == 2) {
        this.setTextureName(Draconix.modid + ":armor/DMLegs");      
    }else if (slot == 3) {
        this.setTextureName(Draconix.modid + ":armor/DMBoots");
    }   
}

public AbissArmor(ArmorMaterial material, int id,
        int slot) {
    super(material, id, slot);
    this.setCreativeTab(WorldModule.WorldTab);
    ;
    if(slot == 0) {
        this.setTextureName(Draconix.modid + ":armor/AbissHelm");
    }else if (slot == 1) {
        this.setTextureName(Draconix.modid + ":armor/AbissChest");
    }else if (slot == 2) {
        this.setTextureName(Draconix.modid + ":armor/AbissLegs");       
    }else if (slot == 3) {
        this.setTextureName(Draconix.modid + ":armor/AbissBoots");
    }   
}

private static void registerMiningHelmets() {
    miningHelmetLamp = new ItemMiningLamp(miningHelmetLampId).setUnlocalizedName(ItemLib.MINING_HELMET_LAMP).setTextureName(ResourceLib.MINING_HELMET_LAMP);
    miningHelmetIron = new ItemMiningHelmet(miningHelmetIronId, ArmorMaterial.IRON, 2, ItemLib.MINING_HELMET_IRON, ResourceLib.MINING_HELMET_IRON);
    miningHelmetGold = new ItemMiningHelmet(miningHelmetGoldId, ArmorMaterial.GOLD, 4, ItemLib.MINING_HELMET_GOLD, ResourceLib.MINING_HELMET_GOLD);
    miningHelmetDiamond = new ItemMiningHelmet(miningHelmetDiamondId, ArmorMaterial.DIAMOND, 3, ItemLib.MINING_HELMET_DIAMOND, ResourceLib.MINING_HELMET_DIAMOND);

    GameRegistry.registerItem(miningHelmetLamp,
                              ItemLib.MINING_HELMET_LAMP);
    GameRegistry.registerItem(miningHelmetIron,
                              ItemLib.MINING_HELMET_IRON);
    GameRegistry.registerItem(miningHelmetGold,
                              ItemLib.MINING_HELMET_GOLD);
    GameRegistry.registerItem(miningHelmetDiamond,
                              ItemLib.MINING_HELMET_DIAMOND);
}

private boolean checkPlayerIsWearingSetArmorType(ArmorMaterial mat){
for(int index = 0; index < 4; index++){
    if(player.getCurrentArmor(index) != null){
    ItemArmor armor = (ItemArmor)player.getCurrentArmor(index).getItem();
    if(!armor.getArmorMaterial().equals(mat)){
        return false;
    }
    }
    else{
    return false;
    }
}
return true;
   }

public ItemArtifactArmor(ArmorMaterial armorMaterial, int renderID, int iconNum, int damageIndex) {
    super(armorMaterial, renderID, damageIndex);
    iconn = iconNum;
    this.setCreativeTab(DragonArtifacts.tabArtifacts);
    this.setHasSubtypes(true);
    this.setMaxDamage(armorMaterial.getDurability(damageIndex)*2);
}

@Override
public String getArmorTexture(ItemStack stack, Entity entity, int slot, String type) {

    //The default texture (in case there is no given texture).
    String matName = stack.stackTagCompound.getString("matName").toLowerCase();
    if(type == null) {
        matName = "color";
    }
    String texture = "artifacts:textures/models/armor/"+matName+"_default_layer"+ (slot == 2 ? "2" : "1") +".png";

    if(stack.stackTagCompound == null) {
        return texture;
    }
    //Get the armor model texture map holding the textures mapped to the item's icon.
    HashMap<ArmorMaterial, String> modelMap = ArtifactsAPI.itemicons.armorModels.get( (type == null ? "color_" : "") + stack.stackTagCompound.getString("icon").toLowerCase());
    if(modelMap == null) {
        return texture;
    }

    //Get the texture for the material type.
    String modelTexture = modelMap.get(this.getArmorMaterial());
    if(modelTexture == null) {
        return texture;
    }
    else {
        texture = modelTexture;
    }

    return texture;
}

@Override
public void registerModelTexture(String icon, ArmorMaterial material, String modelTexture, String modelColor) {
    HashMap<ArmorMaterial, AbstractModelTexture> innerMap = modelMap.get(icon);

    if(innerMap == null) {
        innerMap = new HashMap<ArmorMaterial, AbstractModelTexture>();
    }

    innerMap.put(material, new AbstractModelTexture(modelTexture, modelColor));
    modelMap.put(icon, innerMap);
}

public MaterialDefinition setArmorMaterial(ArmorMaterial armorMaterial) {
    this.armorMaterial = armorMaterial;
    return this;
}

public ArmorMaterial getArmorMaterial() {
    return this.armorMaterial;
}

public static ArmorMaterial addArmorMaterial(String name, String textureName, int durability, int[] reductionAmounts, int enchantability, SoundEvent soundOnEquip, float toughness)
{
    return addEnum(ArmorMaterial.class, name, textureName, durability, reductionAmounts, enchantability, soundOnEquip, toughness);
}

public iteml83(ArmorMaterial material, int render_index, int armor_type) {
    super(material, render_index, armor_type);
    // TODO Auto-generated constructor stub
    setUnlocalizedName("iteml83");
     setCreativeTab(ItemRegistry1.FF7itemsL);
}

public static ArmorMaterial addArmorMaterial(String name, int durability, int[] reductionAmounts, int enchantability)
{
    return addEnum(ArmorMaterial.class, name, durability, reductionAmounts, enchantability);
}

public static ItemARKArmor addArmorItem(String name, ArmorMaterial mat, String armorTexName, EntityEquipmentSlot type,
        boolean golden)
{
    return InitializationManager.instance().registerItem(name, new ItemARKArmor(mat, armorTexName, type, golden));
}

public static ArmorMaterial addArmorMaterial(String string, int i, int[] js, int j) {
    return null;
}

public ItemCandyCaneArmor(ArmorMaterial diamond, int i, int j) {
    super(diamond, 0, i);
    //this.textureName = textureName;
    this.setUnlocalizedName("ItemCandyCaneArmor");
    this.setTextureName("epicproportionsmod_christmas:ItemCandyCaneArmor");
}

public ItemGingerBreadArmor(ArmorMaterial diamond, int i, int j) {
    super(diamond, 0, i);
    //this.textureName = textureName;
    this.setUnlocalizedName("ItemGingerBreadArmor");
    this.setTextureName("epicproportionsmod_christmas:ItemGingerBreadArmor");
}

public ItemSuperPatArmor(ArmorMaterial diamond, int i, int j) {
    super(diamond, 0, i);
    //this.textureName = textureName;
    this.setUnlocalizedName("ItemSuperPatArmor");
    this.setTextureName("epicproportionsmod:ItemSuperPatArmor");
}

public ItemJenArmor(ArmorMaterial diamond, int i, int j) {
    super(diamond, 0, i);
    //this.textureName = textureName;
    this.setUnlocalizedName("ItemJenArmor");
    this.setTextureName("epicproportionsmod:ItemJenArmor");
}

public ItemSuperJenArmor(ArmorMaterial diamond, int i, int j) {
    super(diamond, 0, i);
    //this.textureName = textureName;
    this.setUnlocalizedName("ItemSuperJenArmor");
    this.setTextureName("epicproportionsmod:ItemSuperJenArmor");
}

public ItemPatArmor(ArmorMaterial diamond, int i, int j) {
    super(diamond, 0, i);
    //this.textureName = textureName;
    this.setUnlocalizedName("ItemPatArmor");
    this.setTextureName("epicproportionsmod:ItemPatArmor");
}

public itemJenslips(ArmorMaterial diamond, int i, int j) {
    super(diamond, 0, i);
    //this.textureName = textureName;
    this.setUnlocalizedName("itemJenslips");
    this.setTextureName("epicproportionsmod:itemJenslips");
}