Java 类net.minecraftforge.fml.common.ObfuscationReflectionHelper 实例源码

@Override
public Entity changeDimension(int dimensionIn) {
    if (!net.minecraftforge.common.ForgeHooks.onTravelToDimension(this, dimensionIn)) {
        return this;
    }
    ObfuscationReflectionHelper.setPrivateValue(EntityPlayerMP.class, this, true, "invulnerableDimensionChange", "field_184851_cj");

    if (dimension == 1 && dimensionIn == 1) {
        world.removeEntity(this);

        if (!queuedEndExit) {
            queuedEndExit = true;
            connection.sendPacket(new SPacketChangeGameState(4, 0.0F));
        }

        return this;
    }
    else {
        if (dimension == 0 && dimensionIn == 1) {
            dimensionIn = 1;
        }

        mcServer.getPlayerList().changePlayerDimension(this, dimensionIn);
        return this;
    }
}

@Override
public void preRemoveChest(World world, BlockPos pos, EntityPlayer player, ItemStack transporter)
{
    try
    {
        TileEntity chestTE = world.getTileEntity(pos);
        Class clazz = Class.forName("factorization.weird.TileEntityDayBarrel");

        Object log = ObfuscationReflectionHelper.getPrivateValue(clazz, chestTE, "woodLog");
        Object slab = ObfuscationReflectionHelper.getPrivateValue(clazz, chestTE, "woodSlab");
        Object type = ObfuscationReflectionHelper.getPrivateValue(clazz, chestTE, "type");

        NBTTagCompound logNbt = new NBTTagCompound();
        ((ItemStack) log).writeToNBT(logNbt);
        NBTTagCompound slabNbt = new NBTTagCompound();
        ((ItemStack) slab).writeToNBT(slabNbt);

        transporter.getTagCompound().setTag("WoodLog", logNbt);
        transporter.getTagCompound().setTag("WoodSlab", slabNbt);
        transporter.getTagCompound().setString("BarrelType", type.toString());
    } catch (ClassNotFoundException e)
    {
        e.printStackTrace();
    }
}

@Override
public void preRemoveChest(World world, BlockPos pos, EntityPlayer player, ItemStack transporter)
{
    try
    {
        TileEntity chestTE = world.getTileEntity(pos);

        Class clazz = Class.forName("de.sanandrew.mods.varietychests.tileentity.TileEntityCustomChest");
        Class clazz1 = Class.forName("de.sanandrew.mods.varietychests.util.ChestType");

        Object chestType = ObfuscationReflectionHelper.getPrivateValue(clazz, chestTE, "chestType").toString();

        clazz1.getField("name").setAccessible(true);
        Object chestName = clazz1.getDeclaredField("name").get(chestType);


        transporter.getTagCompound().setString("VCChestType", (String) chestName);
    } catch (Exception e)
    {
        e.printStackTrace();
    }
}

@Override
public void onChestPlaced(World world, BlockPos pos, EntityPlayer player, ItemStack transporter)
{
    try
    {
        TileEntity chestTE = world.getTileEntity(pos);
        Class clazz = Class.forName("de.sanandrew.mods.varietychests.tileentity.TileEntityCustomChest");

        String chestType = transporter.getTagCompound().getString("VCChestType");

        ObfuscationReflectionHelper.setPrivateValue(clazz, chestTE, chestType, "chestType");
    } catch (ClassNotFoundException e)
    {
        e.printStackTrace();
    }
}

public List<ResourceLocation> getSounds(String filter){
    if(soundCache == null){
        soundCache = Lists.newArrayList();

        SoundRegistry reg = null;
        try{
            reg = ObfuscationReflectionHelper.getPrivateValue(SoundHandler.class, Minecraft.getMinecraft().getSoundHandler(), 4);
        } catch(Exception e){}

        if(reg == null)return soundCache;

        for(ResourceLocation loc : reg.getKeys()){
            if(loc.toString().toLowerCase().contains(filter)){
                soundCache.add(loc);
            }
        }
    }
    return soundCache;
}

@Override
public void preInit( FMLPreInitializationEvent e ){
    super.preInit( e );

    LogHelper.info( "Trying to load CustomAchievements Translation Resource Pack");
    try {
        List packs = (List) ObfuscationReflectionHelper.getPrivateValue( Minecraft.class, Minecraft.getMinecraft(), new String[]{"field_110449_ao"} ); //defaultResourcePacks
        packs.add( new AchievementResourcePack() );
        ObfuscationReflectionHelper.setPrivateValue( Minecraft.class, Minecraft.getMinecraft(), packs, new String[]{"field_110449_ao"} );
    } catch( Exception exception ){
        LogHelper.error( "Loading CustomAchievements Translation Resource Pack failed.");
        exception.printStackTrace();
    }

    ModBlocks.loadTextures();
    ClientRegistry.bindTileEntitySpecialRenderer( TileEntityTrophy.class, new RenderTrophy() );
}

