chunk preloader for 1.10.2 (probably only works with OptiFine)

bauerfix.py

t = open("wat4.txt")
t = t.read()

t = t.split("\n")
lastangle = 0
for i in range(len(t)):
    
    elements = t[i].split("/")
    if len(elements) < 4:
        t.remove(t[i])
        break
    #print elements
    angle = ((180.0+float(elements[4]))%360.0)-180.0
    d = angle - ((180.0+lastangle)%360)-180
    if d > 180:
        d -= 360
    if d < -180:
        d += 360
    lastangle += d
    elements[4] = str(lastangle)
    t[i] = "/".join(elements)

t = "\n".join(t)
print t

ChunkPreloader.java

/*
 ** 2014 August 03
 **
 ** The author disclaims copyright to this source code.  In place of
 ** a legal notice, here is a blessing:
 **    May you do good and not evil.
 **    May you find forgiveness for yourself and forgive others.
 **    May you share freely, never taking more than you give.
 */
package info.ata4.minecraft.minema.client.modules;

import java.lang.reflect.Field;
import java.util.Iterator;
import java.util.List;
import java.util.Map.Entry;

import info.ata4.minecraft.minema.client.config.MinemaConfig;
import net.minecraft.client.Minecraft;
import net.minecraft.client.renderer.RenderGlobal;
import net.minecraft.client.renderer.chunk.ChunkRenderDispatcher;
import net.minecraft.client.renderer.chunk.RenderChunk;
import net.minecraftforge.common.MinecraftForge;
import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
import net.minecraftforge.fml.common.gameevent.TickEvent.Phase;
import net.minecraftforge.fml.common.gameevent.TickEvent.RenderTickEvent;

/**
 *
 * @author Nico Bergemann <barracuda415 at yahoo.de>
 */
public class ChunkPreloader extends CaptureModule {
    
    private static final Minecraft MC = Minecraft.getMinecraft();
    
    private Field renderInfosField;
    private Field renderDispatcherField;

    private Field renderChunkField;
    
    public ChunkPreloader(MinemaConfig cfg) {
        super(cfg);
    }
    
	@SuppressWarnings("rawtypes")
	@SubscribeEvent
    public void onTick(RenderTickEvent evt) {
        if (evt.phase != Phase.START) {
            return;
        }

        
        if (renderInfosField == null || renderDispatcherField == null) {
            return;
        }
        
        // TODO: this only loads local client chunks and doesn't load missing
        // chunks from the server
        
        
        
        
        ChunkRenderDispatcher renderDispatcher;
        Iterator iterator;
		try {
			
			iterator = ((List) renderInfosField.get(MC.renderGlobal)).iterator();
			renderDispatcher = (ChunkRenderDispatcher) renderDispatcherField.get(MC.renderGlobal);
		} catch (Exception e) {
			renderInfosField = null;
			throw new RuntimeException("failed to get value of renderGlobal fields", e);
		}
        /*while (iterator.hasNext()) {
            RenderChunk renderChunk = iterator.next();
            if(renderChunk.isNeedsUpdate() || renderChunk.isNeedsUpdateCustom()){
	            renderDispatcher.updateChunkNow(renderChunk);
	            renderChunk.clearNeedsUpdate();
	            iterator.remove();
            }
            
        }*/
		renderDispatcher.runChunkUploads(System.nanoTime()+500000000L);
		int j = 0;
		try {
			while (iterator.hasNext()) {
				Object renderInfo = iterator.next();

				RenderChunk rc = (RenderChunk) renderChunkField.get(renderInfo);
				if (rc.isNeedsUpdateCustom()) {
					renderDispatcher.updateChunkNow(rc);
					rc.clearNeedsUpdate();
					j++;
				} else if(rc.isNeedsUpdate()) {
					renderDispatcher.updateChunkNow(rc);
					rc.clearNeedsUpdate();
					j++;
				}
				
				
			}
		} catch (Exception e) {
			throw new RuntimeException("preloader: could not force chunk updates", e);
		}
		/*long maxTime = System.nanoTime()+1000000000L;
		renderDispatcher.runChunkUploads(maxTime);
		int j = 0;
		while (iterator.hasNext()) {
			RenderChunk renderchunk = (RenderChunk) iterator.next();
			boolean flag;
			if (renderchunk.isNeedsUpdateCustom()) {
				flag = renderDispatcher.updateChunkNow(renderchunk);
			} else {
				flag = renderDispatcher.updateChunkLater(renderchunk);
			}

			if (!flag) {
				System.out.println("flag exceeded");
				break;
			}

			renderchunk.clearNeedsUpdate();
			iterator.remove();
			long i = maxTime - System.nanoTime();
			if (i < 0L) {
				System.out.println("maxTime exceeded");
				break;
			}
			j++;
		}
		
        //MC.renderGlobal.updateChunks();*/
        //renderDispatcher.runChunkUploads(System.nanoTime()+500000000L);
		System.out.println("updated chunks: "+j);
    }

	@Override
    protected void doEnable() throws Exception {
		
		for(Entry<Thread, StackTraceElement[]> e : Thread.getAllStackTraces().entrySet()){
			Thread t = e.getKey();
			if(t.getName().startsWith("Chunk Batcher")){
				System.out.println("thread: "+t.getName()+" "+t.getState());
				
				for (StackTraceElement traceElement : e.getValue())
	                System.out.println("\t" + traceElement);
			}
		}
		
		
        try {
        	for(Field f : RenderGlobal.class.getDeclaredFields()){
        		f.setAccessible(true);
        		if(f.getType().getTypeParameters().length > 0){ // Assuming it's the only LinkedHashSet in this class
        			System.out.print(f.getName()+" ");

        			System.out.print(f.getGenericType());
        			System.out.print(" = ");
        			System.out.print(f.get(MC.renderGlobal).getClass().getTypeName());
        			
        			System.out.print("\n");
        			if(f.getName().equals("field_72755_R")){
        				renderInfosField = f;
        			}
        		}else if(f.get(MC.renderGlobal) instanceof ChunkRenderDispatcher){
        			renderDispatcherField =  f;
        		}
        	}
        	for(Class<?> subClass : RenderGlobal.class.getDeclaredClasses()){
        		
        		if(subClass.getName().endsWith("ContainerLocalRenderInformation")){
        			renderChunkField = subClass.getDeclaredFields()[0];
        			renderChunkField.setAccessible(true);
        		}
        	}
        } catch (Exception ex) {
        	ex.printStackTrace();
            throw new RuntimeException("Can't get chunksToUpdate and renderDispatcher field", ex);
        }
        if(renderInfosField == null) throw new RuntimeException("renderInfos field not found");
        if(renderDispatcherField == null) throw new RuntimeException("renderDispatcher field not found");
        if(renderChunkField == null) throw new RuntimeException("renderChunk field not found");
        MinecraftForge.EVENT_BUS.register(this);
    }

    @Override
    protected void doDisable() throws Exception {
    	MinecraftForge.EVENT_BUS.unregister(this);
    }
    
}

SIEMA ERROR