modloader.clas fix for 1.1 (untested)

import java.awt.image.BufferedImage;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.URI;
import java.net.URL;
import java.net.URLClassLoader;
import java.security.DigestException;
import java.security.NoSuchAlgorithmException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Properties;
import java.util.Random;
import java.util.Set;
import java.util.logging.FileHandler;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.logging.SimpleFormatter;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;
import javax.imageio.ImageIO;
import net.minecraft.client.Minecraft;
import org.lwjgl.input.Keyboard;
import org.lwjgl.input.Mouse;

public final class ModLoader
{
  private static final List<sr> animList = new LinkedList();
  private static final Map<Integer, BaseMod> blockModels = new HashMap();
  private static final Map<Integer, Boolean> blockSpecialInv = new HashMap();
  private static final File cfgdir = new File(Minecraft.b(), "/config/");
  private static final File cfgfile = new File(cfgdir, "ModLoader.cfg");

  public static Level cfgLoggingLevel = Level.FINER;
  private static Map<String, Class<? extends ms>> classMap = null;
  private static long clock = 0L;
  public static final boolean DEBUG = false;
  private static Field field_animList = null;
  private static Field field_armorList = null;
  private static Field field_modifiers = null;
  private static Field field_TileEntityRenderers = null;
  private static boolean hasInit = false;
  private static int highestEntityId = 3000;
  private static final Map<BaseMod, Boolean> inGameHooks = new HashMap();
  private static final Map<BaseMod, Boolean> inGUIHooks = new HashMap();

  private static Minecraft instance = null;
  private static int itemSpriteIndex = 0;
  private static int itemSpritesLeft = 0;
  private static final Map<BaseMod, Map<ads, boolean[]>> keyList = new HashMap();
  private static final File logfile = new File(Minecraft.b(), "ModLoader.txt");
  private static final Logger logger = Logger.getLogger("ModLoader");
  private static FileHandler logHandler = null;
  private static Method method_RegisterEntityID = null;
  private static Method method_RegisterTileEntity = null;
  private static final File modDir = new File(Minecraft.b(), "/mods/");
  private static final LinkedList<BaseMod> modList = new LinkedList();
  private static int nextBlockModelID = 1000;
  private static final Map<Integer, Map<String, Integer>> overrides = new HashMap();

  public static final Properties props = new Properties();
  private static zp[] standardBiomes;
  private static int terrainSpriteIndex = 0;
  private static int terrainSpritesLeft = 0;
  private static String texPack = null;

  private static boolean texturesAdded = false;

  private static final boolean[] usedItemSprites = new boolean[256];

  private static final boolean[] usedTerrainSprites = new boolean[256];
  public static final String VERSION = "ModLoader 1.1";
  private static Map<String, String> localizedStrings = new HashMap();

  private static String langPack = null;

  public static void AddAchievementDesc(aca paramws, String paramString1, String paramString2)
  {
    try
    {
      if (paramws.i().contains(".")) {
        String[] arrayOfString = paramws.i().split("\\.");
        if (arrayOfString.length == 2) {
          String str = arrayOfString[1];
          AddLocalization(new StringBuilder().append("achievement.").append(str).toString(), paramString1);
          AddLocalization(new StringBuilder().append("achievement.").append(str).append(".desc").toString(), paramString2);
          setPrivateValue(ahm.class, paramws, 1, cs.a(new StringBuilder().append("achievement.").append(str).toString()));
          setPrivateValue(aca.class, paramws, 3, cs.a(new StringBuilder().append("achievement.").append(str).append(".desc").toString()));
        } else {
          setPrivateValue(ahm.class, paramws, 1, paramString1);
          setPrivateValue(aca.class, paramws, 3, paramString2);
        }
      } else {
        setPrivateValue(ahm.class, paramws, 1, paramString1);
        setPrivateValue(aca.class, paramws, 3, paramString2);
      }
    } catch (IllegalArgumentException localIllegalArgumentException) {
      logger.throwing("ModLoader", "AddAchievementDesc", localIllegalArgumentException);
      ThrowException(localIllegalArgumentException);
    } catch (SecurityException localSecurityException) {
      logger.throwing("ModLoader", "AddAchievementDesc", localSecurityException);
      ThrowException(localSecurityException);
    } catch (NoSuchFieldException localNoSuchFieldException) {
      logger.throwing("ModLoader", "AddAchievementDesc", localNoSuchFieldException);
      ThrowException(localNoSuchFieldException);
    }
  }

  public static int AddAllFuel(int paramInt1, int paramInt2)
  {
    logger.finest(new StringBuilder().append("Finding fuel for ").append(paramInt1).toString());
    int i = 0;
    for (Iterator localIterator = modList.iterator(); (localIterator.hasNext()) && (i == 0); )
      i = ((BaseMod)localIterator.next()).AddFuel(paramInt1, paramInt2);
    if (i != 0)
      logger.finest(new StringBuilder().append("Returned ").append(i).toString());
    return i;
  }

  public static void AddAllRenderers(Map<Class<? extends ms>, ti> paramMap)
  {
    if (!hasInit) {
      init();
      logger.fine("Initialized");
    }

    for (BaseMod localBaseMod : modList)
      localBaseMod.AddRenderer(paramMap);
  }

  public static void addAnimation(sr paramdt)
  {
    logger.finest(new StringBuilder().append("Adding animation ").append(paramdt.toString()).toString());
    for (sr localdt : animList) {
      if ((localdt.g == paramdt.g) && (localdt.k == paramdt.k)) {
        animList.remove(paramdt);
        break;
      }
    }
    animList.add(paramdt);
  }

  public static int AddArmor(String paramString)
  {
    try
    {
      String[] arrayOfString = (String[])(String[])field_armorList.get(null);
      List localList = Arrays.asList(arrayOfString);
      ArrayList localArrayList = new ArrayList();
      localArrayList.addAll(localList);
      if (!localArrayList.contains(paramString))
        localArrayList.add(paramString);
      int i = localArrayList.indexOf(paramString);
      field_armorList.set(null, localArrayList.toArray(new String[0]));
      return i;
    } catch (IllegalArgumentException localIllegalArgumentException) {
      logger.throwing("ModLoader", "AddArmor", localIllegalArgumentException);
      ThrowException("An impossible error has occured!", localIllegalArgumentException);
    } catch (IllegalAccessException localIllegalAccessException) {
      logger.throwing("ModLoader", "AddArmor", localIllegalAccessException);
      ThrowException("An impossible error has occured!", localIllegalAccessException);
    }
    return -1;
  }

  public static void AddLocalization(String paramString1, String paramString2)
  {
    localizedStrings.put(key, value);
  }

  private static void addMod(ClassLoader paramClassLoader, String paramString)
  {
    try
    {
      String str = paramString.split("\\.")[0];
      if (str.contains("$"))
        return;
      if ((props.containsKey(str)) && ((props.getProperty(str).equalsIgnoreCase("no")) || (props.getProperty(str).equalsIgnoreCase("off"))))
        return;
      Package localPackage = ModLoader.class.getPackage();
      if (localPackage != null)
        str = new StringBuilder().append(localPackage.getName()).append(".").append(str).toString();
      Class localClass = paramClassLoader.loadClass(str);
      if (!BaseMod.class.isAssignableFrom(localClass)) {
        return;
      }
      setupProperties(localClass);
      BaseMod localBaseMod = (BaseMod)localClass.newInstance();

      if (localBaseMod != null) {
        modList.add(localBaseMod);
        logger.fine(new StringBuilder().append("Mod Initialized: \"").append(localBaseMod.toString()).append("\" from ").append(paramString).toString());
        System.out.println(new StringBuilder().append("Mod Initialized: ").append(localBaseMod.toString()).toString());
      }
    } catch (Throwable localThrowable) {
      logger.fine(new StringBuilder().append("Failed to load mod from \"").append(paramString).append("\"").toString());
      System.out.println(new StringBuilder().append("Failed to load mod from \"").append(paramString).append("\"").toString());
      logger.throwing("ModLoader", "addMod", localThrowable);
      ThrowException(localThrowable);
    }
  }