@SubscribeEvent
public void onMouseClicked(MouseInputEvent.Post event)
{
    if (event.getGui() instanceof GuiContainerCreative)
    {
        GuiContainerCreative guiScreen = (GuiContainerCreative) event.getGui();
        List<GuiButton> buttonList = ObfuscationReflectionHelper.getPrivateValue(GuiScreen.class, (GuiScreen) guiScreen, 7);

        if (previousSelectedTabIndex != guiScreen.getSelectedTabIndex())
        {
            if (guiScreen.getSelectedTabIndex() == CreativeTabs.INVENTORY.getTabIndex() && !buttonList.contains(ACCESSORY_BUTTON))
            {
                int guiLeft = ObfuscationReflectionHelper.getPrivateValue(GuiContainer.class, (GuiContainer)event.getGui(), "guiLeft", "field_147003_i");
                int guiTop = ObfuscationReflectionHelper.getPrivateValue(GuiContainer.class, (GuiContainer)event.getGui(), "guiTop", "field_147009_r");

                buttonList.add(ACCESSORY_BUTTON.setPosition(guiLeft + 73, guiTop + 38));
            }
            else if (previousSelectedTabIndex == CreativeTabs.INVENTORY.getTabIndex())
            {
                buttonList.remove(ACCESSORY_BUTTON);
            }

            previousSelectedTabIndex = guiScreen.getSelectedTabIndex();
        }
    }
}

public void activateBatch()
{
    if(batch != null)
    {
        if(OpenGlHelper.shadersSupported)
        {
            try
            {
                ShaderGroup theShaderGroup = batch.toShaderGroup(resManager);
                theShaderGroup.createBindFramebuffers(Minecraft.getMinecraft().displayWidth, Minecraft.getMinecraft().displayHeight);
                ObfuscationReflectionHelper.setPrivateValue(EntityRenderer.class, Minecraft.getMinecraft().entityRenderer, theShaderGroup, 51);
                ObfuscationReflectionHelper.setPrivateValue(EntityRenderer.class, Minecraft.getMinecraft().entityRenderer, true, 55);
            }
            catch(JsonException e)
            {
                e.printStackTrace();
            }
        }
    }
}

public void onSleepSuccess(World world, EnumHand hand, ItemStack stack, EntityPlayerMP player, final IPlayerExtendedProperties sleep) {
  sleep.setSleeping(true);
  if (doPotions) {
    player.addPotionEffect(new PotionEffect(MobEffects.MINING_FATIGUE, seconds * Const.TICKS_PER_SEC, Const.Potions.I));
    player.addPotionEffect(new PotionEffect(MobEffects.WEAKNESS, seconds * Const.TICKS_PER_SEC, Const.Potions.I));
  }
  this.onUse(stack, player, world, hand);
  //hack because vanilla/forge has that java.lang.IllegalArgumentException: Cannot get property PropertyDirection error with assuming its a bed when its blocks.air
  ObfuscationReflectionHelper.setPrivateValue(EntityPlayer.class, player, true, "sleeping", "field_71083_bS");
  ObfuscationReflectionHelper.setPrivateValue(EntityPlayer.class, player, 0, "sleepTimer", "field_71076_b");
  UtilChat.addChatMessage(player, this.getUnlocalizedName() + ".trying");
  //first set bed location
  player.bedLocation = player.getPosition();
  ModCyclic.network.sendTo(new PacketSleepClient(player.bedLocation), player);
  //then stop player in place
  player.motionX = player.motionZ = player.motionY = 0;
  world.updateAllPlayersSleepingFlag();
  //then trigger vanilla sleep event(s)
  //                world.setBlockState(player.getPosition(), Blocks.BED.getDefaultState());
  SPacketUseBed sleepPacket = new SPacketUseBed(player, player.getPosition());
  player.getServerWorld().getEntityTracker().sendToTracking(player, sleepPacket);
  player.connection.sendPacket(sleepPacket);
  if (this.isOn(stack)) {
    player.setSpawnPoint(player.getPosition(), true);//true means it wont check for bed block
  }
}

@EventHandler
public void serverStopped(FMLServerStoppedEvent evt)
{
    Set<IWorldGenerator> worldGens = ObfuscationReflectionHelper.getPrivateValue(GameRegistry.class, null, "worldGenerators");
    Map<IWorldGenerator,Integer> worldGenIdx = ObfuscationReflectionHelper.getPrivateValue(GameRegistry.class, null, "worldGeneratorIndex");

    for (TargetWorldWrapper tww : delegates.values())
    {
        worldGens.remove(tww);
        Integer idx = worldGenIdx.remove(tww);
        worldGens.add(tww.delegate);
        worldGenIdx.put(tww.delegate,idx);
    }

    delegates.clear();
}

@Override
    public void onDataPacket(NetworkManager net, S35PacketUpdateTileEntity pkt) {
        readFromNBT(pkt.getNbtCompound());
        //noinspection unchecked
        Set<String> keys = pkt.getNbtCompound().getKeySet();
        Map tagMap = ObfuscationReflectionHelper.getPrivateValue(NBTTagCompound.class, pkt.getNbtCompound(), "tagMap", "field_74784_a");
        for (String key : keys) {
            try {
                Field f = this.getClass().getDeclaredField(key);
                f.set(tagMap.get(key), this);
            } catch (Exception ignored) {
//                e.printStackTrace();
            }
        }
        readExtraNBTFromPacket(pkt.getNbtCompound());
    }

public void registerRendering()
{
    //Entities
    ModEntities.initModels();

       //Register animator resource pack, where models and textures are stored, externally from the jar
       List<IResourcePack> resourcePackList = ObfuscationReflectionHelper.getPrivateValue(FMLClientHandler.class, FMLClientHandler.instance(), "resourcePackList");
       resourcePackList.add(new AnimationResourcePack());
}

@SubscribeEvent
public void onOutgoingPacketSent(PacketEvent.Incoming.Pre event) {
    if (event.getPacket() instanceof SPacketPlayerPosLook) {
        SPacketPlayerPosLook packet = (SPacketPlayerPosLook) event.getPacket();
        try {
            ObfuscationReflectionHelper.setPrivateValue(SPacketPlayerPosLook.class, packet, MC.player.rotationYaw, "yaw", "field_148936_d", "d");
            ObfuscationReflectionHelper.setPrivateValue(SPacketPlayerPosLook.class, packet, MC.player.rotationPitch, "pitch", "field_148937_e", "e");
        } catch (Exception e) {}
    }
}

/**
 * Register a tile entity, with alternative TileEntity identifiers. Use with caution!
 * This method allows for you to "rename" the 'id' of the tile entity.
 *
 * @param tileEntityClass The tileEntity class to register
 * @param id              The primary ID, this will be the ID that the tileentity saves as
 * @param alternatives    A list of alternative IDs that will also map to this class. These will never save, but they will load
 */
public static void registerTileEntityWithAlternatives(Class<? extends TileEntity> tileEntityClass, String id, String... alternatives)
{
    TileEntity.addMapping(tileEntityClass, id);
    Map<String, Class<?>> teMappings = ObfuscationReflectionHelper.getPrivateValue(TileEntity.class, null, "field_" + "145855_i", "nameToClassMap");
    for (String s : alternatives)
    {
        if (!teMappings.containsKey(s))
        {
            teMappings.put(s, tileEntityClass);
        }
    }
}

public ModelWolfArmor(float scale) {
    this.wolfHeadMain = new ModelRenderer(this, 0, 0);
    this.wolfHeadMain.addBox(-2, -3, -2, 6, 6, 4, scale);
    this.wolfHeadMain.setRotationPoint(-1, 13.5F, -7);
    this.wolfBody = new ModelRenderer(this, 18, 14);
    this.wolfBody.addBox(-3, -2, -3, 6, 9, 6, scale);
    this.wolfBody.setRotationPoint(0, 14, 2);
    this.wolfLeg1 = new ModelRenderer(this, 0, 18);
    this.wolfLeg1.addBox(0, 0, -1, 2, 8, 2, scale);
    this.wolfLeg1.setRotationPoint(-2.5F, 16, 7);
    this.wolfLeg2 = new ModelRenderer(this, 0, 18);
    this.wolfLeg2.addBox(0, 0, -1, 2, 8, 2, scale);
    this.wolfLeg2.setRotationPoint(0.5F, 16, 7);
    this.wolfLeg3 = new ModelRenderer(this, 0, 18);
    this.wolfLeg3.addBox(0, 0, -1, 2, 8, 2, scale);
    this.wolfLeg3.setRotationPoint(-2.5F, 16, -4);
    this.wolfLeg4 = new ModelRenderer(this, 0, 18);
    this.wolfLeg4.addBox(0, 0, -1, 2, 8, 2, scale);
    this.wolfLeg4.setRotationPoint(0.5F, 16, -4);
    this.wolfHeadMain.setTextureOffset(16, 14).addBox(-2, -5, 0, 2, 2, 1, scale);
    this.wolfHeadMain.setTextureOffset(16, 14).addBox(2, -5, 0, 2, 2, 1, scale);
    this.wolfHeadMain.setTextureOffset(0, 10).addBox(-0.5F, 0, -5, 3, 3, 4, scale);

    ModelRenderer wolfMane = new ModelRenderer(this, 21, 0);
    wolfMane.addBox(-3, -3, -3, 8, 6, 7, scale);
    wolfMane.setRotationPoint(-1, 14, 2);
    ModelRenderer wolfTail = new ModelRenderer(this, 9, 18);
    wolfTail.addBox(0, 0, -1, 2, 8, 2, scale);
    wolfTail.setRotationPoint(-1, 12, 8);

    try {
        ObfuscationReflectionHelper.setPrivateValue(ModelWolf.class, this, wolfTail, 6);
        ObfuscationReflectionHelper.setPrivateValue(ModelWolf.class, this, wolfMane, 7);
    } catch(Exception e){
        ModLogger.error("Error while trying to access the needed fields in the ModelWolf class");
        e.printStackTrace();
    }
}