  public static void AddName(Object paramObject, String paramString)
  {
    String str1 = null;
    Object localObject;
    if ((paramObject instanceof ww)) {
      localObject = (ww)paramObject;
      if (((acy)localObject).e() != null)
        str1 = new StringBuilder().append(((acy)localObject).e()).append(".name").toString();
    } else if ((paramObject instanceof oe)) {
      localObject = (oe)paramObject;
      if (((oe)localObject).p() != null).p() != null)
      str1 = new StringBuilder().append(((oe)localObject).p()).append(".name").toString();
    } else if ((paramObject instanceof yq)) {
      localObject = (yq)paramObject;
      String str2 = ww.e[localObject.c].a((yq)localObject);
      if (str2 != null)
        str1 = new StringBuilder().append(str2).append(".name").toString();
    } else {
      localObject = new Exception(new StringBuilder().append(paramObject.getClass().getName()).append(" cannot have name attached to it!").toString());
      logger.throwing("ModLoader", "AddName", (Throwable)localObject);
      ThrowException((Throwable)localObject);
    }
    if (str1 != null) { AddLocalization(str1, paramString);
    } else {
      localObject = new Exception(new StringBuilder().append(paramObject).append(" is missing name tag!").toString());
      logger.throwing("ModLoader", "AddName", (Throwable)localObject);
      ThrowException((Throwable)localObject);
    }
  }

  public static int addOverride(String paramString1, String paramString2)
  {
    try
    {
      int i = getUniqueSpriteIndex(paramString1);
      addOverride(paramString1, paramString2, i);
      return i;
    } catch (Throwable localThrowable) {
      logger.throwing("ModLoader", "addOverride", localThrowable);
      ThrowException(localThrowable);
    }throw new RuntimeException(localThrowable);
  }

 public static void addOverride(String paramString1, String paramString2, int paramInt)
  {
    int i = -1;
    int j = 0;
    if (paramString1.equals("/terrain.png")) {
      i = 0;
      j = terrainSpritesLeft;
    } else if (paramString1.equals("/gui/items.png")) {
      i = 1;
      j = itemSpritesLeft; } else {
      return;
    }System.out.println(new StringBuilder().append("Overriding ").append(paramString1).append(" with ").append(paramString2).append(" @ ").append(paramInt).append(". ").append(j).append(" left.").toString());
    logger.finer(new StringBuilder().append("addOverride(").append(paramString1).append(",").append(paramString2).append(",").append(paramInt).append("). ").append(j).append(" left.").toString());
    Object localObject = (Map)overrides.get(Integer.valueOf(i));
    if (localObject == null) {
      localObject = new HashMap();
      overrides.put(Integer.valueOf(i), localObject);
    }
    ((Map)localObject).put(paramString2, Integer.valueOf(paramInt));
  }

  public static void AddRecipe(yq paramdk, Object[] paramArrayOfObject)
  {
    fk.a().a(paramdk, paramArrayOfObject);
  }

  public static void AddShapelessRecipe(yq paramdk, Object[] paramArrayOfObject)
  {
    fk.a().b(paramdk, paramArrayOfObject);
  }

  public static void AddSmelting(int paramInt, yq paramdk)
  {
    ds.a().a(paramInt, paramdk);
  }

  public static void AddSpawn(Class<? extends aar> paramClass, int paramInt1, int paramInt2, int paramInt3, aah paramjf)
  {
    AddSpawn(paramClass, paramInt1, paramInt2, paramInt3, paramjf, null);
  }

  public static void AddSpawn(Class<? extends aar> paramClass, int paramInt1, int paramInt2, int paramInt3, aah paramjf, zp[] paramArrayOfsr)
  {
    if (paramClass == null) {
      throw new IllegalArgumentException("entityClass cannot be null");
    }
    if (paramjf == null) {
      throw new IllegalArgumentException("spawnList cannot be null");
    }
    if (paramArrayOfsr == null) {
      paramArrayOfsr = standardBiomes;
    }
    for (int i = 0; i < paramArrayOfsr.length; i++)
    {
      List list = biomes[i].a(spawnList);

List localList = paramArrayOfsr[i].a(paramjf);

      if (localList != null) {
        int j = 0;
        for (bd localyx : localList) {
          if (localyx.a == paramClass) {
            localyx.d = paramInt1;
            localyx.b = paramInt2;
            localyx.c = paramInt3;
            j = 1;
            break;
          }
        }
        if (j == 0)
          localList.add(new bd(paramClass, paramInt1, paramInt2, paramInt3));
      }
    }
  }

  public static void AddSpawn(String paramString, int paramInt1, int paramInt2, int paramInt3, aah paramjf)
  {
    AddSpawn(paramString, paramInt1, paramInt2, paramInt3, paramjf, null);
  }

  public static void AddSpawn(String paramString, int paramInt1, int paramInt2, int paramInt3, aah paramjf, zp[] paramArrayOfsr)
  {
    Class localClass = (Class)classMap.get(paramString);
    if ((localClass != null) && (aar.class.isAssignableFrom(localClass)))
      AddSpawn(localClass, paramInt1, paramInt2, paramInt3, paramjf, paramArrayOfsr);
  }

  public static boolean DispenseEntity(vq world, paramry, double paramDouble1, double paramDouble2, double paramDouble3, int paramInt1, int paramInt2, yq paramdk)
  {
    boolean bool = false;
    for (Iterator localIterator = modList.iterator(); (localIterator.hasNext()) && (!bool); )
      bool = ((BaseMod)localIterator.next()).DispenseEntity(paramry, paramDouble1, paramDouble2, paramDouble3, paramInt1, paramInt2, paramdk);
    return bool;
  }

  public static List<BaseMod> getLoadedMods()
  {
    return Collections.unmodifiableList(modList);
  }

  public static Logger getLogger()
  {
    return logger;
  }

  public static Minecraft getMinecraftInstance()
  {
    if (instance == null) {
      try {
        ThreadGroup localThreadGroup = Thread.currentThread().getThreadGroup();
        int i = localThreadGroup.activeCount();
        Thread[] arrayOfThread = new Thread[i];
        localThreadGroup.enumerate(arrayOfThread);
        for (int j = 0; j < arrayOfThread.length; j++) {
          System.out.println(arrayOfThread[j].getName());
        }
        for (j = 0; j < arrayOfThread.length; j++)
          if (arrayOfThread[j].getName().equals("Minecraft main thread")) {
            instance = (Minecraft)getPrivateValue(Thread.class, arrayOfThread[j], "target");
            break;
          }
      }
      catch (SecurityException localSecurityException) {
        logger.throwing("ModLoader", "getMinecraftInstance", localSecurityException);
        throw new RuntimeException(localSecurityException);
      } catch (NoSuchFieldException localNoSuchFieldException) {
        logger.throwing("ModLoader", "getMinecraftInstance", localNoSuchFieldException);
        throw new RuntimeException(localNoSuchFieldException);
      }
    }
    return instance;
  }

  public static <T, E> T getPrivateValue(Class<? super E> paramClass, E paramE, int paramInt)
    throws IllegalArgumentException, SecurityException, NoSuchFieldException
  {
    try
    {
      Field localField = paramClass.getDeclaredFields()[paramInt];
      localField.setAccessible(true);
      return localField.get(paramE);
    } catch (IllegalAccessException localIllegalAccessException) {
      logger.throwing("ModLoader", "getPrivateValue", localIllegalAccessException);
      ThrowException("An impossible error has occured!", localIllegalAccessException);
    }
    return null;
  }

  public static <T, E> T getPrivateValue(Class<? super E> paramClass, E paramE, String paramString)
    throws IllegalArgumentException, SecurityException, NoSuchFieldException
  {
    try
    {
      Field localField = paramClass.getDeclaredField(paramString);
      localField.setAccessible(true);
      return localField.get(paramE);
    } catch (IllegalAccessException localIllegalAccessException) {
      logger.throwing("ModLoader", "getPrivateValue", localIllegalAccessException);
      ThrowException("An impossible error has occured!", localIllegalAccessException);
    }
    return null;
  }

  public static int getUniqueBlockModelID(BaseMod paramBaseMod, boolean paramBoolean)
  {
    int i = nextBlockModelID++;
    blockModels.put(Integer.valueOf(i), paramBaseMod);
    blockSpecialInv.put(Integer.valueOf(i), Boolean.valueOf(paramBoolean));
    return i;
  }

  public static int getUniqueEntityId()
  {
    return highestEntityId++;
  }

  private static int getUniqueItemSpriteIndex()
  {
    for (; itemSpriteIndex < usedItemSprites.length; itemSpriteIndex += 1)
      if (usedItemSprites[itemSpriteIndex] == 0) {
        usedItemSprites[itemSpriteIndex] = true;
        itemSpritesLeft -= 1;
        return itemSpriteIndex++;
      }
    Exception localException = new Exception("No more empty item sprite indices left!");
    logger.throwing("ModLoader", "getUniqueItemSpriteIndex", localException);
    ThrowException(localException);
    return 0;
  }

  public static int getUniqueSpriteIndex(String paramString)
  {
    if (paramString.equals("/gui/items.png")) return getUniqueItemSpriteIndex();
    if (paramString.equals("/terrain.png"))
      return getUniqueTerrainSpriteIndex();
    Exception localException = new Exception(new StringBuilder().append("No registry for this texture: ").append(paramString).toString());
    logger.throwing("ModLoader", "getUniqueItemSpriteIndex", localException);
    ThrowException(localException);
    return 0;
  }

  private static int getUniqueTerrainSpriteIndex()
  {
    for (; terrainSpriteIndex < usedTerrainSprites.length; terrainSpriteIndex += 1)
      if (usedTerrainSprites[terrainSpriteIndex] == 0) {
        usedTerrainSprites[terrainSpriteIndex] = true;
        terrainSpritesLeft -= 1;
        return terrainSpriteIndex++;
      }
    Exception localException = new Exception("No more empty terrain sprite indices left!");
    logger.throwing("ModLoader", "getUniqueItemSpriteIndex", localException);
    ThrowException(localException);
    return 0;
  }

  private static void init()
  {
    hasInit = true;

    String str1 = "1111111111111111111111111111111111111101111111111111111111111111111111111111111111111111111111111111110111111111111111000111111111111101111111110000000100111111000000010000111100000000000000110000000000000000000000000000000000000000000000001111111111111111";

    String str2 = "1111111111111111111111111111110111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111110111111111111100000001111111111000000001111000000000111111000000000001111111000000001111111111111111111";

    for (int i = 0; i < 256; i++) {
      usedItemSprites[i] = (str1.charAt(i) == '1' ? 1 : false);
      if (usedItemSprites[i] == 0)
        itemSpritesLeft += 1;
      usedTerrainSprites[i] = (str2.charAt(i) == '1' ? 1 : false);
      if (usedTerrainSprites[i] == 0) {
        terrainSpritesLeft += 1;
      }

    }
    Object localObject1;
    try
    {
      instance = (Minecraft)getPrivateValue(Minecraft.class, null, 1);

      instance.u = new EntityRendererProxy(instance);
      classMap = (Map)getPrivateValue(yr.class, null, 0);
      field_modifiers = Field.class.getDeclaredField("modifiers");
      field_modifiers.setAccessible(true);
      field_TileEntityRenderers = aai.class.getDeclaredFields()[0];
      field_TileEntityRenderers.setAccessible(true);
      field_armorList = us.class.getDeclaredFields()[3];
      field_modifiers.setInt(field_armorList, field_armorList.getModifiers() & 0xFFFFFFEF);
      field_armorList.setAccessible(true);
      field_animList = yz.class.getDeclaredFields()[6];
      field_animList.setAccessible(true);

      Field[] arrayOfField = zp.class.getDeclaredFields();

      localObject1 = new LinkedList();
      for (int j = 0; j < arrayOfField.length; j++) {
        Class localClass = arrayOfField[j].getType();

        if (((arrayOfField[j].getModifiers() & 0x8) != 0) && (localClass.isAssignableFrom(zp.class))) {
          zp localsr = (zp)arrayOfField[j].get(null);
          if (((localsr instanceof sd)) || ((localsr instanceof fr)))
            continue;
          ((List)localObject1).add(localsr);
        }
      }

      standardBiomes = (zp[])(zp[])((List)localObject1).toArray(new zp[0]);
      try
      {
        method_RegisterTileEntity = kf.class.getDeclaredMethod("a", new Class[] { Class.class, String.class });
      } catch (NoSuchMethodException localNoSuchMethodException2) {
        method_RegisterTileEntity = kf.class.getDeclaredMethod("addMapping", new Class[] { Class.class, String.class });
      }
      method_RegisterTileEntity.setAccessible(true);
      try
      {
        method_RegisterEntityID = yr.class.getDeclaredMethod("a", new Class[] { Class.class, String.class, Integer.TYPE });
      } catch (NoSuchMethodException localNoSuchMethodException3) {
        method_RegisterEntityID = yr.class.getDeclaredMethod("addMapping", new Class[] { Class.class, String.class, Integer.TYPE });
      }
      method_RegisterEntityID.setAccessible(true);
    }
    catch (SecurityException localSecurityException) {
      logger.throwing("ModLoader", "init", localSecurityException);
      ThrowException(localSecurityException);
      throw new RuntimeException(localSecurityException);
    } catch (NoSuchFieldException localNoSuchFieldException) {
      logger.throwing("ModLoader", "init", localNoSuchFieldException);
      ThrowException(localNoSuchFieldException);
      throw new RuntimeException(localNoSuchFieldException);
    } catch (NoSuchMethodException localNoSuchMethodException1) {
      logger.throwing("ModLoader", "init", localNoSuchMethodException1);
      ThrowException(localNoSuchMethodException1);
      throw new RuntimeException(localNoSuchMethodException1);
    } catch (IllegalArgumentException localIllegalArgumentException) {
      logger.throwing("ModLoader", "init", localIllegalArgumentException);
      ThrowException(localIllegalArgumentException);
      throw new RuntimeException(localIllegalArgumentException);
    } catch (IllegalAccessException localIllegalAccessException) {
      logger.throwing("ModLoader", "init", localIllegalAccessException);
      ThrowException(localIllegalAccessException);
      throw new RuntimeException(localIllegalAccessException);
    }

    try
    {
      loadConfig();
      if (props.containsKey("loggingLevel"))
        cfgLoggingLevel = Level.parse(props.getProperty("loggingLevel"));
      if (props.containsKey("grassFix")) {
        uc.cfgGrassFix = Boolean.parseBoolean(props.getProperty("grassFix"));
      }
      logger.setLevel(cfgLoggingLevel);
      if (((logfile.exists()) || (logfile.createNewFile())) && (logfile.canWrite()) && (logHandler == null)) {
        logHandler = new FileHandler(logfile.getPath());
        logHandler.setFormatter(new SimpleFormatter());
        logger.addHandler(logHandler);
      }
      logger.fine("ModLoader 1.1 Initializing...");

      System.out.println("ModLoader 1.1 Initializing...");
      File source = new File(ModLoader.class.getProtectionDomain().getCodeSource().getLocation().toURI());
      modDir.mkdirs();
      URLClassLoader localURLClassLoader = (URLClassLoader)ModLoader.class.getClassLoader();
      localObject1 = localURLClassLoader.getURLs();
      for (Object localObject3 : localObject1) {
        File localFile = new File(localObject3.toURI());
        String str3 = localFile.getName();
        if ((str3.startsWith("lwjgl")) || (str3.equals("jinput.jar")))
          continue;
        readFromClassPath(localFile);
      }
      readFromModFolder(modDir);
      sortModList();

      for (??? = modList.iterator(); ((Iterator)???).hasNext(); ) { localBaseMod = (BaseMod)((Iterator)???).next();
        localBaseMod.load();
        logger.fine(new StringBuilder().append("Mod Loaded: \"").append(localBaseMod.toString()).append("\"").toString());
        System.out.println(new StringBuilder().append("Mod Loaded: ").append(localBaseMod.toString()).toString());
        if (!props.containsKey(localBaseMod.getClass().getSimpleName()))
          props.setProperty(localBaseMod.getClass().getSimpleName(), "on");
      }
      BaseMod localBaseMod;
      for (??? = modList.iterator(); ((Iterator)???).hasNext(); ) { localBaseMod = (BaseMod)((Iterator)???).next();
        localBaseMod.ModsLoaded();
      }

      System.out.println("Done.");

      props.setProperty("loggingLevel", cfgLoggingLevel.getName());
      props.setProperty("grassFix", Boolean.toString(uc.cfgGrassFix));

      instance.A.A = RegisterAllKeys(instance.A.A);
      instance.A.a();

      initStats();

      saveConfig();
    } catch (Throwable localThrowable) {
      logger.throwing("ModLoader", "init", localThrowable);
      ThrowException("ModLoader has failed to initialize.", localThrowable);
      if (logHandler != null)
        logHandler.close();
      throw new RuntimeException(localThrowable);
    }
  }

  private static void sortModList() throws Exception {
    HashMap localHashMap = new HashMap();
    for (Object localObject = getLoadedMods().iterator(); ((Iterator)localObject).hasNext(); ) { BaseMod localBaseMod1 = (BaseMod)((Iterator)localObject).next();
      localHashMap.put(localBaseMod1.getClass().getSimpleName(), localBaseMod1);
    }
    localObject = new LinkedList();
    int i = 0;
    while ((((LinkedList)localObject).size() != modList.size()) &&
      (i <= 10))
    {
      for (BaseMod localBaseMod2 : modList) {
        if (((LinkedList)localObject).contains(localBaseMod2))
          continue;
        String str1 = localBaseMod2.getPriorities();

        if ((str1 == null) || (str1.length() == 0) || (str1.indexOf(58) == -1)) {
          ((LinkedList)localObject).add(localBaseMod2);
        }
        else
        {
          if (i <= 0)
            continue;
          int j = -1;
          int k = -2147483648;
          int m = 2147483647;
          String[] arrayOfString1;
          if (str1.indexOf(59) > 0)
            arrayOfString1 = str1.split(";");
          else {
            arrayOfString1 = new String[] { str1 };
          }

          int n = 0;
          while (true) { String str2 = arrayOfString1[n];
            if (str2.indexOf(58) != -1)
            {
              String[] arrayOfString2 = str2.split(":");
              String str3 = arrayOfString2[0];
              String str4 = arrayOfString2[1];

              if ((str3.contentEquals("required-before")) || (str3.contentEquals("before")) || (str3.contentEquals("after")) || (str3.contentEquals("required-after")))
              {
                if (str4.contentEquals("*")) {
                  if ((str3.contentEquals("required-before")) || (str3.contentEquals("before"))) {
                    j = 0; break label556;
                  }if ((!str3.contentEquals("required-after")) && (!str3.contentEquals("after"))) break label556; j = newList.size();

                  break label556;
                }

                if (((key.contentEquals("required-before")) || (key.contentEquals("required-after"))) && (!localHashMap.containsKey(str4))) {
                  throw new Exception(String.format("%s is missing dependency: %s", new Object[] { mod, value }));
                }
                BaseMod localBaseMod3 = (BaseMod)localHashMap.get(str4);
                if (!((LinkedList)localObject).contains(localBaseMod3)) {
                  break;
                }
                int i1 = ((LinkedList)localObject).indexOf(localBaseMod3);

                if ((str3.contentEquals("required-before")) || (str3.contentEquals("before"))) {
                  j = i1;
                  if (j < m) m = j;
                  else
                    j = m;
                }
                else if ((str3.contentEquals("required-after")) || (str3.contentEquals("after"))) {
                  j = i1 + 1;
                  if (j > k) k = j;
                  else
                    j = k;
                }
              }
            }
            n++; if (n < arrayOfString1.length)
            {
              continue;
            }

            if (j == -1) break;
            ((LinkedList)localObject).add(j, localBaseMod2); }
        }
      }
      i++;
    }
    label556: modList.clear();
    modList.addAll((Collection)localObject);
  }

  private static void initStats() {
    for (int i = 0; i < oe.m.length; i++) {
      if ((!gl.a.containsKey(Integer.valueOf(16777216 + id))) && (oe.m[i] != null) && (oe.m[i].q())) {
        String str = abn.a().a("stat.mineBlock", new Object[] { oe.m[i].o() });
        gl.C[i] = new agd(16777216 + i, (String)localObject1, i).a();
        gl.e.add(gl.C[i]);
      }
    }

    for (i = 0; i < ww.e.length; i++) {
      if ((!gl.a.containsKey(Integer.valueOf(16908288 + i))) && (ww.e[i] != null)) {
        localObject1 = abn.a().a("stat.useItem", new Object[] { Boolean.valueOf(ww.e[i].k()) });
        gl.E[i] = new agd(16908288 + i, (String)localObject1, i).a();

        if (i >= oe.m.length) {
          gl.d.add(gl.E[i]);
        }
      }

      if ((!gl.a.containsKey(Integer.valueOf(16973824 + i))) && (ww.e[i] != null) && (ww.e[i].i())) {
        localObject1 = abn.a().a("stat.breakItem", new Object[] { Boolean.valueOf(ww.e[i].k()) });
        gl.F[i] = new agd(16973824 + i, (String)localObject1, i).a();
      }
    }

    HashSet localHashSet = new HashSet();

    for (Object localObject1 = fk.a().b().iterator(); ((Iterator)localObject1).hasNext(); ) { localObject2 = ((Iterator)localObject1).next();
      localHashSet.add(Integer.valueOf(((ut)localObject2).b().c));
    }
 Object localObject2;
    for (localObject1 = ds.a().b().values().iterator(); ((Iterator)localObject1).hasNext(); ) { localObject2 = ((Iterator)localObject1).next();
      localHashSet.add(Integer.valueOf((((yq)localObject2).c));
    }
    for (localObject1 = localHashSet.iterator(); ((Iterator)localObject1).hasNext(); ) { int j = ((Integer)((Iterator)localObject1).next()).intValue();
      if ((!gl.a.containsKey(Integer.valueOf(16842752 + j))) && (ww.e[j] != null)) {
        String str = abn.a().a("stat.craftItem", new Object[] { Boolean.valueOf(ww.e[j].k()) });
        gl.D[j] = new agd(16842752 + j, str, j).a();
      }
    }
  }

  public static boolean isGUIOpen(Class<? extends ug> paramClass)
  {
    Minecraft localMinecraft = getMinecraftInstance();
    if (paramClass == null) {
      return localMinecraft.s == null;
    }
    if ((localMinecraft.s == null) && (paramClass != null)) {
      return false;
    }
    return gui.isInstance(game.s);
  }

  public static boolean isModLoaded(String paramString)
  {
    Class localClass = null;
    try {
      localClass = Class.forName(paramString);
    } catch (ClassNotFoundException localClassNotFoundException) {
      return false;
    }
    if (localClass != null) {
      for (BaseMod localBaseMod : modList) {
        if (localClass.isInstance(localBaseMod))
          return true;
      }
    }
    return false;
  }

  public static void loadConfig()
    throws IOException
  {
    cfgdir.mkdir();

    if ((!cfgfile.exists()) && (!cfgfile.createNewFile())) {
      return;
    }
    if (cfgfile.canRead()) {
      FileInputStream localFileInputStream = new FileInputStream(cfgfile);
      props.load(localFileInputStream);
      localFileInputStream.close();
    }
  }

  public static BufferedImage loadImage(yz paramzh, String paramString)
    throws Exception
  {
    fy localadk = (fy)getPrivateValue(yz.class, paramzh, 11);
    InputStream localInputStream = localadk.a.a(paramString);
    if (localInputStream == null)
      throw new Exception(new StringBuilder().append("Image not found: ").append(paramString).toString());
    BufferedImage localBufferedImage = ImageIO.read(localInputStream);
    if (localBufferedImage == null)
      throw new Exception(new StringBuilder().append("Image corrupted: ").append(paramString).toString());
    return localBufferedImage;
  }

  public static void OnItemPickup(xb paramvi, yq paramdk)
  {
    for (BaseMod localBaseMod : modList)
      localBaseMod.OnItemPickup(paramvi, paramdk);
  }

  public static void OnTick(float paramFloat, Minecraft paramMinecraft)
  {
    ld.b();
    ld.b();
    ld.a("modtick");
    if (!hasInit) {
      init();
      logger.fine("Initialized");
    }

    if ((texPack == null) || (paramMinecraft.A.m != texPack)) {
      texturesAdded = false;
      texPack = paramMinecraft.A.m;
    }

    if ((langPack == null) || (abn.a().c() != langPack)) {
      Properties localized = null;
      try {
        localized = (Properties)getPrivateValue(abn.class, abn.a(), 1);
      } catch (SecurityException e) {
        logger.throwing("ModLoader", "AddLocalization", e);
        ThrowException(e);
      } catch (NoSuchFieldException e) {
        logger.throwing("ModLoader", "AddLocalization", e);
        ThrowException(e);
      }
      if (localized != null)
        localized.putAll(localizedStrings);
      langPack = abn.a().c();
    }

    if ((!texturesAdded) && (paramMinecraft.p != null))
    {
      RegisterAllTextureOverrides(paramMinecraft.p);

      texturesAdded = true;
    }

    long l = 0L;
    Object localObject1;
    if (paramMinecraft.f != null)
    {
      l = paramMinecraft.f.u();
      for (localObject1 = inGameHooks.entrySet().iterator(); ((Iterator)localObject1).hasNext(); ) {
        localObject2 = (Map.Entry)((Iterator)localObject1).next();
        if ((clock == l) && (((Boolean)((Map.Entry)localObject2).getValue()).booleanValue()))
          continue;
        if (!((BaseMod)((Map.Entry)localObject2).getKey()).OnTickInGame(paramFloat, paramMinecraft))
          ((Iterator)localObject1).remove();
      }
    }
    Object localObject2;
    if (paramMinecraft.r != null) {
      for (localObject2 = inGUIHooks.entrySet().iterator(); ((Iterator)localObject2).hasNext(); ) {
        localObject1 = (Map.Entry)((Iterator)localObject2).next();
        if (clock == l) if ((((Boolean)((Map.Entry)localObject1).getValue()).booleanValue() & paramMinecraft.f != null))
            continue;
        if (!((BaseMod)((Map.Entry)localObject1).getKey()).OnTickInGUI(paramFloat, paramMinecraft, paramMinecraft.s)) {
          ((Iterator)localObject2).remove();
        }
      }
    }
    if (clock != l)
      for (localObject2 = keyList.entrySet().iterator(); ((Iterator)localObject2).hasNext(); ) { localEntry1 = (Map.Entry)((Iterator)localObject2).next();
        for (localIterator = ((Map)localEntry1.getValue()).entrySet().iterator(); localIterator.hasNext(); ) { Object localObject3 = localIterator.next();
          Map.Entry localEntry2 = (Map.Entry)localObject3;
          int i = ((ads)localEntry2.getKey()).d;
          boolean bool;
          if (i < 0) {
            i += 100;
            bool = Mouse.isButtonDown(i);
          } else {
            bool = Keyboard.isKeyDown(i);
          }
          boolean[] arrayOfBoolean = (boolean[])(boolean[])localEntry2.getValue();
          int j = arrayOfBoolean[1];
          arrayOfBoolean[1] = bool;
          if ((!bool) || ((j != 0) && (arrayOfBoolean[0] == 0))) {
            continue;
          }
          ((BaseMod)localEntry1.getKey()).KeyboardEvent((ads)localEntry2.getKey());
        }
      }
    Map.Entry localEntry1;
    Iterator localIterator;
    clock = l;
    ld.b();
    ld.a("render");
    ld.a("gameRenderer");
  }

  public static void OpenGUI(xb paramvi, ug paramxe)
  {
    if (!hasInit) {
      init();
      logger.fine("Initialized");
    }
    Minecraft localMinecraft = getMinecraftInstance();
    if (localMinecraft.i != paramvi)
      return;
    if (paramxe != null)
      localMinecraft.a(paramxe);
  }

  public static void PopulateChunk(bs paramej, int paramInt1, int paramInt2, vq paramry)
  {
    if (!hasInit) {
      init();
      logger.fine("Initialized");
    }

    Random localRandom = new Random(paramry.t());
    long l1 = localRandom.nextLong() / 2L * 2L + 1L;
    long l2 = localRandom.nextLong() / 2L * 2L + 1L;
    localRandom.setSeed(paramInt1 * l1 + paramInt2 * l2 ^ paramry.t());

    for (BaseMod localBaseMod : modList)
    {
      if (paramej.c().equals("RandomLevelSource")) localBaseMod.GenerateSurface(paramry, localRandom, paramInt1 << 4, paramInt2 << 4);
      else if (paramej.c().equals("HellRandomLevelSource"))
        localBaseMod.GenerateNether(paramry, localRandom, paramInt1 << 4, paramInt2 << 4);
    }
  }

  private static void readFromClassPath(File paramFile)
    throws FileNotFoundException, IOException
  {
    logger.finer(new StringBuilder().append("Adding mods from ").append(paramFile.getCanonicalPath()).toString());
    ClassLoader localClassLoader = ModLoader.class.getClassLoader();
    Object localObject1;
    Object localObject2;
    String str;
    if ((paramFile.isFile()) && ((paramFile.getName().endsWith(".jar")) || (paramFile.getName().endsWith(".zip")))) {
      logger.finer("Zip found.");
      localObject1 = new FileInputStream(paramFile);
      localObject2 = new ZipInputStream((InputStream)localObject1);
      ZipEntry localZipEntry = null;
      while (true) {
        localZipEntry = ((ZipInputStream)localObject2).getNextEntry();
        if (localZipEntry == null) {
          break;
        }
        str = localZipEntry.getName();
        if ((!localZipEntry.isDirectory()) && (str.startsWith("mod_")) && (str.endsWith(".class")))
          addMod(localClassLoader, str);
      }
      ((InputStream)localObject1).close();
    } else if (paramFile.isDirectory()) {
      localObject1 = ModLoader.class.getPackage();
      if (localObject1 != null) {
        localObject2 = ((Package)localObject1).getName().replace('.', File.separatorChar);
        paramFile = new File(paramFile, (String)localObject2);
      }
      logger.finer("Directory found.");
      localObject2 = paramFile.listFiles();
      if (localObject2 != null)
        for (int i = 0; i < localObject2.length; i++) {
          str = localObject2[i].getName();
          if ((localObject2[i].isFile()) && (str.startsWith("mod_")) && (str.endsWith(".class")))
            addMod(localClassLoader, str);
        }
    }
  }

  private static void readFromModFolder(File paramFile)
    throws IOException, IllegalArgumentException, IllegalAccessException, InvocationTargetException, SecurityException, NoSuchMethodException
  {
    ClassLoader localClassLoader = Minecraft.class.getClassLoader();
    Method localMethod = URLClassLoader.class.getDeclaredMethod("addURL", new Class[] { URL.class });
    localMethod.setAccessible(true);

    if (!paramFile.isDirectory()) {
      throw new IllegalArgumentException("folder must be a Directory.");
    }
    File[] arrayOfFile = paramFile.listFiles();
    Arrays.sort(arrayOfFile);
    File localFile;
    if ((localClassLoader instanceof URLClassLoader)) {
      for (i = 0; i < arrayOfFile.length; i++) {
        localFile = arrayOfFile[i];

        if ((!localFile.isDirectory()) && ((!localFile.isFile()) || ((!localFile.getName().endsWith(".jar")) && (!localFile.getName().endsWith(".zip"))))) {
          continue;
        }
        localMethod.invoke(localClassLoader, new Object[] { localFile.toURI().toURL() });
      }
    }

    for (int i = 0; i < arrayOfFile.length; i++) {
      localFile = arrayOfFile[i];

      if ((!localFile.isDirectory()) && ((!localFile.isFile()) || ((!localFile.getName().endsWith(".jar")) && (!localFile.getName().endsWith(".zip"))))) {
        continue;
      }
      logger.finer(new StringBuilder().append("Adding mods from ").append(localFile.getCanonicalPath()).toString());
      Object localObject1;
      Object localObject2;
      String str;
      if (localFile.isFile()) {
        logger.finer("Zip found.");
        localObject1 = new FileInputStream(localFile);
        localObject2 = new ZipInputStream((InputStream)localObject1);
        ZipEntry localZipEntry = null;
        while (true) {
          localZipEntry = ((ZipInputStream)localObject2).getNextEntry();
          if (localZipEntry == null) {
            break;
          }
          str = localZipEntry.getName();
          if ((!localZipEntry.isDirectory()) && (str.startsWith("mod_")) && (str.endsWith(".class")))
            addMod(localClassLoader, str);
        }
        ((ZipInputStream)localObject2).close();
        ((InputStream)localObject1).close();
      } else if (localFile.isDirectory()) {
        localObject1 = ModLoader.class.getPackage();
        if (localObject1 != null) {
          localObject2 = ((Package)localObject1).getName().replace('.', File.separatorChar);
          localFile = new File(localFile, (String)localObject2);
        }
        logger.finer("Directory found.");
        localObject2 = localFile.listFiles();
        if (localObject2 != null)
          for (int j = 0; j < localObject2.length; j++) {
            str = localObject2[j].getName();
            if ((localObject2[j].isFile()) && (str.startsWith("mod_")) && (str.endsWith(".class")))
              addMod(localClassLoader, str);
          }
      }
    }
  }

  public static ads[] RegisterAllKeys(ads[] paramArrayOfads)
  {
    LinkedList localLinkedList = new LinkedList();
    localLinkedList.addAll(Arrays.asList(paramArrayOfaby));
    for (Map localMap : keyList.values())
      localLinkedList.addAll(localMap.keySet());
    return (ads[])(ads[])localLinkedList.toArray(new ads[0]);
  }

  public static void RegisterAllTextureOverrides(yz paramzh)
  {
    animList.clear();

    Minecraft localMinecraft = getMinecraftInstance();
    for (Iterator localIterator1 = modList.iterator(); localIterator1.hasNext(); ) { localObject1 = (BaseMod)localIterator1.next();
      ((BaseMod)localObject1).RegisterAnimation(localMinecraft);
    }
    Object localObject1;
    for (localIterator1 = animList.iterator(); localIterator1.hasNext(); ) { localObject1 = (sr)localIterator1.next();

      paramzh.a((sr)localObject1);
    }

    for (localIterator1 = overrides.entrySet().iterator(); localIterator1.hasNext(); ) { localObject1 = (Map.Entry)localIterator1.next();
      for (localIterator2 = ((Map)((Map.Entry)localObject1).getValue()).entrySet().iterator(); localIterator2.hasNext(); ) { Object localObject2 = localIterator2.next();
        Map.Entry localEntry = (Map.Entry)localObject2;
        String str = (String)localEntry.getKey();
        int i = ((Integer)localEntry.getValue()).intValue();
        int j = ((Integer)((Map.Entry)localObject1).getKey()).intValue();
        try {
          BufferedImage localBufferedImage = loadImage(paramzh, str);
          ModTextureStatic localModTextureStatic = new ModTextureStatic(i, j, localBufferedImage);

          paramzh.a(localModTextureStatic);
        } catch (Exception localException) {
          logger.throwing("ModLoader", "RegisterAllTextureOverrides", localException);
          ThrowException(localException);
          throw new RuntimeException(localException);
        } } }
    Iterator localIterator2;
  }

  public static void RegisterBlock(oe paramoe)
  {
    RegisterBlock(paramoe, null);
  }

  public static void RegisterBlock(oe paramoe, Class<? extends tw> paramClass)
  {
    try
    {
      if (paramoe == null) {
        throw new IllegalArgumentException("block parameter cannot be null.");
      }
      int i = paramoe.bO;
      tw localtw = null;
      if (paramClass != null) localtw = (tw)paramClass.getConstructor(new Class[] { Integer.TYPE }).newInstance(new Object[] { Integer.valueOf(i - 256) }); else {
        localtw = new tw(i - 256);
      }
      if ((oe.m[i] != null) && (ww.e[i] == null))
        ww.e[i] = localtw;
    } catch (IllegalArgumentException localIllegalArgumentException) {
      logger.throwing("ModLoader", "RegisterBlock", localIllegalArgumentException);
      ThrowException(localIllegalArgumentException);
    } catch (IllegalAccessException localIllegalAccessException) {
      logger.throwing("ModLoader", "RegisterBlock", localIllegalAccessException);
      ThrowException(localIllegalAccessException);
    } catch (SecurityException localSecurityException) {
      logger.throwing("ModLoader", "RegisterBlock", localSecurityException);
      ThrowException(localSecurityException);
    } catch (InstantiationException localInstantiationException) {
      logger.throwing("ModLoader", "RegisterBlock", localInstantiationException);
      ThrowException(localInstantiationException);
    } catch (InvocationTargetException localInvocationTargetException) {
      logger.throwing("ModLoader", "RegisterBlock", localInvocationTargetException);
      ThrowException(localInvocationTargetException);
    } catch (NoSuchMethodException localNoSuchMethodException) {
      logger.throwing("ModLoader", "RegisterBlock", localNoSuchMethodException);
      ThrowException(localNoSuchMethodException);
    }
  }

  public static void RegisterEntityID(Class<? extends ms> paramClass, String paramString, int paramInt)
  {
    try
    {
      method_RegisterEntityID.invoke(null, new Object[] { paramClass, paramString, Integer.valueOf(paramInt) });
    } catch (IllegalArgumentException localIllegalArgumentException) {
      logger.throwing("ModLoader", "RegisterEntityID", localIllegalArgumentException);
      ThrowException(localIllegalArgumentException);
    } catch (IllegalAccessException localIllegalAccessException) {
      logger.throwing("ModLoader", "RegisterEntityID", localIllegalAccessException);
      ThrowException(localIllegalAccessException);
    } catch (InvocationTargetException localInvocationTargetException) {
      logger.throwing("ModLoader", "RegisterEntityID", localInvocationTargetException);
      ThrowException(localInvocationTargetException);
    }
  }

  public static void RegisterEntityID(Class<? extends ms> entityClass, String entityName, int id, int background, int foreground)
  {
    RegisterEntityID(entityClass, entityName, id);

    yr.a.put(Integer.valueOf(id), new he(id, background, foreground));
  }

  public static void RegisterKey(BaseMod paramBaseMod, ads paramaby, boolean paramBoolean)
  {
    Object localObject = (Map)keyList.get(paramBaseMod);
    if (localObject == null)
      localObject = new HashMap();
    ((Map)localObject).put(paramaby, new boolean[] { paramBoolean });
    keyList.put(paramBaseMod, localObject);
  }

  public static void RegisterTileEntity(Class<? extends bq> paramClass, String paramString)
  {
    RegisterTileEntity(paramClass, paramString, null);
  }

  public static void RegisterTileEntity(Class<? extends kf> tileEntityClass, String id)
  {
    RegisterTileEntity(tileEntityClass, id, null);
  }

  public static void RegisterTileEntity(Class<? extends kf> paramClass, String paramString, yu paramyu)
  {
    try
    {
      method_RegisterTileEntity.invoke(null, new Object[] { paramClass, paramString });
      if (paramyu != null) {
        aai localah = aai.a;

        Map localMap = (Map)field_TileEntityRenderers.get(localaai);
        localMap.put(paramClass, paramyu);
        paramyu.a(localaai);
      }
    } catch (IllegalArgumentException localIllegalArgumentException) {
      logger.throwing("ModLoader", "RegisterTileEntity", localIllegalArgumentException);
      ThrowException(localIllegalArgumentException);
    } catch (IllegalAccessException localIllegalAccessException) {
      logger.throwing("ModLoader", "RegisterTileEntity", localIllegalAccessException);
      ThrowException(localIllegalAccessException);
    } catch (InvocationTargetException localInvocationTargetException) {
      logger.throwing("ModLoader", "RegisterTileEntity", localInvocationTargetException);
      ThrowException(localInvocationTargetException);
    }
  }

  public static void RemoveSpawn(Class<? extends aar> paramClass, aah paramaah)
  {
    RemoveSpawn(paramClass, paramaah, null);
  }

  public static void RemoveSpawn(Class<? extends aar> paramClass, aah paramaah, zp[] paramArrayOfsr)
  {
    if (paramClass == null) {
      throw new IllegalArgumentException("entityClass cannot be null");
    }
    if (paramaah == null) {
      throw new IllegalArgumentException("spawnList cannot be null");
    }
    if (paramArrayOfsr == null)
      paramArrayOfsr = standardBiomes;
    Iterator localIterator;
    for (int i = 0; i < paramArrayOfsr.length; i++)
    {
      List localList = paramArrayOfsr[i].a(paramaah);

      if (localList != null)
        for (localIterator = localList.iterator(); localIterator.hasNext(); ) {
          bd localbd = (bd)localIterator.next();
          if (localbd.a == paramClass)
            localIterator.remove();
        }
    }
  }

  public static void RemoveSpawn(String paramString, aah paramaah)
  {
    RemoveSpawn(paramString, paramaah, null);
  }

  public static void RemoveSpawn(String paramString, aah paramaah, zp[] paramArrayOfsr)
  {
    Class localClass = (Class)classMap.get(paramString);
    if ((localClass != null) && (aar.class.isAssignableFrom(localClass)))
      RemoveSpawn(localClass, paramaah, paramArrayOfsr);
  }

  public static boolean RenderBlockIsItemFull3D(int paramInt)
  {
    if (!blockSpecialInv.containsKey(Integer.valueOf(paramInt)))
      return paramInt == 16;
    return ((Boolean)blockSpecialInv.get(Integer.valueOf(paramInt))).booleanValue();
  }

  public static void RenderInvBlock(uc paramuc, oe paramoe, int paramInt1, int paramInt2)
  {
    BaseMod localBaseMod = (BaseMod)blockModels.get(Integer.valueOf(paramInt2));
    if (localBaseMod == null)
      return;
    localBaseMod.RenderInvBlock(paramuc, paramoe, paramInt1, paramInt2);
  }

  public static boolean RenderWorldBlock(uc paramuc, aiw paramaiw, iint paramInt1, int paramInt2, int paramInt3, oe paramoe, int paramInt4)
  {
    BaseMod localBaseMod = (BaseMod)blockModels.get(Integer.valueOf(paramInt4));
    if (localBaseMod == null)
      return false;
    return localBaseMod.RenderWorldBlock(paramuc, paramaiw, paramInt1, paramInt2, paramInt3, paramoe, paramInt4);
  }

  public static void saveConfig()
    throws IOException
  {
    cfgdir.mkdir();

    if ((!cfgfile.exists()) && (!cfgfile.createNewFile())) {
      return;
    }
    if (cfgfile.canWrite()) {
      FileOutputStream localFileOutputStream = new FileOutputStream(cfgfile);
      props.store(localFileOutputStream, "ModLoader Config");
      localFileOutputStream.close();
    }
  }

  public static void SetInGameHook(BaseMod paramBaseMod, boolean paramBoolean1, boolean paramBoolean2)
  {
    if (paramBoolean1) inGameHooks.put(paramBaseMod, Boolean.valueOf(paramBoolean2)); else
      inGameHooks.remove(paramBaseMod);
  }

  public static void SetInGUIHook(BaseMod paramBaseMod, boolean paramBoolean1, boolean paramBoolean2)
  {
    if (paramBoolean1) inGUIHooks.put(paramBaseMod, Boolean.valueOf(paramBoolean2)); else
      inGUIHooks.remove(paramBaseMod);
  }

  public static <T, E> void setPrivateValue(Class<? super T> paramClass, T paramT, int paramInt, E paramE)
    throws IllegalArgumentException, SecurityException, NoSuchFieldException
  {
    try
    {
      Field localField = paramClass.getDeclaredFields()[paramInt];
      localField.setAccessible(true);
      int i = field_modifiers.getInt(localField);
      if ((i & 0x10) != 0)
        field_modifiers.setInt(localField, i & 0xFFFFFFEF);
      localField.set(paramT, paramE);
    } catch (IllegalAccessException localIllegalAccessException) {
      logger.throwing("ModLoader", "setPrivateValue", localIllegalAccessException);
      ThrowException("An impossible error has occured!", localIllegalAccessException);
    }
  }

  public static <T, E> void setPrivateValue(Class<? super T> paramClass, T paramT, String paramString, E paramE)
    throws IllegalArgumentException, SecurityException, NoSuchFieldException
  {
    try
    {
      Field localField = paramClass.getDeclaredField(paramString);
      int i = field_modifiers.getInt(localField);
      if ((i & 0x10) != 0)
        field_modifiers.setInt(localField, i & 0xFFFFFFEF);
      localField.setAccessible(true);
      localField.set(paramT, paramE);
    } catch (IllegalAccessException localIllegalAccessException) {
      logger.throwing("ModLoader", "setPrivateValue", localIllegalAccessException);
      ThrowException("An impossible error has occured!", localIllegalAccessException);
    }
  }

  private static void setupProperties(Class<? extends BaseMod> paramClass) throws IllegalArgumentException, IllegalAccessException, IOException, SecurityException, NoSuchFieldException
  {
    List fieldList = new LinkedList();
    Properties localProperties = new Properties();
    int currentHash = 0;
    int cfgHash = 0;

    File localFile = new File(cfgdir, new StringBuilder().append(paramClass.getName()).append(".cfg").toString());
    if ((localFile.exists()) && (localFile.canRead())) {
      localProperties.load(new FileInputStream(localFile));
    }
    if (modprops.containsKey("checksum")) {
      cfgHash = Integer.parseInt(modprops.getProperty("checksum"), 36);
    }
    for (Field field : mod.getDeclaredFields()) {
      if (((field.getModifiers() & 0x8) != 0) && (field.isAnnotationPresent(MLProp.class))) {
        fieldList.add(field);
        Object currentvalue = field.get(null);
        currentHash += currentvalue.hashCode();
      }
    }

    StringBuilder localStringBuilder1 = new StringBuilder();

    for (Field localField : paramClass.getFields()) {
      if (((localField.getModifiers() & 0x8) != 0) && (localField.isAnnotationPresent(MLProp.class))) {
        Class localClass = localField.getType();
        MLProp localMLProp = (MLProp)localField.getAnnotation(MLProp.class);
        String str1 = localMLProp.name().length() == 0 ? localField.getName() : localMLProp.name();
        Object localObject1 = localField.get(null);

        StringBuilder localStringBuilder2 = new StringBuilder();
        if (localMLProp.min() != (-1.0D / 0.0D))
          localStringBuilder2.append(String.format(",>=%.1f", new Object[] { Double.valueOf(localMLProp.min()) }));
        if (localMLProp.max() != (1.0D / 0.0D)) {
          localStringBuilder2.append(String.format(",<=%.1f", new Object[] { Double.valueOf(localMLProp.max()) }));
        }
        StringBuilder localStringBuilder3 = new StringBuilder();
        if (localMLProp.info().length() > 0) {
          localStringBuilder3.append(" -- ");
          localStringBuilder3.append(localMLProp.info());
        }

        localStringBuilder1.append(String.format("%s (%s:%s%s)%s\n", new Object[] { str1, localClass.getName(), localObject1, localStringBuilder2, localStringBuilder3 }));

        if ((cfgHash == currentHash) && (localProperties.containsKey(keystr1
          String str2 = localProperties.getProperty(str1);

          Object localObject2 = null;
          if (localClass.isAssignableFrom(String.class)) localObject2 = str2;
          else if (localClass.isAssignableFrom(Integer.TYPE)) localObject2 = Integer.valueOf(Integer.parseInt(str2));
          else if (localClass.isAssignableFrom(Short.TYPE)) localObject2 = Short.valueOf(Short.parseShort(str2));
          else if (localClass.isAssignableFrom(Byte.TYPE)) localObject2 = Byte.valueOf(Byte.parseByte(str2));
          else if (localClass.isAssignableFrom(Boolean.TYPE)) localObject2 = Boolean.valueOf(Boolean.parseBoolean(str2));
          else if (localClass.isAssignableFrom(Float.TYPE)) localObject2 = Float.valueOf(Float.parseFloat(str2));
          else if (localClass.isAssignableFrom(Double.TYPE)) {
            localObject2 = Double.valueOf(Double.parseDouble(str2));
          }
          if (localObject2 != null) {
            if ((localObject2 instanceof Number)) {
              double d = ((Number)localObject2).doubleValue();
              if ((localMLProp.min() != (-1.0D / 0.0D)) && (d < localMLProp.min()))
                continue;
              if ((localMLProp.max() != (1.0D / 0.0D)) && (d > localMLProp.max())) {
                continue;
              }
            }
            logger.finer(new StringBuilder().append(str1).append(" set to ").append(localObject2).toString());
            if (!((Object)localObject2).equals(localObject1))
              localField.set(null, localObject2);
          }
        } else {
          logger.finer(new StringBuilder().append(str1).append(" not in config, using default: ").append(localObject1).toString());
          localProperties.setProperty(str1, localObject1.toString());
        }
      }
    }

    if ((!localProperties.isEmpty()) && ((localFile.exists()) || (localFile.createNewFile())) && (localFile.canWrite()))
      localProperties.store(new FileOutputStream(localFile), localStringBuilder1.toString());
  }

  public static void TakenFromCrafting(xb paramxb, yq paramyq, ic paramic)
  {
    for (BaseMod localBaseMod : modList)
      localBaseMod.TakenFromCrafting(paramxb, paramyq, paramic);
  }

  public static void TakenFromFurnace(xb paramxb, yq paramyq)
  {
    for (BaseMod localBaseMod : modList)
      localBaseMod.TakenFromFurnace(paramxb, paramyq);
  }

  public static void ThrowException(String paramString, Throwable paramThrowable)
  {
    Minecraft localMinecraft = getMinecraftInstance();
    if (localMinecraft != null) localMinecraft.a(new im(paramString, paramThrowable)); else
      throw new RuntimeException(paramThrowable);
  }

  private static void ThrowException(Throwable paramThrowable)
  {
    ThrowException("Exception occured in ModLoader", paramThrowable);
  }
}