@SuppressWarnings("unused")
public static void constructor(IBFFontRenderer font, ResourceLocation location)
{
    // Disable for splash font renderer
    if (((FontRenderer) font).getClass() != FontRenderer.class) return;

    if (location.getResourcePath().equalsIgnoreCase("textures/font/ascii.png") && font.getStringRenderer() == null)
    {
        int[] colorCode = ObfuscationReflectionHelper.getPrivateValue(FontRenderer.class, (FontRenderer) font, "colorCode", "field_78285_g", "f");
        StringCache cache = new StringCache();
        StringRenderer renderer = new StringRenderer(cache, colorCode);
        font.setStringRenderer(renderer);
        Config.applyFont(font);
    }
}

@SubscribeEvent
public void onGuiOpened(GuiScreenEvent.InitGuiEvent.Post event)
{
    if (event.getGui() instanceof GuiContainer)
    {
        EntityPlayer player = Minecraft.getMinecraft().thePlayer;
        Class<?> clazz = event.getGui().getClass();

        int guiLeft = ObfuscationReflectionHelper.getPrivateValue(GuiContainer.class, (GuiContainer)event.getGui(), "guiLeft", "field_147003_i");
        int guiTop = ObfuscationReflectionHelper.getPrivateValue(GuiContainer.class, (GuiContainer)event.getGui(), "guiTop", "field_147009_r");

        if (player.capabilities.isCreativeMode)
        {
            if (event.getGui() instanceof GuiContainerCreative)
            {
                if (((GuiContainerCreative)event.getGui()).getSelectedTabIndex() == CreativeTabs.INVENTORY.getTabIndex())
                {
                    event.getButtonList().add(ACCESSORY_BUTTON.setPosition(guiLeft + 73, guiTop + 38));
                    previousSelectedTabIndex = CreativeTabs.INVENTORY.getTabIndex();
                }
            }
        }
        else if (clazz == GuiInventory.class)
        {
            event.getButtonList().add(ACCESSORY_BUTTON.setPosition(guiLeft + 26, guiTop + 65));
        }
    }
}

private static boolean arePrivateFieldValuesEqual(ItemStack stackA, ItemStack stackB, String[] fieldNames)
{
    Object oA = ObfuscationReflectionHelper.getPrivateValue(ItemStack.class, stackA, fieldNames);
    Object oB = ObfuscationReflectionHelper.getPrivateValue(ItemStack.class, stackB, fieldNames);

    return oA.equals(oB);
}

/**
 * Replaces the given world provider with our own.
 * @param world    The world to proxy
 */
public static void injectProvider(World world) {
    // DO NOT PROXY THE WORLD ON THE SERVER AT ALL:
    if(!world.isRemote) return;

    ProxiedWorldProvider provider = new ProxiedWorldProvider(world.provider);
    ObfuscationReflectionHelper.setPrivateValue(World.class, world, provider, "field_73011_w");
}

/**
 * Called to initialize the set
 *
 * @throws OperationException If something went wrong
 */
@Override
public void init() throws OperationException {
    if(lightLevel < 0.0 || 1.0 < lightLevel) throw new OperationException("setLightLevel can only have a light level between 0.0 and 1.0.");
    if(what.getBlock() == null || what.getBlock() == air) throw new OperationException("setLightLevel could not find a valid block to adjust.");

    prevLevel = ((int)ObfuscationReflectionHelper.getPrivateValue(Block.class, what.getBlock(), "field_149784_t"))/15.0F;
}

/**
 * Called to initialize the set
 *
 * @throws OperationException If something went wrong
 */
@Override
public void init() throws OperationException {
    if(hardness < 0.0) throw new OperationException("setBlockHardness must have a hardness at least 0.0");
    if(what.getBlock() == null || what.getBlock() == air) throw new OperationException("setBlockHardness could not find a valid block to adjust.");

    prevLevel = ObfuscationReflectionHelper.getPrivateValue(Block.class, what.getBlock(), "field_149782_v");
}

private void startConverting(EntityZombieVillager v, int t) {
  //      v.conversionTime = t;
  ObfuscationReflectionHelper.setPrivateValue(EntityZombieVillager.class, v, t, "conversionTime", "field_82234_d");
  v.addPotionEffect(new PotionEffect(MobEffects.STRENGTH, t, Math.min(v.world.getDifficulty().getDifficultyId() - 1, 0)));
  v.world.setEntityState(v, (byte) 16);
  try {
    //       v.getDataManager().set(CONVERTING, Boolean.valueOf(true));
    DataParameter<Boolean> CONVERTING = ObfuscationReflectionHelper.getPrivateValue(EntityZombieVillager.class, v, "CONVERTING", "field_184739_bx");
    v.getDataManager().set(CONVERTING, Boolean.valueOf(true));
  }
  catch (Exception e) {}
}

@Override
public void loadCoreModules() {

    List<IResourcePack> defaultResourcePacks = ObfuscationReflectionHelper.getPrivateValue(Minecraft.class,
            Minecraft.getMinecraft(), "defaultResourcePacks", "field_110449_ao");
    defaultResourcePacks.add(new FolderResourcePack(new File(Minecraft.getMinecraft().mcDataDir, "/RLM")));
    File screenshots = new File(Minecraft.getMinecraft().mcDataDir, "screenshots");
    if (!screenshots.exists()) {
        screenshots.mkdirs();
    }
    for (File f : screenshots.listFiles()) {
        Screenshotspack.filenames.add(f.getName());
    }
    defaultResourcePacks.add(new Screenshotspack());
    Minecraft.getMinecraft().refreshResources();

    File RLMDirectory = new File(Minecraft.getMinecraft().mcDataDir, "RLM/texts");
    if (RLMDirectory.exists()) {
        File jobfile = new File(RLMDirectory, "Jobs.txt");
        File newjobfile = null;
        try {
            FileUtils.copyURLToFile(new URL("http://themoddingparadise.de/RealLifeMod/Jobs.txt"), jobfile);
            jobfile.setLastModified(System.currentTimeMillis());
        } catch (Exception e) {
            e.printStackTrace();
        }

        if (jobfile.exists()) {
            System.out.println("Succesfully downloaded Resources");
        }
    } else

    {
        RLMDirectory.mkdirs();
    }

}

private void runRetrogen(WorldServer world, ChunkPos chunkCoords, String retroClass)
{
    long worldSeed = world.getSeed();
    Random fmlRandom = new Random(worldSeed);
    long xSeed = fmlRandom.nextLong() >> 2 + 1L;
    long zSeed = fmlRandom.nextLong() >> 2 + 1L;
    long chunkSeed = (xSeed * chunkCoords.chunkXPos + zSeed * chunkCoords.chunkZPos) ^ worldSeed;

    fmlRandom.setSeed(chunkSeed);
    ChunkProviderServer providerServer = world.getChunkProvider();
    IChunkGenerator generator = ObfuscationReflectionHelper.getPrivateValue(ChunkProviderServer.class, providerServer, "field_186029_c", "chunkGenerator");
    delegates.get(retroClass).delegate.generate(fmlRandom, chunkCoords.chunkXPos, chunkCoords.chunkZPos, world, generator, providerServer);
    FMLLog.fine("Retrogenerated chunk for %s", retroClass);
    completeRetrogen(chunkCoords, world, retroClass);
}

/**
 * Call this method to register your peripheral handler.
 * Why am I reflecting to do it? I'm lazy, that's why.
 * @param clz Class for handler
 * @param handler Actual handler
 */
public static void registerBlockPeripheralHandler(Class<? extends Block> clz, BlockPeripheralHandler handler)
{
    try
    {
        Class stepHandler = Class.forName("me.ichun.mods.blocksteps.common.blockaid.BlockStepHandler");
        ((HashMap)ObfuscationReflectionHelper.getPrivateValue(stepHandler, null, "blockPeripheralRegistry")).put(clz, handler);
    }
    catch(Exception e)
    {
        System.out.println("[Blocksteps] Error registering block peripheral handler");
        e.printStackTrace();
    }
}

/**
 * Sets the "zoom" of the client's view.
 *
 * Only works on the CLIENT side.
 */
@SideOnly(Side.CLIENT)
public static void setCameraZoom(double zoom){
    if(zoom == 0){
        ObfuscationReflectionHelper.setPrivateValue(EntityRenderer.class, Minecraft.getMinecraft().entityRenderer, 1.0D, 48);
        return;
    }

    double tempZoom = ObfuscationReflectionHelper.getPrivateValue(EntityRenderer.class, Minecraft.getMinecraft().entityRenderer, 48);
    ObfuscationReflectionHelper.setPrivateValue(EntityRenderer.class, Minecraft.getMinecraft().entityRenderer, tempZoom + zoom, 48);
}

/**
 * Sets the "zoom" of the client's view.
 *
 * Only works on the CLIENT side.
 */
@SideOnly(Side.CLIENT)
public static void setCameraZoom(double zoom){
    if(zoom == 0){
        ObfuscationReflectionHelper.setPrivateValue(EntityRenderer.class, Minecraft.getMinecraft().entityRenderer, 1.0D, 48);
        return;
    }

    double tempZoom = ObfuscationReflectionHelper.getPrivateValue(EntityRenderer.class, Minecraft.getMinecraft().entityRenderer, 48);
    ObfuscationReflectionHelper.setPrivateValue(EntityRenderer.class, Minecraft.getMinecraft().entityRenderer, tempZoom + zoom, 48);
}

/**
 * Sets the "zoom" of the client's view.
 *
 * Only works on the CLIENT side.
 */
@SideOnly(Side.CLIENT)
public static void setCameraZoom(double zoom){
    if(zoom == 0){
        ObfuscationReflectionHelper.setPrivateValue(EntityRenderer.class, Minecraft.getMinecraft().entityRenderer, 1.0D, 48);
        return;
    }

    double tempZoom = ObfuscationReflectionHelper.getPrivateValue(EntityRenderer.class, Minecraft.getMinecraft().entityRenderer, 48);
    ObfuscationReflectionHelper.setPrivateValue(EntityRenderer.class, Minecraft.getMinecraft().entityRenderer, tempZoom + zoom, 48);
}

/**
 * Sets the "zoom" of the client's view.
 *
 * Only works on the CLIENT side.
 */
@SideOnly(Side.CLIENT)
public static void setCameraZoom(double zoom){
    if(zoom == 0){
        ObfuscationReflectionHelper.setPrivateValue(EntityRenderer.class, Minecraft.getMinecraft().entityRenderer, 1.0D, 48);
        return;
    }

    double tempZoom = ObfuscationReflectionHelper.getPrivateValue(EntityRenderer.class, Minecraft.getMinecraft().entityRenderer, 48);
    ObfuscationReflectionHelper.setPrivateValue(EntityRenderer.class, Minecraft.getMinecraft().entityRenderer, tempZoom + zoom, 48);
}

/**
 * Sets the "zoom" of the client's view.
 *
 * Only works on the CLIENT side.
 */
@SideOnly(Side.CLIENT)
public static void setCameraZoom(double zoom){
    if(zoom == 0){
        ObfuscationReflectionHelper.setPrivateValue(EntityRenderer.class, Minecraft.getMinecraft().entityRenderer, 1.0D, 48);
        return;
    }

    double tempZoom = ObfuscationReflectionHelper.getPrivateValue(EntityRenderer.class, Minecraft.getMinecraft().entityRenderer, 48);
    ObfuscationReflectionHelper.setPrivateValue(EntityRenderer.class, Minecraft.getMinecraft().entityRenderer, tempZoom + zoom, 48);
}

@SideOnly(Side.CLIENT)
private void onInput(@Nonnull EntityPlayerSP player) {

  MovementInput input = player.movementInput;
  BlockPos target = TravelController.instance.selectedCoord;
  if (target == null) {
    return;
  }

  TileEntity te = player.world.getTileEntity(target);
  if (te instanceof ITravelAccessable) {
    ITravelAccessable ta = (ITravelAccessable) te;
    if (ta.getRequiresPassword(player)) {
      PacketOpenAuthGui p = new PacketOpenAuthGui(target);
      PacketHandler.INSTANCE.sendToServer(p);
      return;
    }
  }

  if (travelToSelectedTarget(player, Prep.getEmpty(), EnumHand.MAIN_HAND, TravelSource.BLOCK, false)) {
    input.jump = false;
    try {
      ObfuscationReflectionHelper.setPrivateValue(EntityPlayer.class, (EntityPlayer) player, 0, "flyToggleTimer", "field_71101_bC");
    } catch (Exception e) {
      // ignore
    }
  }

}

@SuppressWarnings("unchecked")
public static void registerHeadHelper(Class<? extends EntityLivingBase> clz, HeadBase base)
{
    try
    {
        Class clzz = Class.forName("me.ichun.mods.ichunutil.client.entity.head.HeadHandler");
        Map modelOffsetHelpers = (Map)ObfuscationReflectionHelper.getPrivateValue(clzz, null, "modelOffsetHelpers");
        modelOffsetHelpers.put(clz, base);
    }
    catch(Exception e)
    {
        System.out.println("Error registering head helper class: " + clz.getName());
        e.printStackTrace();
    }
}

private static void setGeneratorOptions(World world, WorldInfo worldInfo, WorldSettings settings) {
    if (!world.isRemote) {
        ExampleMod.logger.info("Setting empty generatorOptions to current defaults");
        ObfuscationReflectionHelper.setPrivateValue(WorldInfo.class, worldInfo, settings.writeToJson(), "generatorOptions");
    }
}

public static void firePlayerLoadingEvent(EntityPlayer player, IPlayerFileData playerFileData, String uuidString)
{
    SaveHandler sh = (SaveHandler) playerFileData;
    File dir = ObfuscationReflectionHelper.getPrivateValue(SaveHandler.class, sh, "playersDirectory", "field_"+"75771_c");
    MinecraftForge.EVENT_BUS.post(new PlayerEvent.LoadFromFile(player, dir, uuidString));
}

@SuppressWarnings("deprecation")
public void drawBlockDamageTexture(Tessellator tessellatorIn, VertexBuffer vertexBuffer, Entity entityIn, float partialTicks, World world, List<BlockPos> blocks) {
    double d0 = entityIn.lastTickPosX + (entityIn.posX - entityIn.lastTickPosX) * partialTicks;
    double d1 = entityIn.lastTickPosY + (entityIn.posY - entityIn.lastTickPosY) * partialTicks;
    double d2 = entityIn.lastTickPosZ + (entityIn.posZ - entityIn.lastTickPosZ) * partialTicks;

    TextureManager renderEngine = Minecraft.getMinecraft().renderEngine;
    float curBlockDamageMP = ObfuscationReflectionHelper.getPrivateValue(PlayerControllerMP.class, Minecraft.getMinecraft().playerController, 4);
    int progress = (int) (curBlockDamageMP * 10f) - 1; // 0-10

    if(progress < 0) {
        return;
    }

    renderEngine.bindTexture(TextureMap.LOCATION_BLOCKS_TEXTURE);
    //preRenderDamagedBlocks BEGIN
    GlStateManager.tryBlendFuncSeparate(774, 768, 1, 0);
    GlStateManager.enableBlend();
    GlStateManager.color(1.0F, 1.0F, 1.0F, 0.5F);
    GlStateManager.doPolygonOffset(-3.0F, -3.0F);
    GlStateManager.enablePolygonOffset();
    GlStateManager.alphaFunc(516, 0.1F);
    GlStateManager.enableAlpha();
    GlStateManager.pushMatrix();
    //preRenderDamagedBlocks END

    vertexBuffer.begin(GL11.GL_QUADS, DefaultVertexFormats.BLOCK);
    vertexBuffer.setTranslation(-d0, -d1, -d2);
    vertexBuffer.noColor();

    for(BlockPos blockpos : blocks) {
        blockpos.getX();
        blockpos.getY();
        blockpos.getZ();
        Block block = world.getBlockState(blockpos).getBlock();
        TileEntity te = world.getTileEntity(blockpos);
        boolean hasBreak = block instanceof BlockChest || block instanceof BlockEnderChest
                || block instanceof BlockSign || block instanceof BlockSkull;
        if(!hasBreak) {
            hasBreak = te != null && te.canRenderBreaking();
        }

        if(!hasBreak) {
            IBlockState iblockstate = world.getBlockState(blockpos);

            if(iblockstate.getBlock().getMaterial(iblockstate) != Material.AIR) {
                TextureAtlasSprite textureatlassprite = RenderUtil.getSprite("minecraft:blocks/destroy_stage_"+progress)/*ClientProxy.destroyBlockIcons[progress]*/;
                BlockRendererDispatcher blockrendererdispatcher = Minecraft.getMinecraft().getBlockRendererDispatcher();
                blockrendererdispatcher.renderBlockDamage(iblockstate, blockpos, textureatlassprite, world);
            }
        }
    }

    tessellatorIn.draw();
    vertexBuffer.setTranslation(0.0D, 0.0D, 0.0D);
    // postRenderDamagedBlocks BEGIN
    GlStateManager.disableAlpha();
    GlStateManager.doPolygonOffset(0.0F, 0.0F);
    GlStateManager.disablePolygonOffset();
    GlStateManager.enableAlpha();
    GlStateManager.depthMask(true);
    GlStateManager.popMatrix();
    // postRenderDamagedBlocks END
   }

public void collectEntityData(List<String> lines, RayTraceResult ray, Entity entity){
    String nameLine = entity.getDisplayName().getFormattedText() + " (#"+entity.getEntityId()+")";
lines.add(nameLine);        

    boolean handledRider = false;
if(entity instanceof EntityItemFrame){
    EntityItemFrame frame = (EntityItemFrame)entity;
    ItemStack item = frame.getDisplayedItem();
    if(ItemStackTools.isEmpty(item)){
        lines.add("Item: "+Lang.localize("gui.empty"));
    } else {
        lines.add("Item: "+item.getDisplayName());
    }
}

    if(entity instanceof EntityLivingBase){
    EntityLivingBase living = (EntityLivingBase)entity;
    String health = "Health: "+(living.getHealth()+" / "+ living.getMaxHealth());
    lines.add(health);
}

    if(entity instanceof EntityBoat){
        EntityBoat boat = (EntityBoat)entity;

        if(boat.getControllingPassenger() !=null){
            lines.add("Driver: "+boat.getControllingPassenger().getDisplayName().getFormattedText());
        } else {
            lines.add("Driver: "+Lang.localize("gui.empty"));
        }

        if(!boat.getPassengers().isEmpty() && boat.getPassengers().size() > 1 && boat.getPassengers().get(1) !=null){
            lines.add("Passenger: "+boat.getPassengers().get(1).getDisplayName().getFormattedText());
        } else {
            lines.add("Passenger: "+Lang.localize("gui.empty"));
        }
        handledRider = true;
    }

    if(entity instanceof EntityMinecart){
        EntityMinecart cart = (EntityMinecart)entity;

        if(cart instanceof EntityMinecartEmpty){
        if(cart.getControllingPassenger() !=null){
            lines.add("Rider: "+cart.getControllingPassenger().getDisplayName().getFormattedText());
        } else {
            lines.add("Rider: "+Lang.localize("gui.empty"));
        }
        }
        if(cart instanceof EntityMinecartFurnace){
            EntityMinecartFurnace furnace = (EntityMinecartFurnace)cart;
            int fuel = ObfuscationReflectionHelper.getPrivateValue(EntityMinecartFurnace.class, furnace, 1);
        lines.add("Fuel: "+TimeUtil.getTimeFromTicks(fuel));
        }
        handledRider = true;
    }

    if(entity instanceof IEntityOwnable){
        IEntityOwnable ownable = (IEntityOwnable)entity;
        UUID owner = ownable.getOwnerId();
        if(owner !=null){
            String name = ProfileUtil.getUsername(owner);
            if(name != ProfileUtil.ERROR){
                lines.add("Owner: "+name);
            }
        }
    }

    if(!handledRider && entity.getControllingPassenger() !=null){
        lines.add("Rider: "+entity.getControllingPassenger().getDisplayName().getFormattedText());
    }
  }

public static void injectMethod(float partialTickTime, int flag) {
    Minecraft mc = Minecraft.getMinecraft();
    int rendererUpdateCount = ObfuscationReflectionHelper.getPrivateValue(EntityRenderer.class, mc.entityRenderer, "field_78529_t", "rendererUpdateCount");
    CoreLib.getInstance().getEventBus().post(new CameraTransformEvent(mc.thePlayer, rendererUpdateCount, partialTickTime, flag));
}

public void disactiveBatch()
{
    updateConfig();
    ObfuscationReflectionHelper.setPrivateValue(EntityRenderer.class, Minecraft.getMinecraft().entityRenderer, null, 51);
    ObfuscationReflectionHelper.setPrivateValue(EntityRenderer.class, Minecraft.getMinecraft().entityRenderer, false, 55);
}

public static int getVillagerCareer(EntityVillager merchant) {
  return ObfuscationReflectionHelper.getPrivateValue(EntityVillager.class, merchant, "careerId", "field_175563_bv");
}

public static void setVillagerCareer(EntityVillager merchant, int c) {
  ObfuscationReflectionHelper.setPrivateValue(EntityVillager.class, merchant, c, "careerId", "field_175563_bv");
}