minecraft_de_Client_Events_EventAPI.java

package de.Client.Events;

public class EventAPI {

	public static final String VERSION = String.format("%s-%s", new Object[] {"0.7", "beta"});
	public static final String[] AUTHOR = {"DarkMagican6"};
}

minecraft_de_Client_Events_EventManager.java

package de.Client.Events;

import de.Client.Events.IEvent.Event;
import de.Client.Events.IEvent.EventStoppable;
import de.Client.Events.Types.Priority;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.concurrent.CopyOnWriteArrayList;




/**
 * 
 * 
 * @author DarkMagician6
 * @since February 2, 2014
 */
public final class EventManager {
	
	/**
	 * HashMap containing all the registered MethodData sorted on the event parameters of the methods.
	 */
	private static final Map<Class<? extends Event>, List<MethodData>> REGISTRY_MAP = new HashMap<Class<? extends Event>, List<MethodData>>();
	
	/**
	 * All methods in this class are static so there would be no reason to create an object of the EventManager class.
	 */
	private EventManager() {
	}
	
    /**
     * Registers all the methods marked with the EventTarget annotation in the class of the given Object.
     *
     * @param object
     *         Object that you want to register.
     */
    public static void register(Object object) {
        for (final Method method : object.getClass().getDeclaredMethods()) {
            if (isMethodBad(method)) {
                continue;
            }

            register(method, object);
        }
    }

    /**
     * Registers the methods marked with the EventTarget annotation and that require
     * the specified Event as the parameter in the class of the given Object.
     *
     * @param object
     *         Object that contains the Method you want to register.
     */
    public static void register(Object object, Class<? extends Event> eventClass) {
        for (final Method method : object.getClass().getDeclaredMethods()) {
            if (isMethodBad(method, eventClass)) {
                continue;
            }

            register(method, object);
        }
    }

    /**
     * Unregisters all the methods inside the Object that are marked with the EventTarget annotation.
     *
     * @param object
     *         Object of which you want to unregister all Methods.
     */
    public static void unregister(Object object) {
        for (final List<MethodData> dataList : REGISTRY_MAP.values()) {
            for (final MethodData data : dataList) {
                if (data.getSource().equals(object)) {
                    dataList.remove(data);
                }
            }
        }

        cleanMap(true);
    }

    /**
     * Unregisters all the methods in the given Object that have the specified class as a parameter.
     *
     * @param object
     *         Object that implements the Listener interface.
     */
    public static void unregister(Object object, Class<? extends Event> eventClass) {
        if (REGISTRY_MAP.containsKey(eventClass)) {
            for (final MethodData data : REGISTRY_MAP.get(eventClass)) {
                if (data.getSource().equals(object)) {
                	REGISTRY_MAP.get(eventClass).remove(data);
                }
            }

            cleanMap(true);
        }
    }

    /**
     * Registers a new MethodData to the HashMap.
     * If the HashMap already contains the key of the Method's first argument it will add
     * a new MethodData to key's matching list and sorts it based on Priority. @see com.darkmagician6.eventapi.types.Priority
     * Otherwise it will put a new entry in the HashMap with a the first argument's class
     * and a new CopyOnWriteArrayList containing the new MethodData.
     *
     * @param method
     *         Method to register to the HashMap.
     * @param object
     *         Source object of the method.
     */
    private static void register(Method method, Object object) {
    	Class<? extends Event> indexClass = (Class<? extends Event>) method.getParameterTypes()[0];
    	//New MethodData from the Method we are registering.
    	final MethodData data = new MethodData(object, method, method.getAnnotation(EventTarget.class).value());
    	
    	//Set's the method to accessible so that we can also invoke it if it's protected or private.
    	if (!data.getTarget().isAccessible()) {
    		data.getTarget().setAccessible(true);
    	}
	
    	if (REGISTRY_MAP.containsKey(indexClass)) {
    		if (!REGISTRY_MAP.get(indexClass).contains(data)) {
    			REGISTRY_MAP.get(indexClass).add(data);
    			sortListValue(indexClass);
    		}
    	} else {
    		REGISTRY_MAP.put(indexClass, new CopyOnWriteArrayList<MethodData>() {
    			//Eclipse was bitching about a serialVersionUID.
    			private static final long serialVersionUID = 666L; {
    				add(data);
    			}
    		});
    	}
    }

    /**
     * Removes an entry based on the key value in the map.
     *
     * @param indexClass
     *         They index key in the map of which the entry should be removed.
     */
    public static void removeEntry(Class<? extends Event> indexClass) {
        Iterator<Map.Entry<Class<? extends Event>, List<MethodData>>> mapIterator = REGISTRY_MAP.entrySet().iterator();

        while (mapIterator.hasNext()) {
            if (mapIterator.next().getKey().equals(indexClass)) {
                mapIterator.remove();
                break;
            }
        }
    }

    /**
     * Cleans up the map entries.
     * Uses an iterator to make sure that the entry is completely removed.
     *
     * @param onlyEmptyEntries
     *         If true only remove the entries with an empty list, otherwise remove all the entries.
     */
    public static void cleanMap(boolean onlyEmptyEntries) {
        Iterator<Map.Entry<Class<? extends Event>, List<MethodData>>> mapIterator = REGISTRY_MAP.entrySet().iterator();

        while (mapIterator.hasNext()) {
            if (!onlyEmptyEntries || mapIterator.next().getValue().isEmpty()) {
                mapIterator.remove();
            }
        }
    }

    /**
     * Sorts the List that matches the corresponding Event class based on priority value.
     *
     * @param indexClass
     *         The Event class index in the HashMap of the List to sort.
     */
    private static void sortListValue(Class<? extends Event> indexClass) {
        List<MethodData> sortedList = new CopyOnWriteArrayList<MethodData>();

        for (final byte priority : Priority.VALUE_ARRAY) {
            for (final MethodData data : REGISTRY_MAP.get(indexClass)) {
                if (data.getPriority() == priority) {
                    sortedList.add(data);
                }
            }
        }

        //Overwriting the existing entry.
        REGISTRY_MAP.put(indexClass, sortedList);
    }

    /**
     * Checks if the method does not meet the requirements to be used to receive event calls from the Dispatcher.
     * Performed checks: Checks if the parameter length is not 1 and if the EventTarget annotation is not present.
     *
     * @param method
     *         Method to check.
     *
     * @return True if the method should not be used for receiving event calls from the Dispatcher.
     *
     * @see com.darkmagician6.eventapi.EventTarget
     */
    private static boolean isMethodBad(Method method) {
        return method.getParameterTypes().length != 1 || !method.isAnnotationPresent(EventTarget.class);
    }

    /**
     * Checks if the method does not meet the requirements to be used to receive event calls from the Dispatcher.
     * Performed checks: Checks if the parameter class of the method is the same as the event we want to receive.
     *
     * @param method
     *         Method to check.
     * @return True if the method should not be used for receiving event calls from the Dispatcher.
     *
     * @see com.darkmagician6.eventapi.EventTarget
     */
    private static boolean isMethodBad(Method method, Class<? extends Event> eventClass) {
        return isMethodBad(method) || !method.getParameterTypes()[0].equals(eventClass);
    }
	
    /**
     * Call's an event and invokes the right methods that are listening to the event call.
     * First get's the matching list from the registry map based on the class of the event.
     * Then it checks if the list is not null. After that it will check if the event is an instance of
     * EventStoppable and if so it will add an extra check when looping trough the data.
     * If the Event was an instance of EventStoppable it will check every loop if the EventStoppable is stopped, and if
     * it is it will break the loop, thus stopping the call.
     * For every MethodData in the list it will invoke the Data's method with the Event as the argument.
     * After that is all done it will return the Event.
     *
     * @param event
     *         Event to dispatch.
     *
     * @return Event in the state after dispatching it.
     */
    public static final Event call(final Event event) {
        List<MethodData> dataList = REGISTRY_MAP.get(event.getClass());

        if (dataList != null) {
            if (event instanceof EventStoppable) {
                EventStoppable stoppable = (EventStoppable) event;

                for (final MethodData data : dataList) {
                    invoke(data, event);

                    if (stoppable.isStopped()) {
                        break;
                    }
                }
            } else {
                for (final MethodData data : dataList) {
                    invoke(data, event);
                }
            }
        }

        return event;
    }
    
    /**
     * Invokes a MethodData when an Event call is made.
     *
     * @param data
     *         The data of which the targeted Method should be invoked.
     * @param argument
     *         The called Event which should be used as an argument for the targeted Method.
     *         
     * TODO: Error messages.
     */
    private static void invoke(MethodData data, Event argument) {
        try {
            data.getTarget().invoke(data.getSource(), argument);
        } catch (IllegalAccessException ignored) {
        } catch (IllegalArgumentException ignored) {
        } catch (InvocationTargetException ignored) {
        }
    }
	
	/**
	 * 
	 * @author DarkMagician6
	 * @since January 2, 2014
	 */
	private static final class MethodData {

	    private final Object source;

	    private final Method target;

	    private final byte priority;

	    /**
	     * Sets the values of the data.
	     *
	     * @param source
	     *         The source Object of the data. Used by the VM to
	     *         determine to which object it should send the call to.
	     * @param target
	     *         The targeted Method to which the Event should be send to.
	     * @param priority
	     *         The priority of this Method. Used by the registry to sort
	     *         the data on.
	     */
	    public MethodData(Object source, Method target, byte priority) {
	        this.source = source;
	        this.target = target;
	        this.priority = priority;
	    }

	    /**
	     * Gets the source Object of the data.
	     *
	     * @return Source Object of the targeted Method.
	     */
	    public Object getSource() {
	        return source;
	    }

	    /**
	     * Gets the targeted Method.
	     *
	     * @return The Method that is listening to certain Event calls.
	     */
	    public Method getTarget() {
	        return target;
	    }

	    /**
	     * Gets the priority value of the targeted Method.
	     *
	     * @return The priority value of the targeted Method.
	     */
	    public byte getPriority() {
	        return priority;
	    }

	}

}

minecraft_de_Client_Events_Events_DisplayGuiScreenEvent.java

package de.Client.Events.Events;

import de.Client.Events.IEvent.Event;
import net.minecraft.client.gui.GuiScreen;

/**
 * Created by Daniel on 31.08.2017.
 */
public class DisplayGuiScreenEvent implements Event{
    public GuiScreen guiScreenbevor;
    public GuiScreen guiScreenafter;
    public DisplayGuiScreenEvent(GuiScreen g, GuiScreen g2){
        guiScreenbevor = g;
        guiScreenafter = g2;
    }
}

minecraft_de_Client_Events_Events_EventBoundingBox.java

package de.Client.Events.Events;

import de.Client.Events.IEvent.Event;
import net.minecraft.block.Block;
import net.minecraft.util.AxisAlignedBB;

public class EventBoundingBox
  implements Event
{
  public final Block block;
  public AxisAlignedBB boundingBox;
  public final double x;
  public final double y;
  public final double z;
  
  public EventBoundingBox(AxisAlignedBB bb, Block block, double x, double y, double z)
  {
    this.block = block;
    this.boundingBox = bb;
    this.x = x;
    this.y = y;
    this.z = z;
  }
  
  public AxisAlignedBB getBoundingBox()
  {
    return this.boundingBox;
  }
  
  public void setBoundingBox(AxisAlignedBB boundingBox)
  {
    this.boundingBox = boundingBox;
  }
  
  public Block getBlock()
  {
    return this.block;
  }
  
  public double getX()
  {
    return this.x;
  }
  
  public double getY()
  {
    return this.y;
  }
  
  public double getZ()
  {
    return this.z;
  }
}

minecraft_de_Client_Events_Events_EventRenderScreen.java

package de.Client.Events.Events;

import de.Client.Events.IEvent.Event;

public class EventRenderScreen
  implements Event
{
  public EventRenderScreen()
  {
	  
  }
}

minecraft_de_Client_Events_Events_EventRenderWorld.java

package de.Client.Events.Events;

import de.Client.Events.IEvent.Event;

public class EventRenderWorld
  implements Event
{
  private float ticks;
  
  public EventRenderWorld(float ticks)
  {
    setTicks(ticks);
  }
  
  public float getTicks()
  {
    return this.ticks;
  }
  
  public void setTicks(float ticks)
  {
    this.ticks = ticks;
  }
}

minecraft_de_Client_Events_Events_EventRenderWorldBackground.java

package de.Client.Events.Events;

import de.Client.Events.IEvent.Callables.EventCancellable;
import de.Client.Events.IEvent.Event;

public class EventRenderWorldBackground extends EventCancellable {


    public EventRenderWorldBackground() {

    }

}

minecraft_de_Client_Events_Events_EventSafeWalk.java

package de.Client.Events.Events;

import de.Client.Events.IEvent.Event;

public class EventSafeWalk implements Event {

    private boolean shouldWalkSafely;

    public EventSafeWalk(boolean shouldWalkSafely) {
        this.shouldWalkSafely = shouldWalkSafely;
    }

    public boolean getShouldWalkSafely() {
        return this.shouldWalkSafely;
    }

    public void setShouldWalkSafely(boolean shouldWalkSafely) {
        this.shouldWalkSafely = shouldWalkSafely;
    }
}

minecraft_de_Client_Events_Events_MoveEvent.java

package de.Client.Events.Events;

import de.Client.Events.IEvent.Callables.EventCancellable;

public class MoveEvent extends EventCancellable {

	public double x;
	public double y;
	public double z;
	
	public MoveEvent(double x, double y, double z) {
		this.x = x;
		this.y = y;
		this.z = z;
	}
	
	public double getX() {
		return this.x;
	}
	
	public double getY() {
		return this.y;
	}
	
	public double getZ() {
		return this.z;
	}
	
	public void setX(double x) {
		this.x = x;
	}
	
	public void setY(double y) {
		this.y = y;
	}
	
	public void setZ(double z) {
		this.z = z;
	}
}

minecraft_de_Client_Events_Events_PacketReceiveEvent.java

package de.Client.Events.Events;


import de.Client.Events.IEvent.Callables.EventCancellable;
import net.minecraft.network.Packet;

public class PacketReceiveEvent extends EventCancellable {

	private Packet packet;
	
	public PacketReceiveEvent(Packet packet) {
		this.packet = packet;
	}
	
	public Packet getPacket() {
		return this.packet;
	}
	
	public void setPacket(Packet packet) {
		this.packet = packet;
	}
}

minecraft_de_Client_Events_Events_PacketSendEvent.java

package de.Client.Events.Events;

import de.Client.Events.IEvent.Callables.EventCancellable;
import net.minecraft.network.Packet;

public class PacketSendEvent extends EventCancellable {

	private Packet packet;
	
	public PacketSendEvent(Packet packet) {
		this.packet = packet;
	}
	
	public Packet getPacket() {
		return this.packet;
	}
	
	public void setPacket(Packet packet) {
		this.packet = packet;
	}
}

minecraft_de_Client_Events_Events_PreMotionUpdate.java

package de.Client.Events.Events;

import de.Client.Events.IEvent.EventStoppable;

public class PreMotionUpdate extends EventStoppable {

	public double motionX;
	public double motionY;
	public double motionZ;

	public PreMotionUpdate(double motionX, double motionY, double motionZ) {
		this.motionX = motionX;
		this.motionY = motionY;
		this.motionZ = motionZ;
	}
}

minecraft_de_Client_Events_Events_PreSendMotion.java

package de.Client.Events.Events;

import de.Client.Events.IEvent.Callables.EventCancellable;

public class PreSendMotion extends EventCancellable
{
  public float yaw;
  public float pitch;

  public PreSendMotion(float yaw, float pitch)
  {
    this.yaw = yaw;
    this.pitch = pitch;
  }

  public float getPitch() {
    return this.pitch;
  }

  public float getYaw() {
    return this.yaw;
  }

  public void setPitch(float pitch) {
    this.pitch = pitch;
  }

  public void setYaw(float yaw) {
    this.yaw = yaw;
  }
}

minecraft_de_Client_Events_Events_Render3DEvent.java

package de.Client.Events.Events;

import de.Client.Events.IEvent.Event;

public class Render3DEvent implements Event {

	private float partialTicks;
	
	public Render3DEvent(float partialTicks) {
		this.partialTicks = partialTicks;
	}
	
	public float getPartialTicks() {
		return this.partialTicks;
	}
	
	public void setPartialTicks(float partialTicks) {
		this.partialTicks = partialTicks;
	}
}

minecraft_de_Client_Events_Events_UpdateEvent.java

package de.Client.Events.Events;

import de.Client.Events.IEvent.Event;
import de.Client.Events.IEvent.State;

public class UpdateEvent implements Event {

	public State state;
	public float yaw;
	public float pitch;
	public double y;
	public boolean ground;

	public UpdateEvent() {
		this.state = State.POST;
	}
	
	public UpdateEvent(double y, float yaw, float pitch, boolean ground) {
		this.state = State.PRE;
		this.yaw = yaw;
		this.pitch = pitch;
		this.y = y;
		this.ground = ground;
	}
	
	public double getY() {
		return this.y;
	}
	
	public float getYaw() {
		return this.yaw;
	}

	public float getPitch() {
		return this.pitch;
	}

	public boolean onGround() {
		return this.ground;
	}
	
	public State getState() {
		return this.state;
	}
	
	
}

minecraft_de_Client_Events_EventTarget.java

package de.Client.Events;

import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Documented
@Target({java.lang.annotation.ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface EventTarget {
	byte value() default 2;
}

minecraft_de_Client_Events_IEvent_Callables_EventCancellable.java

package de.Client.Events.IEvent.Callables;

import de.Client.Events.IEvent.Cancellable;
import de.Client.Events.IEvent.Event;

public class EventCancellable implements Event, Cancellable {

	private boolean cancelled;
	
	public boolean isCancelled() {
		return this.cancelled;
	}
	
	public void setCancelled(boolean state) {
		this.cancelled = state;
	}
}

minecraft_de_Client_Events_IEvent_Callables_EventTyped.java

package de.Client.Events.IEvent.Callables;

import de.Client.Events.IEvent.Event;
import de.Client.Events.IEvent.Typed;

public class EventTyped implements Event, Typed {

	private final byte type;
	
	protected EventTyped(byte eventType) {
		this.type = eventType;
	}
	
	public byte getType() {
		return this.type;
	}
}

minecraft_de_Client_Events_IEvent_Cancellable.java

package de.Client.Events.IEvent;

public interface Cancellable {

	boolean isCancelled();
	
	void setCancelled(boolean paramBoolean);
}

minecraft_de_Client_Events_IEvent_Event.java

package de.Client.Events.IEvent;

public interface Event {
	
}

minecraft_de_Client_Events_IEvent_EventStoppable.java

package de.Client.Events.IEvent;

public abstract class EventStoppable implements Event {

	private boolean stopped;
	
	public void stop() {
		this.stopped = true;
	}
	
	public boolean isStopped() {
		return this.stopped;
	}
}

minecraft_de_Client_Events_IEvent_State.java

package de.Client.Events.IEvent;

public enum State {

	PRE,
	POST
}

minecraft_de_Client_Events_IEvent_Typed.java

package de.Client.Events.IEvent;

public interface Typed {

	byte getType();
}

minecraft_de_Client_Events_Types_EventType.java

package de.Client.Events.Types;

public class EventType {

	public static final byte PRE = 0;
	public static final byte ON = 1;
	public static final byte POST = 2;
	public static final byte SEND = 3;
	public static final byte RECIEVE = 4;
}

minecraft_de_Client_Events_Types_Priority.java

package de.Client.Events.Types;

public final class Priority {

	public static final byte HIGHEST = 0;
	public static final byte HIGH = 1;
	public static final byte MEDIUM = 2;
	public static final byte LOW = 3;
	public static final byte LOWEST = 4;
	public static final byte[] VALUE_ARRAY = {0, 1, 2, 3, 4};
}

minecraft_de_Client_Main_Commands_CommandManager.java

package de.Client.Main.Commands;

import de.Client.Main.Main;
import de.Client.Main.Modules.Module;
import de.Client.Main.Modules.mods.Combat.McdeadAimbot;
import de.Client.Main.Modules.mods.World.Fucker;
import de.Client.Main.Values.Value;
import de.Client.Main.Values.ValueBoolean;
import de.Client.Main.Values.ValueDouble;
import de.Client.Render.ArrayLists.ArrayListC;
import de.Client.Render.ArrayLists.ArrayListD;
import de.Client.Render.ArrayLists.ArrayListD2;
import de.Client.Render.ArrayLists.ArrayListS;
import de.Client.Render.TabGuis.TabGuiC;
import de.Client.Render.TabGuis.TabGuiD;
import de.Client.Render.TabGuis.TabGuiS;
import de.Client.Render.Watermarks.WatermarkC;
import de.Client.Render.Watermarks.WatermarkD;
import de.Client.Render.Watermarks.WatermarkS;
import de.Client.Render.Watermarks.WatermarkSky;
import de.Client.Utils.*;
import net.minecraft.block.Block;
import net.minecraft.client.Minecraft;
import net.minecraft.event.HoverEvent;
import net.minecraft.util.ChatComponentText;
import net.minecraft.util.ChatStyle;
import net.minecraft.util.EnumChatFormatting;
import net.minecraft.util.IChatComponent;
import org.lwjgl.Sys;
import org.lwjgl.input.Keyboard;

import java.awt.*;
import java.io.*;
import java.net.URL;

public class CommandManager {
	
	public String prefix = ".";
	
	
	public CommandManager(){
		
	}
	 private  String prefixHover()
	  {
	    return String.format("&5[Night]", new Object[] { "Night" }).trim();
	  }
	  
	  public  String format(String s)
	  {
	    return s.replaceAll("(?i)&([a-f0-9klmnor])", "�$1");
	  }
	  private  IChatComponent split(String message)
	  {
	    message = format(message.replaceAll("\t", "    "));
	    String[] parts = message.split("�");
	    ChatComponentText icc = new ChatComponentText("");
          int n = parts.length;
	    int n2 = 0;
	    while (n2 < n)
	    {
	      String part = parts[n2];
	      if (part.length() > 0)
	      {
	        char c = part.charAt(0);
	        part = part.substring(1);
	        ChatStyle style = new ChatStyle();
	        switch (c)
	        {
	        case 'k': 
	          style.setObfuscated(Boolean.valueOf(true));
	          break;
	        case 'l': 
	          style.setBold(Boolean.valueOf(true));
	          break;
	        case 'm': 
	          style.setUnderlined(Boolean.valueOf(true));
	          break;
	        case 'n': 
	          style.setStrikethrough(Boolean.valueOf(true));
	          break;
	        case 'o': 
	          style.setItalic(Boolean.valueOf(true));
	          break;
	        default: 
	          style.setColor(charToFormat(c));
	        }
	        String[] lines = part.split("\n");
	        int i = 0;
	        while (i < lines.length)
	        {
	          String line = lines[i];
	          icc.appendSibling(new ChatComponentText(line).setChatStyle(style));
	          if (i != lines.length - 1) {
	            icc.appendSibling(new ChatComponentText("\n"));
	          }
	          i++;
	        }
	      }
	      n2++;
	    }
	    return icc;
	  }
	  private  EnumChatFormatting charToFormat(char c)
	  {
	    EnumChatFormatting[] arrenumChatFormatting = EnumChatFormatting.values();
	    int n = arrenumChatFormatting.length;
	    int n2 = 0;
	    while (n2 < n)
	    {
	      EnumChatFormatting ecf = arrenumChatFormatting[n2];
	      if (ecf.formattingCode == c) {
	        return ecf;
	      }
	      n2++;
	    }
	    return EnumChatFormatting.RESET;
	  }

    public void IRC_exutecute_Help(){

    }
	  public void handleSendIRC(String message1){
        String message = message1.replace("#", "");
          String[] s = message.split(" ");
        if(s[0].startsWith("irc")){


                if(s[1].equalsIgnoreCase("help")){
                    IRC_exutecute_Help();
                    return;
                }

                if(s[1].equalsIgnoreCase("list")){
                    this.sendIRC("§4GETALLPLAYER");
                    this.sendChatMessage("List of all IRC user");
                    Main.getMain.cmdManager.sendChatMessage("§a" + Main.getMain.ircManager.getName()+ " §8> §e" + "~ §3(YOU)");
                    return;
                }




        }

          Main.getMain.cmdManager.sendChatMessage("§a" + Main.getMain.ircManager.getName()+ " §8> §e" + message);
          sendIRC(message);
      }
	  public void sendIRC(String message){

	      Main.getMain.ircManager.sendMessage(Main.getMain.ircManager.CHANNEL_MAIN,message);
      }



      public void handleReceiveIRC(IRCChatLine message){
          System.out.println(message.getLine().contains("DŽ"));
          if(message.getLine().contains("§4")){
              String[] m = message.getLine().replace("§4","").split(" ");
              if(m[0].equalsIgnoreCase("GETALLPLAYER")){
                  this.sendIRC("~");
              }
              return;
          }
          Main.getMain.cmdManager.sendChatMessage("§a" + message.getSender() + " §8> §e" + message.getLine());
      }

      public void saveTheme(File f) {
          f.delete();
          try {
              f.createNewFile();
          } catch (IOException e) {
              e.printStackTrace();
          }
          PrintWriter output = null;
          try {
              output = new PrintWriter(new FileWriter(f, true));

          output.println("Color + " + Main.getMain.getClientColor().getRGB());
          output.println("Watermark + " + Main.getMain.waterMark.getClass());
          output.println("TabGui + " + Main.getMain.tabGui.getClass());
          output.println("ArrayList + " + Main.getMain.arrayList.getClass());
          output.close();
          } catch (IOException e) {
              e.printStackTrace();
          }

      }

	public void sendChatMessage(String message){

	    if(Minecraft.getMinecraft().thePlayer == null){
	        return;
        }
		     message = "&7" + message;
		    ChatComponentText icc = new ChatComponentText("");
		    IChatComponent prefix = split((String.format(" &8[&5N&8] ", new Object[] { "Night".substring(0, 1).toLowerCase()})));
		    prefix.getChatStyle().setChatHoverEvent(new HoverEvent(HoverEvent.Action.SHOW_TEXT, split(prefixHover())));
		    icc.appendSibling(prefix);
		        icc.appendSibling(split(message));
		    Minecraft.getMinecraft().thePlayer.addChatMessage(icc);
	}
	  public static int keyStringToIntID(String keyCode) {
	        if (keyCode.equalsIgnoreCase("a")) return Keyboard.KEY_A;
	        if (keyCode.equalsIgnoreCase("b")) return Keyboard.KEY_B;
	        if (keyCode.equalsIgnoreCase("c")) return Keyboard.KEY_C;
	        if (keyCode.equalsIgnoreCase("d")) return Keyboard.KEY_D;
	        if (keyCode.equalsIgnoreCase("e")) return Keyboard.KEY_E;
	        if (keyCode.equalsIgnoreCase("f")) return Keyboard.KEY_F;
	        if (keyCode.equalsIgnoreCase("g")) return Keyboard.KEY_G;
	        if (keyCode.equalsIgnoreCase("h")) return Keyboard.KEY_H;
	        if (keyCode.equalsIgnoreCase("i")) return Keyboard.KEY_I;
	        if (keyCode.equalsIgnoreCase("j")) return Keyboard.KEY_J;
	        if (keyCode.equalsIgnoreCase("k")) return Keyboard.KEY_K;
	        if (keyCode.equalsIgnoreCase("l")) return Keyboard.KEY_L;
	        if (keyCode.equalsIgnoreCase("m")) return Keyboard.KEY_M;
	        if (keyCode.equalsIgnoreCase("n")) return Keyboard.KEY_N;
	        if (keyCode.equalsIgnoreCase("o")) return Keyboard.KEY_O;
	        if (keyCode.equalsIgnoreCase("p")) return Keyboard.KEY_P;
	        if (keyCode.equalsIgnoreCase("q")) return Keyboard.KEY_Q;
	        if (keyCode.equalsIgnoreCase("r")) return Keyboard.KEY_R;
	        if (keyCode.equalsIgnoreCase("s")) return Keyboard.KEY_S;
	        if (keyCode.equalsIgnoreCase("t")) return Keyboard.KEY_T;
	        if (keyCode.equalsIgnoreCase("u")) return Keyboard.KEY_U;
	        if (keyCode.equalsIgnoreCase("v")) return Keyboard.KEY_V;
	        if (keyCode.equalsIgnoreCase("w")) return Keyboard.KEY_W;
	        if (keyCode.equalsIgnoreCase("x")) return Keyboard.KEY_X;
	        if (keyCode.equalsIgnoreCase("y")) return Keyboard.KEY_Y;
	        if (keyCode.equalsIgnoreCase("z")) return Keyboard.KEY_Z;
	 
	        if (keyCode.equalsIgnoreCase("0")) return Keyboard.KEY_0;
	        if (keyCode.equalsIgnoreCase("1")) return Keyboard.KEY_1;
	        if (keyCode.equalsIgnoreCase("2")) return Keyboard.KEY_2;
	        if (keyCode.equalsIgnoreCase("3")) return Keyboard.KEY_3;
	        if (keyCode.equalsIgnoreCase("4")) return Keyboard.KEY_4;
	        if (keyCode.equalsIgnoreCase("5")) return Keyboard.KEY_5;
	        if (keyCode.equalsIgnoreCase("6")) return Keyboard.KEY_6;
	        if (keyCode.equalsIgnoreCase("7")) return Keyboard.KEY_7;
	        if (keyCode.equalsIgnoreCase("8")) return Keyboard.KEY_8;
	        if (keyCode.equalsIgnoreCase("9")) return Keyboard.KEY_9;
	 
	        if (keyCode.equalsIgnoreCase("f1")) return Keyboard.KEY_F1;
	        if (keyCode.equalsIgnoreCase("f2")) return Keyboard.KEY_F2;
	        if (keyCode.equalsIgnoreCase("f3")) return Keyboard.KEY_F3;
	        if (keyCode.equalsIgnoreCase("f4")) return Keyboard.KEY_F4;
	        if (keyCode.equalsIgnoreCase("f5")) return Keyboard.KEY_F5;
	        if (keyCode.equalsIgnoreCase("f6")) return Keyboard.KEY_F6;
	        if (keyCode.equalsIgnoreCase("f7")) return Keyboard.KEY_F7;
	        if (keyCode.equalsIgnoreCase("f8")) return Keyboard.KEY_F8;
	        if (keyCode.equalsIgnoreCase("f9")) return Keyboard.KEY_F9;
	        if (keyCode.equalsIgnoreCase("f10")) return Keyboard.KEY_F10;
	        if (keyCode.equalsIgnoreCase("f11")) return Keyboard.KEY_F11;
	        if (keyCode.equalsIgnoreCase("f12")) return Keyboard.KEY_F12;
	 
	        if (keyCode.equalsIgnoreCase("numpad0")) return Keyboard.KEY_NUMPAD0;
	        if (keyCode.equalsIgnoreCase("numpad1")) return Keyboard.KEY_NUMPAD1;
	        if (keyCode.equalsIgnoreCase("numpad2")) return Keyboard.KEY_NUMPAD2;
	        if (keyCode.equalsIgnoreCase("numpad3")) return Keyboard.KEY_NUMPAD3;
	        if (keyCode.equalsIgnoreCase("numpad4")) return Keyboard.KEY_NUMPAD4;
	        if (keyCode.equalsIgnoreCase("numpad5")) return Keyboard.KEY_NUMPAD5;
	        if (keyCode.equalsIgnoreCase("numpad6")) return Keyboard.KEY_NUMPAD6;
	        if (keyCode.equalsIgnoreCase("numpad7")) return Keyboard.KEY_NUMPAD7;
	        if (keyCode.equalsIgnoreCase("numpad8")) return Keyboard.KEY_NUMPAD8;
	        if (keyCode.equalsIgnoreCase("numpad9")) return Keyboard.KEY_NUMPAD9;
	       
	        if (keyCode.equalsIgnoreCase("up")) return Keyboard.KEY_UP;
	        if (keyCode.equalsIgnoreCase("down")) return Keyboard.KEY_DOWN;
	        if (keyCode.equalsIgnoreCase("right")) return Keyboard.KEY_RIGHT;
	        if (keyCode.equalsIgnoreCase("left")) return Keyboard.KEY_LEFT;
	       
	        if (keyCode.equalsIgnoreCase("del")) return Keyboard.KEY_DELETE;
	        if (keyCode.equalsIgnoreCase("insert")) return Keyboard.KEY_INSERT;
	        if (keyCode.equalsIgnoreCase("end")) return Keyboard.KEY_END;
	        if (keyCode.equalsIgnoreCase("home")) return Keyboard.KEY_HOME;
	        if (keyCode.equalsIgnoreCase("lshift")) return Keyboard.KEY_LSHIFT;
	        if (keyCode.equalsIgnoreCase("tab")) return Keyboard.KEY_TAB;
	        if (keyCode.equalsIgnoreCase(".")) return Keyboard.KEY_PERIOD;
	        if (keyCode.equalsIgnoreCase("strg")) return Keyboard.KEY_LCONTROL;
	        if (keyCode.equalsIgnoreCase("alt")) return Keyboard.KEY_LMENU;
	        if (keyCode.equalsIgnoreCase("hashtag")) return Keyboard.KEY_SLASH;
	        if (keyCode.equalsIgnoreCase("rshift")) return Keyboard.KEY_RSHIFT;
	        if (keyCode.equalsIgnoreCase("none")) return 0;
	        if (keyCode.equalsIgnoreCase("minus")) return Keyboard.KEY_MINUS;
	       
	        return Integer.MAX_VALUE;
	    }
		public static String translateKeyBind(int keyCode) {
			if(keyCode == Keyboard.KEY_BACKSLASH) { return "^"; }
			if(keyCode == Keyboard.KEY_1) { return "1"; }
			if(keyCode == Keyboard.KEY_2) { return "2"; }
			if(keyCode == Keyboard.KEY_3) { return "3"; }
			if(keyCode == Keyboard.KEY_4) { return "4"; }
			if(keyCode == Keyboard.KEY_5) { return "5"; }
			if(keyCode == Keyboard.KEY_6) { return "6"; }
			if(keyCode == Keyboard.KEY_7) { return "7"; }
			if(keyCode == Keyboard.KEY_8) { return "8"; }
			if(keyCode == Keyboard.KEY_9) { return "9"; }
			if(keyCode == Keyboard.KEY_0) { return "0"; }
			if(keyCode == Keyboard.KEY_LBRACKET) { return "§"; }
			if(keyCode == Keyboard.KEY_RBRACKET) { return "'"; }
			if(keyCode == Keyboard.KEY_BACK) { return "Back"; }
			
			if(keyCode == Keyboard.KEY_TAB) { return "Tab"; }
			if(keyCode == Keyboard.KEY_SEMICOLON) { return "Semicolon"; }
			if(keyCode == Keyboard.KEY_ADD) { return "+"; }
			if(keyCode == Keyboard.KEY_RETURN) { return "Return"; }
			
			if(keyCode == Keyboard.KEY_SLASH) { return "#"; }
			if(keyCode == Keyboard.KEY_COMMA) { return ","; }
			if(keyCode == Keyboard.KEY_PERIOD) { return "."; }
			if(keyCode == Keyboard.KEY_MINUS) { return "-"; }
			if(keyCode == Keyboard.KEY_LSHIFT) { return "Shift"; }
			if(keyCode == Keyboard.KEY_RSHIFT) { return "RShift"; }
			if(keyCode == Keyboard.KEY_LCONTROL) { return "Strg"; }
			if(keyCode == Keyboard.KEY_RCONTROL) { return "R-Strg"; }
			if(keyCode == Keyboard.KEY_LMENU) { return "Alt"; }
			if(keyCode == Keyboard.KEY_SPACE) { return "Space"; }
			if(keyCode == Keyboard.KEY_APPS) { return "AltGr"; }
			
			if(keyCode == Keyboard.KEY_A) { return "A"; }
			if(keyCode == Keyboard.KEY_B) { return "B"; }
			if(keyCode == Keyboard.KEY_C) { return "C"; }
			if(keyCode == Keyboard.KEY_D) { return "D"; }
			if(keyCode == Keyboard.KEY_E) { return "E"; }
			if(keyCode == Keyboard.KEY_F) { return "F"; }
			if(keyCode == Keyboard.KEY_G) { return "G"; }
			if(keyCode == Keyboard.KEY_H) { return "H"; }
			if(keyCode == Keyboard.KEY_I) { return "I"; }
			if(keyCode == Keyboard.KEY_J) { return "J"; }
			if(keyCode == Keyboard.KEY_K) { return "K"; }
			if(keyCode == Keyboard.KEY_L) { return "L"; }
			if(keyCode == Keyboard.KEY_M) { return "M"; }
			if(keyCode == Keyboard.KEY_N) { return "N"; }
			if(keyCode == Keyboard.KEY_O) { return "O"; }
			if(keyCode == Keyboard.KEY_P) { return "P"; }
			if(keyCode == Keyboard.KEY_Q) { return "Q"; }
			if(keyCode == Keyboard.KEY_R) { return "R"; }
			if(keyCode == Keyboard.KEY_S) { return "S"; }
			if(keyCode == Keyboard.KEY_T) { return "T"; }
			if(keyCode == Keyboard.KEY_U) { return "U"; }
			if(keyCode == Keyboard.KEY_V) { return "V"; }
			if(keyCode == Keyboard.KEY_W) { return "W"; }
			if(keyCode == Keyboard.KEY_X) { return "X"; }
			if(keyCode == Keyboard.KEY_Y) { return "Y"; }
			if(keyCode == Keyboard.KEY_Z) { return "Z"; }
			return "/";
		}

		public int macroStage;
	public boolean run(String message){
	    if(message.startsWith("#")){
	        this.handleSendIRC(message);
	        return true;
        }
        if(message.startsWith(".macro") || this.macroStage != 0){
            this.execute_Macro(message);
            return true;
        }
        if(message.startsWith(".color")){
            this.execute_Color(message);
            return true;
        }
		if(message.startsWith(".bind")){
			this.execute_BIND(message);
			return true;
		}
		if(message.startsWith(".fucker")){
			this.execute_Fucker(message);
			return true;
		}
        if(message.startsWith(".tog")){
            return true;
        }
		if(message.startsWith(".config")){
		    this.execute_Config(message);
		    return true;
        }
        if(message.startsWith(".watermark")){
            this.execute_Watermark(message);
            this.saveTheme(Main.getMain.mainFile);
            return true;
        }
        if(message.startsWith(".tabgui")){
            this.execute_TabGui(message);
            this.saveTheme(Main.getMain.mainFile);
            return true;
        }
        if(message.startsWith(".arraylist")){
            this.execute_Arraylist(message);
            this.saveTheme(Main.getMain.mainFile);
            return true;
        }
        if(message.startsWith(".friend")){
            this.execute_Friends(message);
            return true;
        }

		for(Module mod : Main.getMain.moduleManager.getModules()){
			String[] split = message.split(" ");
				if(split[0].equalsIgnoreCase("."+mod.name)){
				if(split.length < 2){
					this.sendChatMessage("Usage : .(modulename) info  to get Information about the module");
					this.sendChatMessage("Usage : .(modulename) (valuename) (value) to change a value of the module");
					return true;
				}else{
					if(split[1].equalsIgnoreCase("info")){
						this.sendChatMessage("Info of module : " + mod.name);
						this.sendChatMessage("Category : " + mod.category.name());
						this.sendChatMessage("KeyBind : " + this.translateKeyBind(mod.keyBind));
						this.sendChatMessage("Enabled " + mod.getState);
						this.sendChatMessage("Values ");
						for(Value v : mod.values){
							if(v instanceof ValueBoolean){
								ValueBoolean vb = (ValueBoolean) v;
								this.sendChatMessage(vb.getName() + " : " + vb.getValue());
							}else{
								ValueDouble vd = (ValueDouble) v;
								this.sendChatMessage(vd.getName() + " : " + vd.getValue());
							}
						}
						return true;
					}
					
					for(Value v : mod.values){
					if(split[1].equalsIgnoreCase(v.getName())){
						if(split.length < 2){
							this.sendChatMessage("Usage : ."+mod.name+" " + v.getName() + "(value)");
							return true;
						}
						if(v instanceof ValueBoolean){
							ValueBoolean vb = (ValueBoolean) v;
							try{
								boolean enable = Boolean.parseBoolean(split[2]);
								vb.setValue(enable);
								this.sendChatMessage("Succesfully changed value");
								return true;
							}catch(Exception e){
								this.sendChatMessage(v.getName() + " can only be 'true' or 'false'");
								return true;
							}
						}else{
							ValueDouble vd = (ValueDouble) v;
							try{
								double newvalue = Double.parseDouble(split[2]);
								vd.setValue(newvalue);
								this.sendChatMessage("Succesfully changed value");
								return true;
							}catch(Exception e){
								this.sendChatMessage(split[2] +" is not a number");
								return true;
							}
						}
					}
				}
				}
				this.sendChatMessage("Usage : .(modulename) info  to get Information about the module");
				this.sendChatMessage("Usage : .(modulename) (valuename) (value) to change a value of the module");
				return true;
			}
		}
		return false;
	}

	public void execute_Friends(String message){
        String[] splitString = message.split(" ");
        if(splitString.length < 4){
            this.sendChatMessage("Usage : .friend add (playername) (newname)");
        }else{
            if(splitString[1].equalsIgnoreCase("add")) {
                try {
                    FriendManager.friends.put(splitString[2], new String[]{splitString[3], this.getUUIDFromName(splitString[3])});
                } catch (Exception e) {
                    e.printStackTrace();
                }
                this.sendChatMessage("Succesfully added " + splitString[2] + "as" + splitString[3]);
            }else{
                this.sendChatMessage("Usage : .friend add (playername) (newname)");
            }
        }
        FriendManager.saveFriendrs(Main.getMain.friend);
    }
    public static String getUUIDFromName(String username)
            throws Exception
    {

        return " ";
    }
    public void execute_Arraylist(String string){
        String[] splitString = string.split(" ");
        if(splitString.length < 2){
            this.sendChatMessage("Usage : .watermark (themename) : use .watermark list to see all themes");
        }else{
            if(splitString[1].equalsIgnoreCase("list")){
                this.sendChatMessage("§bList of all watermark themes");
                this.sendChatMessage("Default");
                this.sendChatMessage("Other");
                this.sendChatMessage("Classic");
                this.sendChatMessage("Sun");
                this.sendChatMessage("None");
            }
            if(splitString[1].equalsIgnoreCase("Default")){
                Main.getMain.arrayList = new ArrayListD();
            }
            if(splitString[1].equalsIgnoreCase("Other")){
                Main.getMain.arrayList = new ArrayListD2();
            }
            if(splitString[1].equalsIgnoreCase("Classic")){
                Main.getMain.arrayList = new ArrayListC();
            }
            if(splitString[1].equalsIgnoreCase("Sun")){
                Main.getMain.arrayList = new ArrayListS();
            }
            if(splitString[1].equalsIgnoreCase("None")){
                Main.getMain.arrayList = new ArrayList();
            }
        }

    }

    public void execute_Color(String message){

        String[] splitString = message.split(" ");
        if(splitString.length != 2 && splitString.length != 4){
            this.sendChatMessage("Usage :.color (color) or .color (red) (green) (blue)");
        }else{
            if(splitString.length == 2){
                try{
                    Main.getMain.clientColor = new Color(Integer.parseInt(splitString[1]));
                }catch (Exception e){
                    try {
                        this.sendChatMessage(splitString[2] + "Is not a Color");
                    }catch (Exception ex) {
                        this.sendChatMessage("§4Critical Error");
                    }
                }
            }else{
                try{
                    Main.getMain.clientColor = new Color(Integer.parseInt(splitString[1]),Integer.parseInt(splitString[2]),Integer.parseInt(splitString[3]));
                }catch (Exception e){
                    this.sendChatMessage(splitString[2] + " " +splitString[3] +" " +splitString[1]+  "Is not a Color");
                }
            }
        }
        this.saveTheme(Main.getMain.mainFile);
    }

	public void execute_Watermark(String string){
	    String[] splitString = string.split(" ");
	    if(splitString.length < 2){
	        this.sendChatMessage("Usage : .watermark (themename) : use .watermark list to see all themes");
        }else{
	        if(splitString[1].equalsIgnoreCase("list")){
	            this.sendChatMessage("§bList of all watermark themes");
	            this.sendChatMessage("Default");
                this.sendChatMessage("Stamina");
                this.sendChatMessage("Classic");
                this.sendChatMessage("Sky");
                this.sendChatMessage("None");
            }
            if(splitString[1].equalsIgnoreCase("Sky")){
                Main.getMain.waterMark = new WatermarkSky();
            }
            if(splitString[1].equalsIgnoreCase("Default")){
	            Main.getMain.waterMark = new WatermarkD();
            }
            if(splitString[1].equalsIgnoreCase("Stamina")){
                Main.getMain.waterMark = new WatermarkS();
            }
            if(splitString[1].equalsIgnoreCase("Classic")){
                Main.getMain.waterMark = new WatermarkC();
            }
            if(splitString[1].equalsIgnoreCase("None")){
                Main.getMain.waterMark = new Watermark();
            }
        }

    }

    public void execute_TabGui(String string){
    String[] splitString = string.split(" ");
	    if(splitString.length < 2){
        this.sendChatMessage("Usage : .tabgui (themename) : use .tabgui list to see all themes");
    }else {
            if (splitString[1].equalsIgnoreCase("list")) {
                this.sendChatMessage("§bList of all watermark themes");
                this.sendChatMessage("Default");
                this.sendChatMessage("Circle");
                this.sendChatMessage("Shade");
                this.sendChatMessage("None");
            }
            if (splitString[1].equalsIgnoreCase("Default")) {
                Main.getMain.tabGui = new TabGuiD();
            }
            if (splitString[1].equalsIgnoreCase("None")) {
                Main.getMain.tabGui = new TabGui();
            }
            if (splitString[1].equalsIgnoreCase("Circle")) {
                Main.getMain.tabGui = new TabGuiC();
            }
            if (splitString[1].equalsIgnoreCase("Shade")) {
                Main.getMain.tabGui = new TabGuiS();
            }
        }
	}
	public void execute_BIND(String string){
		String[] split = string.split(" ");
		if(split.length < 2){
			this.sendChatMessage("Use " + this.prefix+" add + (modulename) + (key)");
        }else{
			if(split[1].equalsIgnoreCase("add")){
				if(split.length < 4){
					if(split.length > 2){
						this.sendChatMessage("Wrong Usage " + this.prefix+" add "+split[2]+" (key)");
					}else{
						this.sendChatMessage("Wrong Usage " + this.prefix+" add (modulename) (key)");
					}
				}else{
					Module modToEdit = null;
					for(Module mod : Main.getMain.moduleManager.modules){
						if(mod.name.equalsIgnoreCase(split[2])){
							modToEdit = mod;
						}
					}
					if(modToEdit == null){
						this.sendChatMessage("Module "+split[2]+" not found");
						return;
					}
					int keybind = this.keyStringToIntID(split[3]);
					if(keybind == Integer.MAX_VALUE){
						this.sendChatMessage("cannot bind on "+split[3]);
						return;
					}
					modToEdit.keyBind = keybind;
					this.sendChatMessage("Succesfully bound " +split[2]+ " to " +split[3]);
				}
			}
		}
	}

	public void execute_Config(String string){
	    String[] splitString = string.split(" ");
	    if(splitString.length < 2){
	        this.sendChatMessage("Wrong Usage : .config save/load (configname)");
	        return;
        }else{
	        if(splitString[1].equalsIgnoreCase("save")){
                    try {
                    Main.getMain.moduleManager.saveModule(new File(Main.getMain.configs, (splitString[2]+".nght")));
                    this.sendChatMessage("Succesfully saved config for " + splitString[2]);
                } catch (IOException e) {
                    this.sendChatMessage("Failed creating config " + e.getStackTrace());
                }

            }else if(splitString[1].equalsIgnoreCase("load")){
	            try {


                Main.getMain.moduleManager.loadModules(new File(Main.getMain.configs, (splitString[2]+".nght")));
                this.sendChatMessage("Succesfully loaded config " + splitString[2]);

                }catch (Exception e){
                    this.sendChatMessage("Failed loading config " + e.getStackTrace());
                }
            }else{
                this.sendChatMessage("Wrong Usage : .config save/load (configname)");
            }

        }
    }

    public void saveTheme(){

    }

	public String key;
	public void execute_Macro(String string) {
        String[] splitString = string.split(" ");
        if(splitString.length > 1) {
            if (splitString[1].equalsIgnoreCase("clear")) {
                Main.getMain.macroManager.macroArrayList.clear();
                return;
            }
            if (splitString[1].equalsIgnoreCase("cancel")) {
                key = "";
                this.sendChatMessage("canceled creation of macro");
                this.macroStage = 0;
                return;
            }
        }
        if (this.macroStage == 0) {
            if(splitString.length > 1){
            if (splitString[1].equalsIgnoreCase("createNew")) {
                key = "";
                macroStage = 1;
                this.sendChatMessage("specify the keybind of your macro");
                return;
            }
            }
        } else if (macroStage == 1) {
            int keybind = this.keyStringToIntID(splitString[1]);
            if (keybind == Integer.MAX_VALUE) {
                this.sendChatMessage("cannot bind on " + splitString[1]);
                return;
            }else {
                key += keybind+"@@";
                macroStage = 2;
                this.sendChatMessage("specify the module your macro should affect");
            }

        }else if(macroStage == 2){
            String module = splitString[1];
            Module mod = null;
            for(Module modules : Main.getMain.moduleManager.getModules()){
                if(modules.name.equalsIgnoreCase(module)){
                    mod = modules;
                }
            }
            if(mod == null){
                this.sendChatMessage("this module doesnt exist");
                return;
            }else{
                key += module + "%%";
                this.sendChatMessage("specify the actions of your module");
                macroStage = 3;
                return;
            }
        }else if(macroStage == 3){
            Macro.enumMode enumMode = new Macro("").decryptKeyAction(splitString[1]);
            if(splitString[1].equalsIgnoreCase("finish")){
                this.macroStage = 0;
                this.sendChatMessage("finished creation of your macro");
                Main.getMain.macroManager.macroArrayList.add(new Macro(key));
                return;
            }
            if(splitString[1].equalsIgnoreCase("keys")){
                this.sendChatMessage("§fEAVB §c : EnableAllValueBooleans : Enables every toggle value of the module");
                this.sendChatMessage("§fDAVB §c : DisableAllValueBooleans : Disables every toggle value of the module");
                this.sendChatMessage("§fTVB §c : ToggleValueBoolean : Toggles specific toggle value");
                this.sendChatMessage("§fSVD §c : SetValueDouble : Sets the value of specific value");
                return;
            }
            if(enumMode == null){
                this.sendChatMessage("Unknown key, please try again : use .macro keys to get a list of all possible keys");
                return;
            }
            switch (enumMode){

                case DisableAllValuesBoolean:
                    key +="DAVB::";
                    this.sendChatMessage("succesfully added DisableAllValueBooleans event : use .macro finish to save your macro");
                    break;
                case EnableAllValuesBoolean:
                    key +="EAVB::";
                    this.sendChatMessage("succesfully added EnableallValueBooleans event : use .macro finish to save your macro");
                    break;
                case EnableValueBoolean:
                    key +="EVB__";
                    this.sendChatMessage("specify wich value should be affected by EnableValueBoolean event");
                    macroStage = 4;
                    break;
                case DisableValueBoolean:
                    key +="DVB__";
                    this.sendChatMessage("specify wich value should be affected by DisableValueBoolean event");
                    macroStage = 4;
                    break;
                case ToggleValueBoolean:
                    key +="TVB__";
                    this.sendChatMessage("specify wich value should be affected by ToggleValueBoolean event");
                    macroStage = 4;
                    break;
                case SetValueDouble:
                    key +="SVD__";
                    this.sendChatMessage("specify wich value should be affected by SetValueDouble event");
                    macroStage = 5;
                    break;
            }
        }else if(macroStage == 4){
            key += splitString[1] + "::";
            this.sendChatMessage("set affected value to" + splitString[1] + " : " + "use .macro finish or add another Event");
            macroStage = 3;
        }else if(macroStage == 5){
            key += splitString[1] + "__";
            this.sendChatMessage("set affected value to" + splitString[1] + " : " + "use .macro finish or add another Event");
            macroStage = 6;
        }else if(macroStage == 6){
            try{
                double value = Double.parseDouble(splitString[1]);
                key += value + "::";
                macroStage = 3;
                this.sendChatMessage("succesfully added SetValueDouble event : use .macro finish to save your macro");
            }catch (Exception e){

            }
        }
    }
	public void execute_Fucker(String string){
		String[] split = string.split(" ");
		if(split.length < 2){
			this.sendChatMessage("Use .fucker range to set the range of fucker");
			this.sendChatMessage("Use .fucker set to set the type of block that fucker will target");		
		}else{
			String cmd = split[1];
			if(cmd.equalsIgnoreCase("range")){
				if(split.length < 3){
					this.sendChatMessage("Use .fucker range (range)");
				}else{
					try{
						String value = split[2];
						((Fucker)Main.getMain.moduleManager.getModule(Fucker.class)).range.setValue(Double.parseDouble(value));
						this.sendChatMessage("Succesfully set the range to : " + value);
					}catch(Exception e){
						String value = split[2];
						this.sendChatMessage("Invald value : " + value);
					}
				}
			}else if(cmd.equalsIgnoreCase("set")){
				if(split.length < 3){
					this.sendChatMessage("Use .fucker set (block)");
				}else{
					try{
						int value = Integer.parseInt(split[2]);
						this.sendChatMessage("Please use block name");
					}catch(Exception e){
						String blockname = split[2];
						Block block = null;
						if(Block.getBlockFromName(blockname) == null){
							this.sendChatMessage("Unknown Block : " + blockname);
						}else{
							int id = Block.blockRegistry.getIDForObject( Block.getBlockFromName(blockname));
							((Fucker)Main.getMain.moduleManager.getModule(Fucker.class)).id.setValue(id);
							this.sendChatMessage("Fucker will now destroy " + Block.getBlockFromName(blockname).getUnlocalizedName());
							
						
						}
						
					}
				}
				
			}else{
				this.sendChatMessage("Unknown command : .fucker " + cmd);
				this.sendChatMessage("Use .fucker range to set the range of fucker");
				this.sendChatMessage("Use .fucker set to set the type of block that fucker will target");
			}
		}
	}
	
	
	
}

minecraft_de_Client_Main_Main.java

package de.Client.Main;


import de.Client.Events.EventManager;
import de.Client.Main.Commands.CommandManager;
import de.Client.Main.Modules.ModuleManager;
import de.Client.Render.ArrayLists.ArrayListC;
import de.Client.Render.ArrayLists.ArrayListD;
import de.Client.Render.ArrayLists.ArrayListD2;
import de.Client.Render.ArrayLists.ArrayListS;
import de.Client.Render.ClickGui.ClickGui;
import de.Client.Render.NahrFontRenderer;
import de.Client.Render.TTFManager;
import de.Client.Render.TabGuis.TabGuiC;
import de.Client.Render.TabGuis.TabGuiD;
import de.Client.Render.TabGuis.TabGuiS;
import de.Client.Render.Watermarks.WatermarkC;
import de.Client.Render.Watermarks.WatermarkD;
import de.Client.Render.Watermarks.WatermarkS;
import de.Client.Render.Watermarks.WatermarkSky;
import de.Client.Utils.*;
import de.Client.Utils.ArrayList;
import net.minecraft.client.Minecraft;
import org.newdawn.slick.*;
import java.awt.*;
import java.awt.Color;
import java.awt.Font;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.util.*;



public class Main {

    public void setupTheme(){
        for(String bind : readFile(this.mainFile)) {
            System.out.println(bind + ("" + new WatermarkSky().getClass()) );
            if(bind.startsWith("Color")){
                String s = bind.replace("Color + ","");
                Main.getMain.clientColor = new Color(Integer.parseInt(s));
            }
            if(bind.startsWith("Watermark")){
                String s = bind.replace("Watermark + ","");
                if(("" + new WatermarkSky().getClass()).equalsIgnoreCase(s) ){
                    Main.getMain.waterMark = new WatermarkSky();
                }
                if(("" + new WatermarkD().getClass()).equalsIgnoreCase(s)){
                    Main.getMain.waterMark = new WatermarkD();
                }
                if(("" + new WatermarkS().getClass()).equalsIgnoreCase(s)){
                    Main.getMain.waterMark = new WatermarkS();
                }
                if(("" + new WatermarkC().getClass()).equalsIgnoreCase(s)){
                    Main.getMain.waterMark = new WatermarkC();
                }
            }
            if(bind.startsWith("TabGui")){
                String s = bind.replace("TabGui + ","");
                if(("" + new TabGuiD().getClass()).equalsIgnoreCase(s) ){
                    Main.getMain.tabGui = new TabGuiD();
                }
                if(("" + new TabGuiC().getClass()).equalsIgnoreCase(s)){
                    Main.getMain.tabGui = new TabGuiC();
                }
                if(("" + new TabGuiS().getClass()).equalsIgnoreCase(s)){
                    Main.getMain.tabGui = new TabGuiS();
                }
            }
            if(bind.startsWith("ArrayList")){
                String s = bind.replace("ArrayList + ","");
                if(("" + new ArrayListD().getClass()).equalsIgnoreCase(s) ){
                    Main.getMain.arrayList = new ArrayListD();
                }
                if(("" + new ArrayListS().getClass()).equalsIgnoreCase(s)){
                    Main.getMain.arrayList = new ArrayListS();
                }
                if(("" + new ArrayListC().getClass()).equalsIgnoreCase(s)){
                    Main.getMain.arrayList = new ArrayListC();
                }
                if(("" + new ArrayListD2().getClass()).equalsIgnoreCase(s)){
                    Main.getMain.arrayList = new ArrayListD2();
                }
            }
        }
    }

    public String[] readFile(File file) {
        if(file.exists()) {
            try {
                FileReader fileReader = new FileReader(file);
                BufferedReader bufferedReader = new BufferedReader(fileReader);
                java.util.List<String> lines = new java.util.ArrayList();
                String line = null;
                while ((line = bufferedReader.readLine()) != null) {
                    lines.add(line);
                }
                bufferedReader.close();
                return (String[]) lines.toArray(new String[lines.size()]);
            } catch (Exception ignored) {
            }
        } else {
            System.out.println("[SkyRise] - Bind-Datei existiert nicht!");
        }
        return null;
    }

	public void startClient(){
        RenderAPI2d.loadTextures();
		if(!mainFolder.exists()){
			mainFolder.mkdirs();
		}
		if(!moduleStuff.exists()){
			moduleStuff.mkdirs();
		}
		if(!moduleSave.exists()){
			try {
				moduleSave.createNewFile();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		if(!this.altStuff.exists()){
			this.altStuff.mkdirs();
		}if(!this.configs.exists()){
            this.configs.mkdirs();
        }

		if(!this.altList.exists()){
			try {
				this.altList.createNewFile();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		if(!friendStuff.exists()){
                this.altList.mkdir();
        }
        if(!this.friend.exists()){
            try {
                this.friend.createNewFile();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        if(!this.mainFile.exists()){
            try {
                this.mainFile.createNewFile();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }else{
            setupTheme();
        }
		Main.getMain.moduleManager.loadModules(this.moduleSave);
		macroManager.init();
		FriendManager.setFriends(friend);
        new Thread(() -> {
            //Main.getMain.ircManager.connect();
            try{
                long lastTime = System.nanoTime();
                final double ticks = 60D;
                double ns = 1000000000 / ticks;
                double delta = 0;

                while(true){
                    long now = System.nanoTime();
                    delta += (now - lastTime) / ns;
                    lastTime = now;
                    if(delta >= 3){
                        Main.getMain.tabGui.upDateAnimations();
                        if(Minecraft.getMinecraft().currentScreen instanceof ClickGui) {
                            Main.getMain.getClickGui.updateAnimation();
                        }
                        delta--;
                    }
                }
            }catch(Exception ignored){
            }
        }).start();

        this.c.run();
	}
    public TTFManager mainmenu= new TTFManager("Verdana",Font.PLAIN,15);
    public TTFManager mainmenu2= new TTFManager("BigNoodleTitling",Font.PLAIN,350);
	public RenderAPI2d renderer2d = new RenderAPI2d();
	public CommandManager cmdManager = new CommandManager();
	public TabGui tabGui = new TabGuiD();
    public Watermark waterMark = new WatermarkD();
    public ArrayList arrayList = new ArrayListD();
	public ModuleManager moduleManager = new ModuleManager();
	public static Main getMain = new Main();
	public TTFManager watermark= new TTFManager("Razed Trend",Font.PLAIN,52);
	public TTFManager verdana =new TTFManager("Verdana",Font.PLAIN,25);
    public TTFManager verdanas =new TTFManager("Verdana",Font.PLAIN,22);
	public File mainFolder = new File(Minecraft.getMinecraft().mcDataDir,"Night");
	public File moduleStuff = new File(mainFolder,"ModuleStuff");
    public File configs = new File(mainFolder,"Configs");
    public File friendStuff = new File(mainFolder,"FriendStuff");
    public File friend = new File(mainFolder,"friend.nght");
    public File altStuff = new File(mainFolder,"AltStuff");
	public File altList = new File(altStuff,"alts.nght");
	public File moduleSave = new File(moduleStuff,"modules.nght");
    public File mainFile = new File(mainFolder,"main.nght");
	public ControllerAPI controllerAPI = new ControllerAPI();
	public ClickGui getClickGui = new ClickGui();
    public MacroManager macroManager = new MacroManager();
    public IRC ircManager = new IRC("T_D");
    public ClientUpdateThread c = new ClientUpdateThread();
	public int theme;

	public Color clientColor = new Color(0xff4b0082);

	public void setColor(){
        int color = 0xff4b0082;
        if(this.theme == 1){
            color = 0xff2ECC71;
        }
        if(this.theme == 2){
            color = 0xff19B5FE;
        }
        if(this.theme == 3){
            color = 0xff2ABB9B;
        }
        if(this.theme == 4){
            color = 0xffDB0A5B;
        }
        if(this.theme == 5){
            color = 0xffF5AB35;
        }
        clientColor = new Color(color);
    }

	public Color getClientColor(){
		return clientColor;
	}
    public Color getPurple(double fade,int speed){
        double fader = ((System.nanoTime() /speed/4.0d) +fade/4.0d) % 200;
        fader -= 100;
        if(fader < 0){
            fader *= -1;
        }
        fader +=60;
        Color c = new Color(Main.getMain.getClientColor().getRGB());
        int red = (int) (c.getRed() *  (fader/90 ));
        int green  = (int) (c.getGreen() *  (fader/90 ));
        int blue  = (int) (c.getBlue()*  (fader /90));
        if(red > 255){
            red = 255;
        }
        if(green > 255){
            green = 255;
        }
        if(blue > 255){
            blue = 255;
        }
        return  new Color(red,green,blue);
    }
	 public Color getPurple1(double fade,int speed){
			double fader = ((System.nanoTime() /speed) +fade) % 800;
			fader -= 400;
			if(fader < 0){
				fader *= -1;
			}
			fader +=150;
			int red = (int) (fader / 2);
			int green = (int) (fader / 20);
			int blue = (int) fader;
			if(red > 255){
				red = 255;
			}
			if(green > 255){
				green = 255;
			}
			if(blue > 255){
				blue = 255;
			}
			if(theme == 0){
				return new Color(red,green,blue);
			}
			if(theme == 1){
				return new Color(red,blue,green);
			}
			if(theme == 2){
				return new Color(green,red,blue);
			}
			if(theme == 3){
				return new Color(green,blue,red);
			}
			if(theme == 4){
				return new Color(blue,green,red);
			}
			if(theme == 5){
				return new Color(blue,red,green);
			}
			return null;
		}

}

minecraft_de_Client_Main_Modules_Category.java

package de.Client.Main.Modules;

public enum Category {
	COMBAT,
	MOVEMENT,
	PLAYER,
	WORLD,
	RENDER,
	None,
	Gui,
	
}

minecraft_de_Client_Main_Modules_mods_Combat_Criticals.java

package de.Client.Main.Modules.mods.Combat;

import de.Client.Events.EventTarget;
import de.Client.Events.Events.PacketSendEvent;
import de.Client.Main.Main;
import de.Client.Main.Modules.Category;
import de.Client.Main.Modules.Module;
import de.Client.Main.Modules.ModuleManager;
import de.Client.Main.Modules.mods.Movment.Glide;
import net.minecraft.entity.Entity;
import net.minecraft.network.play.client.C02PacketUseEntity;
import net.minecraft.network.play.client.C03PacketPlayer;
import org.lwjgl.input.Keyboard;

public class Criticals extends Module {

	public Criticals() {
		super("Criticals", Category.COMBAT, Keyboard.KEY_NONE);
	}

	@EventTarget
	public void onPacketSend(PacketSendEvent e) {
		if (this.getState()) {
		    if(Main.getMain.moduleManager.getModule(KillAura.class).getState){
		        if(((KillAura) Main.getMain.moduleManager.getModule(KillAura.class)).Tick.getValue()){
		            return;
                }
            }
		    if(Main.getMain.moduleManager.getModule(Glide.class).getState){
		        if(((Glide) Main.getMain.moduleManager.getModule(Glide.class)).hypixel.getValue()){
		            return;
                }
            }

			if (e.getPacket() instanceof C02PacketUseEntity) {
				Entity entity = ((C02PacketUseEntity) e.getPacket()).entity;
				if(entity.hurtResistantTime > 12 || !mc.thePlayer.onGround){
					return;
				}

				this.mc.getNetHandler().addToSendQueue(new C03PacketPlayer.C04PacketPlayerPosition(
						this.mc.thePlayer.posX, this.mc.thePlayer.posY + 0.12D, this.mc.thePlayer.posZ, false));
				this.mc.getNetHandler().addToSendQueue(new C03PacketPlayer.C04PacketPlayerPosition(
						this.mc.thePlayer.posX, this.mc.thePlayer.posY, this.mc.thePlayer.posZ, false));



			}


		}
	}

}

minecraft_de_Client_Main_Modules_mods_Combat_KillAura.java

package de.Client.Main.Modules.mods.Combat;

import de.Client.Events.EventTarget;
import de.Client.Events.Events.UpdateEvent;
import de.Client.Events.IEvent.State;
import de.Client.Main.Main;
import de.Client.Main.Modules.Category;
import de.Client.Main.Modules.Module;
import de.Client.Main.Modules.mods.Movment.NoSlowDown;
import de.Client.Main.Modules.mods.Movment.Speed;
import de.Client.Main.Modules.mods.Player.Autotool;
import de.Client.Main.Values.Value;
import de.Client.Main.Values.ValueBoolean;
import de.Client.Main.Values.ValueDouble;
import de.Client.Utils.FriendManager;
import de.Client.Utils.TimeHelper;
import net.minecraft.client.Minecraft;
import net.minecraft.entity.Entity;
import net.minecraft.entity.EntityLiving;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.entity.monster.EntityMob;
import net.minecraft.entity.passive.EntityAnimal;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.ItemSword;
import net.minecraft.network.Packet;
import net.minecraft.network.play.client.*;
import net.minecraft.util.BlockPos;
import net.minecraft.util.EnumFacing;
import net.minecraft.util.EnumParticleTypes;
import net.minecraft.util.MathHelper;
import org.lwjgl.Sys;
import org.lwjgl.input.Keyboard;
import org.lwjgl.opengl.Display;

import java.util.ArrayList;
import java.util.Random;

public class KillAura extends Module {
    public ValueDouble targets = new ValueDouble("maxtargets", 3, 10, 10);
    public ValueDouble rotationSpeed = new ValueDouble("rotationSpeed", 10, 300, 300);
    public ValueBoolean single = new ValueBoolean("single", false);
    public ValueDouble delay = new ValueDouble("delay", 80, 300, 300);
    public ValueDouble Range = new ValueDouble("Range", 4, 10, 10);
    public ValueBoolean hitbots = new ValueBoolean("hitbots", false);
    public ValueBoolean heuristic = new ValueBoolean("heuristic", false);
    public ValueBoolean AAC = new ValueBoolean("AAC",false);
    public ValueBoolean Tick = new ValueBoolean("Tick",false);
    public ValueBoolean Autoblock = new ValueBoolean("Autoblock",false);
    public ValueBoolean Player = new ValueBoolean("Player",true);
    public ValueBoolean Animals = new ValueBoolean("Animals",false);
    public ValueBoolean Mobs = new ValueBoolean("Mobs",false);
    public int circlerotation;

    public Entity entityToAttack;

    public ArrayList<EntityLivingBase> entitestoAttack = new ArrayList();

    public boolean reset;
    public TimeHelper time2 = new TimeHelper();
    public TimeHelper time = new TimeHelper();

    public ArrayList<EntityLivingBase> entities = new ArrayList();



    public KillAura() {
        super("KillAura", Category.COMBAT, Keyboard.KEY_Y);
        addValue(this.targets);
        addValue(this.single);
        addValue(this.delay);
        addValue(this.Range);
        addValue(this.rotationSpeed);
        addValue(this.hitbots);
        addValue(this.heuristic);
        addValue(this.Tick);
        addValue(this.Autoblock);
        addValue(this.AAC);
        addValue(Player);
        addValue(Mobs);
        addValue(Animals);
        this.displayName = "Kill Aura";
    }

    public void onEnable() {
        yaw = mc.thePlayer.rotationYaw;
        pitch = mc.thePlayer.rotationPitch;
        new Thread(){
            @Override
            public void run(){
                while(Main.getMain.moduleManager.getModule(KillAura.class).getState) {
                    try {

                        KillAura k = (KillAura) Main.getMain.moduleManager.getModule(KillAura.class);
                        entities.clear();
                        entities = getCloseEnteties(Range.getValue()+1);
                        int targets = 0;
                        targets = (int) (k.single.getValue() ? 1 : k.targets.getValue());
                        if (targets > k.getCloseEnteties(k.Range.getValue()).size()) {
                            targets = k.getCloseEnteties(k.Range.getValue()).size();
                        }
                        if (k.entitestoAttack.size() < targets ) {
                            for (int i = 0; i < targets - k.entitestoAttack.size(); ++i) {
                                Entity e = k.getEntity();
                                entityToAttack = e;
                                k.entitestoAttack.add((EntityLivingBase) e);
                                time.reset();
                            }
                        }else{
                        }
                        for (int i = 0; i < k.entitestoAttack.size(); ++i) {
                            if (k.entitestoAttack.get(i) != null) {
                                Entity entity = k.entitestoAttack.get(i);
                                if (mc.thePlayer.getDistanceToEntity(entity) > k.Range.getValue()) {
                                    k.entitestoAttack.remove(entity);
                                }
                                if (entity.isDead) {
                                    k.entitestoAttack.remove(entity);
                                }
                            }
                        }
                    }catch (Exception e){

                    }
                }
            }
        }.start();

    }

    public void attack(Entity e) {
        if(e == null){
            return;
        }
        //    mc.thePlayer.setPosition(e.posX,e.posY,e.posZ);
        if (this.hitbots.getValue()) {
            //  Main.getMain.cmdManager.sendChatMessage("attacking " + e.getName());
            for (Object en : mc.theWorld.loadedEntityList) {
                if(en instanceof EntityLivingBase) {
                    EntityLivingBase entity = (EntityLivingBase) en;
                    if (entity.isChild()) {
                        //          Main.getMain.cmdManager.sendChatMessage("just a baby - dont care" + e.getName());
                    }
                    if (entity.getDistanceToEntity(e) < 1 && entity.isInvisible() &&!entity.isChild()&& !(entity == mc.thePlayer) && entity.getDistanceToEntity(mc.thePlayer) <= e.getDistanceToEntity(mc.thePlayer)) {
                        e = entity;

                    }
                }
            }
        }

        if(e.hurtResistantTime < 15) {
            mc.thePlayer.swingItem();
        }else {
            mc.thePlayer.sendQueue.addToSendQueue(new C0APacketAnimation());
        }
        mc.thePlayer.sendQueue.addToSendQueue(new C02PacketUseEntity(e, C02PacketUseEntity.Action.ATTACK));
    }
    public void attackAACTick(Entity e) {

        mc.thePlayer.sendQueue.addToSendQueue(new C0BPacketEntityAction(mc.thePlayer,C0BPacketEntityAction.Action.STOP_SPRINTING));
      //  Main.getMain.cmdManager.sendChatMessage("attacking " + e.getName());
        for (Object en : mc.theWorld.loadedEntityList) {
            if(en instanceof EntityLivingBase) {
                EntityLivingBase entity = (EntityLivingBase) en;
                if (entity.isChild()) {
          //          Main.getMain.cmdManager.sendChatMessage("just a baby - dont care" + e.getName());
                }
                if (entity.getDistanceToEntity(e) < 1 && entity.isInvisible() &&!entity.isChild()&& !(entity == mc.thePlayer) && entity.getDistanceToEntity(mc.thePlayer) <= e.getDistanceToEntity(mc.thePlayer)) {
                    e = entity;

                }
            }
        }

        if(e != mc.objectMouseOver.entityHit && mc.objectMouseOver.entityHit != null){
            e = mc.objectMouseOver.entityHit;
           // Main.getMain.cmdManager.sendChatMessage(mc.objectMouseOver.entityHit+"");
        }
        //mc.thePlayer.swingItem();
        mc.thePlayer.sendQueue.addToSendQueue(new C02PacketUseEntity(e, C02PacketUseEntity.Action.ATTACK));
        mc.thePlayer.sendQueue.addToSendQueue(new C0BPacketEntityAction(mc.thePlayer,C0BPacketEntityAction.Action.START_SPRINTING));
    }
    public void attackTick(Entity e) {

        if (this.hitbots.getValue()) {
            Entity entityToHit = null;
            if (entityToHit instanceof EntityLivingBase) {
                if (entityToHit.isInvisible()) {
                    for (Object en : mc.theWorld.loadedEntityList) {
                        Entity entity = (Entity) en;
                        if (entity.getDistanceToEntity(e) < 0.6) {
                            if (entityToHit == null || entityToHit.getDistanceToEntity(mc.thePlayer) > entityToHit.getDistanceToEntity(mc.thePlayer)) {
                                entityToHit = entity;
                                //Main.getMain.cmdManager.sendChatMessage("Changing entity to " + entityToHit.getName());

                            }
                        }
                    }
                    if (entityToHit != null) {
                        e = entityToHit;
                    }
                }
            }
        }
        for(int i = 0; i < 9; ++i){
            mc.thePlayer.sendQueue.addToSendQueue(new C09PacketHeldItemChange(i));
        }
        mc.thePlayer.sendQueue.addToSendQueue(new C09PacketHeldItemChange(mc.thePlayer.inventory.currentItem));
        if(mc.thePlayer.onGround) {
            this.mc.getNetHandler().addToSendQueue(new C03PacketPlayer.C04PacketPlayerPosition(
                    this.mc.thePlayer.posX, this.mc.thePlayer.posY + 0.12D, this.mc.thePlayer.posZ, false));
            this.mc.getNetHandler().addToSendQueue(new C03PacketPlayer.C04PacketPlayerPosition(
                    this.mc.thePlayer.posX, this.mc.thePlayer.posY+0.001, this.mc.thePlayer.posZ, false));
        }
        for(int i = 0; i < 5; ++i) {
            mc.thePlayer.sendQueue.addToSendQueue(new C09PacketHeldItemChange(new Random().nextInt(9)));
            mc.thePlayer.sendQueue.addToSendQueue(new C09PacketHeldItemChange( mc.thePlayer.inventory.currentItem));
            mc.getNetHandler().addToSendQueue((Packet) new C07PacketPlayerDigging(C07PacketPlayerDigging.Action.RELEASE_USE_ITEM, BlockPos.ORIGIN, EnumFacing.DOWN));
            mc.thePlayer.swingItem();
            mc.thePlayer.sendQueue.addToSendQueue(new C02PacketUseEntity(e, C02PacketUseEntity.Action.ATTACK));
        }


    }

    public float getPitchChangeToEntity(Entity entity) {
        double deltaX = entity.posX - mc.thePlayer.posX;
        double deltaZ = entity.posZ - mc.thePlayer.posZ;
        double deltaY = entity.posY - 1.6D + entity.getEyeHeight() - mc.thePlayer.posY;
        double distanceXZ = MathHelper.sqrt_double(deltaX * deltaX + deltaZ * deltaZ);

        double pitchToEntity = -Math.toDegrees(Math.atan(deltaY / distanceXZ));

        return -MathHelper.wrapAngleTo180_float(mc.thePlayer.rotationPitch - (float) pitchToEntity);
    }

    public float getYawChangeToEntity(Entity entity) {
        double deltaX = entity.posX - mc.thePlayer.posX;
        double deltaZ = entity.posZ - mc.thePlayer.posZ;
        double yawToEntity;
        if ((deltaZ < 0.0D) && (deltaX < 0.0D)) {
            yawToEntity = 90.0D + Math.toDegrees(Math.atan(deltaZ / deltaX));
        } else {
            if ((deltaZ < 0.0D) && (deltaX > 0.0D)) {
                yawToEntity = -90.0D + Math.toDegrees(Math.atan(deltaZ / deltaX));
            } else {
                yawToEntity = Math.toDegrees(-Math.atan(deltaX / deltaZ));
            }
        }
        return MathHelper.wrapAngleTo180_float(-(circlerotation - (float) yawToEntity));
    }

    public int compare(Entity a, Entity b) {
        if (a != null && b != null) {
            float yaw = getYawChangeToEntity(a);
            float pitch = getPitchChangeToEntity(a);
            final float da = (yaw + pitch);

            yaw = getYawChangeToEntity(b);
            pitch = getPitchChangeToEntity(b);
            final float db = (yaw + pitch);
            return da < db ? -1 : 1;
        }
        return 0;
    }

    public Entity getEntity() {
        EntityLivingBase rotation = (EntityLivingBase) entities.stream().sorted(this::compare).findFirst().get();
        //Main.getMain.cmdManager.sendChatMessage(this.getYawChangeToEntity(rotation)+"");

            circlerotation += this.rotationSpeed.getValue();
        circlerotation %= 360;
        entities.remove(rotation);
        return rotation;
    }

    public ArrayList<EntityLivingBase> getCloseEnteties(double range) {
        ArrayList<EntityLivingBase> entities = new ArrayList<EntityLivingBase>();
        for (int i = 0; i < mc.theWorld.getLoadedEntityList().size(); ++i) {
            Object eraw = mc.theWorld.getLoadedEntityList().get(i);
            if (eraw instanceof EntityLivingBase) {
                if(!Teams.teammates.contains(((EntityLivingBase) eraw).getName())) {
                    if(!FriendManager.friends.containsKey(((EntityLivingBase) eraw).getName())) {
                      //  System.out.println(eraw+"");
                        if(eraw instanceof EntityPlayer && Player.getValue() || eraw instanceof EntityMob && Mobs.getValue() || eraw instanceof EntityAnimal && Animals.getValue()) {
                            if (eraw != mc.thePlayer) {
                             //   if (((EntityLivingBase) eraw).getHealth() > 0) {
                         //           Main.getMain.cmdManager.sendChatMessage((eraw instanceof EntityPlayer && Player.getValue()) + "");
                                    EntityLivingBase e = (EntityLivingBase) eraw;
                                    if (mc.thePlayer.getDistanceToEntity(e) <= range) {
                                        entities.add(e);
                                    }
                          //      }
                            }
                        }
                    }
                }
            }

        }

        return entities;
    }


    public float[] getRotationsNeeded(Entity entity) {
        double diffY;
        if (entity == null) {
            return null;
        }
        double diffX = entity.posX + entity.motionX - (Minecraft.getMinecraft().thePlayer.posX + mc.thePlayer.motionX);
        double diffZ = entity.posZ + entity.motionZ - (Minecraft.getMinecraft().thePlayer.posZ + mc.thePlayer.motionZ);
        if (entity instanceof EntityLivingBase) {
            EntityLivingBase entityLivingBase = (EntityLivingBase) entity;
            diffY = entityLivingBase.posY + (double) entityLivingBase.getEyeHeight() - (Minecraft.getMinecraft().thePlayer.posY + (double) Minecraft.getMinecraft().thePlayer.getEyeHeight());
        } else {
            diffY = (entity.boundingBox.minY - 0.5 + entity.boundingBox.maxY - 0.5) / 2.0 - (Minecraft.getMinecraft().thePlayer.posY + (double) Minecraft.getMinecraft().thePlayer.getEyeHeight());
        }
        double dist = MathHelper.sqrt_double(diffX * diffX + diffZ * diffZ);
        float yaw = (float) (Math.atan2(diffZ, diffX) * 180.0 / Math.PI) - 90.0f;
        float pitch = (float) (-Math.atan2(diffY, dist) * 180.0 / Math.PI);
        return new float[]{Minecraft.getMinecraft().thePlayer.rotationYaw + MathHelper.wrapAngleTo180_float(yaw - Minecraft.getMinecraft().thePlayer.rotationYaw), Minecraft.getMinecraft().thePlayer.rotationPitch + MathHelper.wrapAngleTo180_float(pitch - Minecraft.getMinecraft().thePlayer.rotationPitch)};
    }
    public boolean unblock;
    public float yaw;
    public float pitch;
    public float yaw2;
    public float pitch2;
    @EventTarget
    public void onEvent(UpdateEvent pre) {
        if(mc.currentScreen != null){
            return;
        }
        if(this.AAC.getValue()){
            NoSlowDown nsd = (NoSlowDown) Main.getMain.moduleManager.getModule(NoSlowDown.class);
            if(nsd.getState && nsd.AACLatest.getValue() && !nsd.nextTick && mc.thePlayer.isBlocking()){
                return;
            }
        }
        if(this.Autoblock.getValue()){
            if(mc.thePlayer.getCurrentEquippedItem() != null) {
                if (getCloseEnteties(this.Range.getValue() + 1).size() > 0) {
                    if (mc.thePlayer.getCurrentEquippedItem().getItem() instanceof ItemSword) {
                        mc.gameSettings.keyBindUseItem.pressed = true;
                        unblock = true;
                    }
                } else {
                    if (unblock) {
                        mc.gameSettings.keyBindUseItem.pressed = false;
                        unblock = false;
                    }
                }

            }
        }

        //  System.
        if (pre.getState() == State.PRE) {



            yaw = mc.thePlayer.rotationYaw;
            pitch = mc.thePlayer.rotationPitch;
            if(mc.thePlayer.getDistanceToEntity(this.entityToAttack) <= this.Range.getValue() && mc.theWorld.loadedEntityList.contains(this.entityToAttack)) {

                float[] rot = this.getRotationsNeeded(this.entityToAttack);
                if(!this.AAC.getValue()) {
                    mc.thePlayer.rotationYaw = rot[0];
                    mc.thePlayer.rotationPitch = rot[1];
                }else{

                    yaw2-= (yaw2 - rot[0]) /( 1.0d + new Random().nextDouble())*2 % 360;
                    pitch2 -= (pitch2 - rot[1]) /( 1.0d + new Random().nextDouble());
                    mc.thePlayer.rotationYaw =yaw2;
                    mc.thePlayer.rotationPitch =pitch2;
                    if( mc.thePlayer.rotationPitch > 90){
                        mc.thePlayer.rotationPitch = 90;
                    }
                    if( mc.thePlayer.rotationPitch < -90){
                        mc.thePlayer.rotationPitch = -90;
                    }

                }
            }

            if (time.hasReached((long) (this.delay.getValue() + (this.heuristic.getValue() ? new Random().nextInt(10) - new Random().nextInt(10) : 0))) || this.Tick.getValue() || this.AAC.getValue()) {
                for (int i = 0; i < this.entitestoAttack.size(); ++i) {
                    Entity e = this.entitestoAttack.get(i);
                    if(this.AAC.getValue()){
                        if (time2.hasReached(50 + new Random().nextInt(50))){
                            mc.thePlayer.swingItem();
                            time2.reset();
                        }
                    }
                    if(time.hasReached(495) || !this.Tick.getValue()) {
                        float[] rot = this.getRotationsNeeded(this.entityToAttack);
                        if (time.hasReached( new Random().nextInt(300)) &&   mc.thePlayer.getDistanceToEntity(this.entityToAttack) < this.Range.getValue() - 1 && (Math.sqrt((rot[0]-mc.thePlayer.rotationYaw)*(rot[0]-mc.thePlayer.rotationYaw)) < 15)|| !this.AAC.getValue()) {
                            if (Tick.getValue()) {
                                this.attackTick(e);
                            } else {
                                if (this.AAC.getValue()) {
                                    this.attackAACTick(e);
                                } else {
                                    this.attack(e);
                                }
                            }
                            time.reset();
                            this.entitestoAttack.remove(e);
                        }
                    }
                }
            }


        } else if (pre.getState() == State.POST) {

            mc.thePlayer.rotationYaw =     (float) yaw;
            mc.thePlayer.rotationPitch = (float) pitch;

        }

    }

}

minecraft_de_Client_Main_Modules_mods_Combat_KnockBackControl.java

package de.Client.Main.Modules.mods.Combat;

import de.Client.Events.EventTarget;
import de.Client.Events.Events.PacketSendEvent;
import de.Client.Main.Main;
import de.Client.Main.Modules.Category;
import de.Client.Main.Modules.Module;
import de.Client.Main.Values.ValueBoolean;
import net.minecraft.network.play.client.C03PacketPlayer;
import net.minecraft.network.play.client.C0BPacketEntityAction;

/**
 * Created by Daniel on 08.08.2017.
 */
public class KnockBackControl extends Module{
    public ValueBoolean ExtraVelocity;
    public ValueBoolean ExtraVelocityB;
    public ValueBoolean LessVelocity;
    public KnockBackControl(){
        super("KBControll",Category.COMBAT,0);
        addValue(ExtraVelocity = new ValueBoolean("ExtraVelocity",true));
        addValue(ExtraVelocityB = new ValueBoolean("ExtraVelocityBypass",false));
        addValue(LessVelocity= new ValueBoolean("LessVelocity",false));
    }

    @EventTarget
    public void onPacketSend(PacketSendEvent e) {
        if(Main.getMain.moduleManager.getModule(KillAura.class).getState){
            if(((KillAura) Main.getMain.moduleManager.getModule(KillAura.class)).Tick.getValue()){
                return;
            }
        }
        if(this.ExtraVelocity.getValue()){
            mc.thePlayer.sendQueue.addToSendQueue(new C0BPacketEntityAction(mc.thePlayer,C0BPacketEntityAction.Action.START_SPRINTING));
        }
        if(this.LessVelocity.getValue()){
            mc.thePlayer.sendQueue.addToSendQueue(new C0BPacketEntityAction(mc.thePlayer,C0BPacketEntityAction.Action.STOP_SPRINTING));
        }
        if(this.ExtraVelocityB.getValue()){
            mc.thePlayer.sendQueue.addToSendQueue(new C03PacketPlayer.C04PacketPlayerPosition(mc.thePlayer.posX,mc.thePlayer.posY,mc.thePlayer.posZ+0.01f,true));
            mc.thePlayer.sendQueue.addToSendQueue(new C0BPacketEntityAction(mc.thePlayer,C0BPacketEntityAction.Action.START_SPRINTING));
        }
    }

}

minecraft_de_Client_Main_Modules_mods_Combat_McdeadAimbot.java

package de.Client.Main.Modules.mods.Combat;

import de.Client.Events.EventTarget;
import de.Client.Events.Events.UpdateEvent;
import de.Client.Events.IEvent.State;
import de.Client.Main.Main;
import de.Client.Main.Modules.Category;
import de.Client.Main.Modules.Module;
import de.Client.Utils.FriendManager;
import de.Client.Utils.Macro;
import de.Client.Utils.TimeHelper;
import net.minecraft.client.Minecraft;
import net.minecraft.entity.Entity;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.network.Packet;
import net.minecraft.network.play.client.C07PacketPlayerDigging;
import net.minecraft.network.play.client.C08PacketPlayerBlockPlacement;
import net.minecraft.util.BlockPos;
import net.minecraft.util.EnumFacing;
import net.minecraft.util.MathHelper;
import org.lwjgl.input.Controller;
import org.lwjgl.input.Controllers;
import org.lwjgl.input.Keyboard;

public class McdeadAimbot extends Module {

    public McdeadAimbot() {
        super("MCDAimbot", Category.COMBAT, 0);
        // TODO Auto-generated constructor stub
    }

    public int preItem;
    public float preLookPitch;
    public float preLookYaw;
    public boolean isCorrectEntity(Object o) {
        if (!(o instanceof EntityLivingBase)) {
            return false;
        }


        return true;
    }
    public float[] getRotationsNeeded(Entity entity) {
        double diffY;
        if (entity == null) {
            return null;
        }
        double diffX = entity.posX + ((entity.posX - entity.lastTickPosX))*16 / mc.thePlayer.getDistanceToEntity(entity) - (Minecraft.getMinecraft().thePlayer.posX + mc.thePlayer.motionX);
        double diffZ = entity.posZ + ((entity.posZ - entity.lastTickPosZ))*16 / mc.thePlayer.getDistanceToEntity(entity) - (Minecraft.getMinecraft().thePlayer.posZ + mc.thePlayer.motionZ);
        if (entity instanceof EntityLivingBase) {
            EntityLivingBase entityLivingBase = (EntityLivingBase) entity;
            diffY = entityLivingBase.posY + (double) entityLivingBase.getEyeHeight() - (Minecraft.getMinecraft().thePlayer.posY + (double) Minecraft.getMinecraft().thePlayer.getEyeHeight());
        } else {
            diffY = (entity.boundingBox.minY - 0.5 + entity.boundingBox.maxY - 0.5) / 2.0 - (Minecraft.getMinecraft().thePlayer.posY + (double) Minecraft.getMinecraft().thePlayer.getEyeHeight());
        }
        double dist = MathHelper.sqrt_double(diffX * diffX + diffZ * diffZ);
        float yaw = (float) (Math.atan2(diffZ, diffX) * 180.0 / Math.PI) - 90.0f;
        float pitch = (float) (-Math.atan2(diffY, dist) * 180.0 / Math.PI);
        return new float[]{Minecraft.getMinecraft().thePlayer.rotationYaw + MathHelper.wrapAngleTo180_float(yaw - Minecraft.getMinecraft().thePlayer.rotationYaw), Minecraft.getMinecraft().thePlayer.rotationPitch + MathHelper.wrapAngleTo180_float(pitch - Minecraft.getMinecraft().thePlayer.rotationPitch)};
    }
    public  EntityLivingBase getClosestEntity() {

        EntityLivingBase closestEntity = null;
        for (Object o : mc.theWorld.playerEntities) {
            if (!isCorrectEntity(o) && !FriendManager.friends.containsKey(((EntityLivingBase) o).getName())) continue;
            EntityLivingBase en = (EntityLivingBase)o;

            if ( en.isDead || en.getHealth() <= 0.0f || en.getName().equals(Minecraft.getMinecraft().thePlayer.getName()) || closestEntity != null && Minecraft.getMinecraft().thePlayer.getDistanceToEntity(en) >= Minecraft.getMinecraft().thePlayer.getDistanceToEntity(closestEntity)) continue;
            closestEntity = en;
        }
        return closestEntity;
    }
    public TimeHelper t = new TimeHelper();
    @EventTarget
    public void onPrePost(UpdateEvent e){
        if(getClosestEntity() == null){
            return;
        }
        EntityPlayer p = (EntityPlayer) this.getClosestEntity();
        if(mc.thePlayer.getDistanceToEntity(p) > 80){
            return;
        }
        if(!mc.thePlayer.canEntityBeSeen(p)){
            return;
        }

        if(e.state == State.PRE) {
            preLookYaw = mc.thePlayer.rotationYaw;
            preLookPitch = mc.thePlayer.rotationPitch;
            float[] rot = this.getRotationsNeeded(p);
            mc.thePlayer.rotationYaw = rot[0];
            mc.thePlayer.rotationPitch = rot[1];
            if(t.hasReached(100)) {
                mc.getNetHandler().addToSendQueue((Packet) new C08PacketPlayerBlockPlacement(mc.thePlayer.getHeldItem()));
                mc.getNetHandler().addToSendQueue((Packet) new C07PacketPlayerDigging(C07PacketPlayerDigging.Action.RELEASE_USE_ITEM, BlockPos.ORIGIN, EnumFacing.DOWN));
                t.reset();
            }
        }else{
            if(e.state == State.POST){
                mc.thePlayer.rotationYaw = preLookYaw;
                mc.thePlayer.rotationPitch = preLookPitch;
            }
        }
    }


}

minecraft_de_Client_Main_Modules_mods_Combat_Regen.java

package de.Client.Main.Modules.mods.Combat;

import de.Client.Events.EventTarget;
import de.Client.Events.Events.PacketSendEvent;
import de.Client.Main.Main;
import de.Client.Main.Modules.Category;
import de.Client.Main.Modules.Module;
import de.Client.Main.Modules.ModuleManager;
import de.Client.Main.Modules.mods.Movment.Glide;
import de.Client.Main.Values.ValueBoolean;
import net.minecraft.entity.Entity;
import net.minecraft.network.play.client.C02PacketUseEntity;
import net.minecraft.network.play.client.C03PacketPlayer;
import org.lwjgl.input.Keyboard;

public class Regen extends Module {

    public Regen() {
        super("Regen", Category.COMBAT, 0);
    }


    public ValueBoolean packets = new ValueBoolean("Packets",true);

    public void onUpdate(){
        if(this.packets.getValue()){
            if(mc.thePlayer.getHealth() < 20 && ! mc.playerController.isInCreativeMode() && mc.thePlayer.onGround && !mc.thePlayer.getFoodStats().needFood()){
                for(int i = 0; i < 300; ++i){
                    mc.thePlayer.sendQueue.addToSendQueue(new C03PacketPlayer(true));
                }
            }
        }
    }

}

minecraft_de_Client_Main_Modules_mods_Combat_Teams.java

package de.Client.Main.Modules.mods.Combat;

import de.Client.Events.EventTarget;
import de.Client.Events.Events.UpdateEvent;
import de.Client.Main.Main;
import de.Client.Main.Modules.Category;
import de.Client.Main.Modules.Module;
import de.Client.Utils.Macro;
import net.minecraft.client.entity.EntityPlayerSP;
import net.minecraft.entity.Entity;
import net.minecraft.entity.EntityLivingBase;
import org.lwjgl.input.Controller;
import org.lwjgl.input.Controllers;
import org.lwjgl.input.Keyboard;

import java.util.ArrayList;
import java.util.Iterator;

public class Teams extends Module {

    public Teams() {
        super("Teams", Category.COMBAT, 0);
        // TODO Auto-generated constructor stub
    }

    private static ArrayList<EntityLivingBase> players = new ArrayList();
    public static ArrayList<String> teammates = new ArrayList();

    public void onRender(){
        //	mc.gameSettings.gammaSetting = 9999;
        if(!this.getState()){
            this.teammates.clear();
        }
    }
    @EventTarget
    public void onUpdate(UpdateEvent e) {




        this.displayName = (this.name);

        this.players.clear();
        this.teammates.clear();
        try {
            for (Iterator<Entity> entities = mc.theWorld.loadedEntityList.iterator(); entities.hasNext();) {
                Object theObject = entities.next();
                if ((theObject instanceof EntityLivingBase)) {
                    EntityLivingBase entity = (EntityLivingBase) theObject;
                    if ((!(entity instanceof EntityPlayerSP)) && (entity.isOnTeam(mc.thePlayer.getTeam()))) {
                        teammates.add(entity.getName().toString());
                        players.add(entity);
                    }
                }
            }
        } catch (Exception exception) {}
    }

    @Override
    public void onDisable() {
        this.players.clear();
        this.teammates.clear();
        super.onDisable();
    }

}

minecraft_de_Client_Main_Modules_mods_Movment_ClickTP.java

package de.Client.Main.Modules.mods.Movment;

import de.Client.Events.EventTarget;
import de.Client.Events.Events.PacketReceiveEvent;
import de.Client.Main.Modules.Category;
import de.Client.Main.Modules.Module;
import de.Client.Main.Values.ValueBoolean;
import de.Client.Utils.TimeHelper;
import net.minecraft.block.BlockAir;
import net.minecraft.network.Packet;
import net.minecraft.network.play.client.C03PacketPlayer;
import net.minecraft.network.play.server.S08PacketPlayerPosLook;
import net.minecraft.util.BlockPos;

import java.util.ArrayList;

public class ClickTP extends Module {
	
	public ValueBoolean rewi = new ValueBoolean("rewi",false);
	public ValueBoolean aac = new ValueBoolean("aac",true);
    public static ValueBoolean legit;

 //   private ArrayList<Location> locationList;
	private boolean cancel;
	private boolean speedTick;
	private float speedTimer = (float) 1.35;
	public TimeHelper timer = new TimeHelper();
	public static boolean yport;
	
	private double save;
	public static boolean canStep;
	private boolean stop;
	public static boolean boost = false;
	private float ground = 0.0F;

	private boolean shouldreset;

	private int timerDelay;
	 private float headStart;

    private int groundTicks;

	private boolean groundBoolean;

	private int state;

	private boolean isSpeeding;

	private double lastHDistance;
	
	  public static double yOffset;
	  private int stage;
	  private double moveSpeed;
	  private double lastDist;
    public float oldYaw;
    private ArrayList<Packet> packets = new ArrayList<Packet>();
    BlockPos tpTo = null;
    BlockPos startPos = null;
    double startY = 0;
    public static double oldX = 0;
    double oldY = 0;
    public static double oldZ = 0;
    boolean inAir = false;
    public int ticks;
	private boolean hasstarted;
    public float newYaw;
	public ClickTP() {
		super("ClickTP", Category.MOVEMENT, 0);
		addValue(this.rewi);
		addValue(this.aac);
	}
	
	@EventTarget
	public void onPacketReceiveEvent(PacketReceiveEvent e) {
		if(this.rewi.getValue()){
		if (e.getPacket() instanceof S08PacketPlayerPosLook && this.hasstarted) {
			for(int i = 0; i < 50; ++i){
				if (this.tpTo.x == mc.thePlayer.posX) {
					if (this.tpTo.z == mc.thePlayer.posZ) {
						return;
					}
				}
			mc.getNetHandler().netManager.sendPacket(new C03PacketPlayer.C04PacketPlayerPosition(
					mc.thePlayer.posX, mc.thePlayer.posY, mc.thePlayer.posZ, true));
			mc.getNetHandler().netManager.sendPacket(new C03PacketPlayer.C04PacketPlayerPosition(
					mc.thePlayer.posX, mc.thePlayer.posY + 9999, mc.thePlayer.posZ, true));
			mc.getNetHandler().netManager.sendPacket(new C03PacketPlayer.C04PacketPlayerPosition(
					mc.thePlayer.posX, mc.thePlayer.posY - Integer.MAX_VALUE, mc.thePlayer.posZ, true));
			
			mc.getNetHandler().netManager.sendPacket(new C03PacketPlayer.C04PacketPlayerPosition(
					mc.thePlayer.posX, mc.thePlayer.posY, mc.thePlayer.posZ, true));
			mc.getNetHandler().netManager.sendPacket(new C03PacketPlayer.C04PacketPlayerPosition(
					this.tpTo.getX(), this.tpTo.getY(), this.tpTo.getZ(), true));
			mc.getNetHandler().netManager.sendPacket(new C03PacketPlayer.C04PacketPlayerPosition(
					mc.thePlayer.posX, mc.thePlayer.posY, mc.thePlayer.posZ, true));
			
			
			
			}
			this.hasstarted = false;
		}
		}
		
	}
	@Override
	public void onEnable(){
		this.tpTo = null;
		this.hasstarted = false;
		super.onEnable();
	}
		public void onUpdate() {
            try {
                if (!(mc.theWorld.getBlockState(mc.objectMouseOver.func_178782_a()).getBlock() instanceof BlockAir) && mc.gameSettings.keyBindAttack.pressed) {
                    if ((mc.theWorld.getBlockState(mc.objectMouseOver.func_178782_a().add(0, 2, 0))
                            .getBlock() instanceof BlockAir)) {
                        if ((mc.theWorld.getBlockState(mc.objectMouseOver.func_178782_a().add(0, 3, 0))
                                .getBlock() instanceof BlockAir)) {
                            this.tpTo = mc.objectMouseOver.func_178782_a().add(0, 1, 0);
                            this.startPos = new BlockPos(mc.thePlayer.posX, mc.thePlayer.posY, mc.thePlayer.posZ);
                            hasstarted = true;
                            int airTicks = 0;
                            timer.reset();
                        }
                    }
                }

                if (hasstarted) {
                    if(!timer.hasReached(2000)) {
                        if ((mc.thePlayer.getDistance(tpTo.x, tpTo.y, tpTo.z) < 5)) {
                            hasstarted = false;
                            return;
                        }
                     //   mc.thePlayer.sendQueue.addToSendQueue(new C03PacketPlayer.C04PacketPlayerPosition(tpTo.x, tpTo.y, tpTo.z, false));
                   //     mc.thePlayer.setSpeed(10);

                        //     mc.timer.timerSpeed = 0.4f;
                //        mc.thePlayer.sendQueue.addToSendQueue(new C03PacketPlayer.C04PacketPlayerPosition(mc.thePlayer.posX, mc.thePlayer.posY, mc.thePlayer.posZ, true));
                            mc.thePlayer.sendQueue.addToSendQueue(new C03PacketPlayer.C04PacketPlayerPosition(tpTo.x, tpTo.y, tpTo.z, true));
                        mc.thePlayer.sendQueue.addToSendQueue(new C03PacketPlayer.C04PacketPlayerPosition(tpTo.x, tpTo.y, tpTo.z, true));
                        mc.thePlayer.sendQueue.addToSendQueue(new C03PacketPlayer.C04PacketPlayerPosition(tpTo.x, tpTo.y, tpTo.z, true));
                        mc.thePlayer.sendQueue.addToSendQueue(new C03PacketPlayer.C04PacketPlayerPosition(tpTo.x, tpTo.y, tpTo.z, true));


                        //    mc.thePlayer.setSpeed(10);
                        //mc.timer.timerSpeed = 0.1f;
                    }else {
                //       mc.thePlayer.setPosition(tpTo.x, tpTo.y, tpTo.z);
                    }
                }
            }catch (Exception e){

            }

            if (this.aac.getValue() ) {
                try {


                    if (!(mc.theWorld.getBlockState(mc.objectMouseOver.func_178782_a()).getBlock() instanceof BlockAir) && mc.gameSettings.keyBindAttack.pressed) {
                        if ((mc.theWorld.getBlockState(mc.objectMouseOver.func_178782_a().add(0, 2, 0))
                                .getBlock() instanceof BlockAir)) {
                            if ((mc.theWorld.getBlockState(mc.objectMouseOver.func_178782_a().add(0, 3, 0))
                                    .getBlock() instanceof BlockAir)) {
                                this.tpTo = mc.objectMouseOver.func_178782_a().add(0, 1, 0);
                                this.startPos = new BlockPos(mc.thePlayer.posX, mc.thePlayer.posY, mc.thePlayer.posZ);
                                hasstarted = true;
                                int airTicks = 0;
                            }
                        }
                    }

                    if (hasstarted) {
                        if ((timer.hasReached(200L))) {
                            /*/
                            /*/
                            mc.thePlayer.sendQueue.addToSendQueue(new C03PacketPlayer.C04PacketPlayerPosition(tpTo.x, tpTo.y, tpTo.z, mc.thePlayer.onGround));
                            mc.thePlayer.sendQueue.addToSendQueue(new C03PacketPlayer.C04PacketPlayerPosition(startPos.x, startPos.y + 50.0D, startPos.z, mc.thePlayer.onGround));

/*/
                            int tpposx = tpTo.x;
                            int tpposy = tpTo.y;
                            int tpposz = tpTo.z;
                            mc.thePlayer.sendQueue.addToSendQueue(new C03PacketPlayer.C04PacketPlayerPosition(mc.thePlayer.posX, mc.thePlayer.posY, mc.thePlayer.posZ, true));
                            mc.thePlayer.sendQueue.addToSendQueue(new C03PacketPlayer.C04PacketPlayerPosition(tpposx - 0.5D, tpposy - 0.5D, tpposz - 0.5D, true));
                            mc.thePlayer.sendQueue.addToSendQueue(new C03PacketPlayer.C04PacketPlayerPosition( mc.thePlayer.posX,  mc.thePlayer.posY,  mc.thePlayer.posZ, true));
                            mc.thePlayer.sendQueue.addToSendQueue(new C03PacketPlayer.C04PacketPlayerPosition(tpposx + 0.5D, tpposy + 0.5D, tpposz + 0.5D, true));
                            mc.thePlayer.sendQueue.addToSendQueue(new C03PacketPlayer.C04PacketPlayerPosition( mc.thePlayer.posX,  mc.thePlayer.posY,  mc.thePlayer.posZ, true));
                            /*/
                            timer.reset();

                        }
                    }
                    if((mc.thePlayer.posX == tpTo.x )&& (mc.thePlayer.posZ == tpTo.z)){
                        this.hasstarted = false;
                    }
                }catch (Exception e){

                }
        }
			if(this.rewi.getValue()){
		mc.timer.timerSpeed = 1;
		if (timer.hasReached(500)) {
			hasstarted = false;
		}
		if (this.hasstarted) {
			if (this.tpTo.x == mc.thePlayer.posX) {
				if (this.tpTo.z == mc.thePlayer.posZ) {
					
				}
			}
		}
		if (mc.gameSettings.keyBindAttack.pressed) {

			if (!(mc.theWorld.getBlockState(mc.objectMouseOver.func_178782_a()).getBlock() instanceof BlockAir)) {
				if ((mc.theWorld.getBlockState(mc.objectMouseOver.func_178782_a().add(0, 2, 0))
						.getBlock() instanceof BlockAir)) {
					if ((mc.theWorld.getBlockState(mc.objectMouseOver.func_178782_a().add(0, 3, 0))
							.getBlock() instanceof BlockAir)) {
						this.tpTo = mc.objectMouseOver.func_178782_a().add(0, 1, 0);

						hasstarted = true;
                        int airTicks = 0;
						timer.reset();
					}
				}
			}
		}
		if (hasstarted  ) {
		

		mc.thePlayer.motionY = 0.1;
		
		}

			}
	}
}

minecraft_de_Client_Main_Modules_mods_Movment_ControllerApi.java

package de.Client.Main.Modules.mods.Movment;

import de.Client.Events.EventTarget;
import de.Client.Events.Events.UpdateEvent;
import de.Client.Events.IEvent.Event;
import de.Client.Main.Main;
import de.Client.Main.Modules.Category;
import de.Client.Main.Modules.Module;
import de.Client.Utils.Macro;
import org.lwjgl.input.Controller;
import org.lwjgl.input.Controllers;
import org.lwjgl.input.Keyboard;
import org.lwjgl.opengl.GL11;

public class ControllerApi extends Module {

    public ControllerApi() {
        super("Controller", Category.MOVEMENT, Keyboard.KEY_Y);
        // TODO Auto-generated constructor stub
    }

    public void onEnable() {
        Main.getMain.controllerAPI.init();
    }
    public void onRender(){
        try {
            Controller c = Main.getMain.controllerAPI.gameController;
            if (c != null) {
                mc.thePlayer.rotationYaw += c.getAxisValue(1) * 2;
                mc.thePlayer.rotationPitch += c.getAxisValue(0);
            } else {
                Main.getMain.controllerAPI.init();
            }
        }catch (Exception e) {

        }
    }
    public boolean tabGui;
    public void onUpdate(){


        try {
            Controller c = Main.getMain.controllerAPI.gameController;
            if (c != null) {
                mc.gameSettings.keyBindJump.pressed = c.isButtonPressed(5);
                mc.gameSettings.keyBindForward.pressed = c.getYAxisValue() < 0;
                mc.gameSettings.keyBindBack.pressed = c.getYAxisValue() > 0;
                mc.gameSettings.keyBindAttack.pressed = c.isButtonPressed(7);
                mc.gameSettings.keyBindUseItem.pressed = c.isButtonPressed(8);
                mc.gameSettings.keyBindLeft.pressed = c.getXAxisValue() == -1;
                mc.gameSettings.keyBindRight.pressed = c.getXAxisValue() == 1;
                if (c.getPovY() < 0) {
                    if (tabGui) {
                        Main.getMain.tabGui.upKey();
                        tabGui = false;
                    }
                } else if (c.getPovY() > 0 && tabGui) {
                    if (tabGui) {
                        Main.getMain.tabGui.downKey();
                        tabGui = false;
                    }
                } else if (c.getPovX() < 0) {
                    if (tabGui) {
                        Main.getMain.tabGui.leftKey();
                        tabGui = false;
                    }
                } else if (c.getPovX() > 0) {
                    if (tabGui) {
                        Main.getMain.tabGui.rightKey();
                        tabGui = false;
                    }
                } else {
                    tabGui = true;
                }


            } else {
                Main.getMain.controllerAPI.init();
            }
        }catch(Exception e){

        }
    }

    @Override
    public boolean isModuleImportant(){
        return false;
    }
}

minecraft_de_Client_Main_Modules_mods_Movment_Fastladder.java

package de.Client.Main.Modules.mods.Movment;

import de.Client.Main.Main;
import de.Client.Main.Modules.Category;
import de.Client.Main.Modules.Module;
import de.Client.Main.Values.ValueBoolean;
import de.Client.Utils.Macro;
import net.minecraft.entity.Entity;
import org.lwjgl.input.Controller;
import org.lwjgl.input.Controllers;
import org.lwjgl.input.Keyboard;

public class Fastladder extends Module {
    public static ValueBoolean AAC = new ValueBoolean("AAC",true) ;
    public Fastladder() {
        super("Fastladder", Category.MOVEMENT,0);
        addValue(AAC);
    }
    public float speed;
    public void onUpdate(){
        if(mc.thePlayer.isOnLadder()){
            mc.thePlayer.motionY -= 0.013;
        }
        //mc.timer.timerSpeed = 0.1f;

        if(mc.thePlayer.onGround && mc.thePlayer.isOnLadder()){
            speed = 0;



            if(mc.thePlayer.isOnLadder() && mc.thePlayer.motionY > 0.2){
                mc.thePlayer.setSpeed(0);
            }
        }


    }



}

minecraft_de_Client_Main_Modules_mods_Movment_Glide.java

package de.Client.Main.Modules.mods.Movment;

import de.Client.Events.EventTarget;
import de.Client.Events.Events.PacketSendEvent;
import de.Client.Events.Events.UpdateEvent;
import de.Client.Main.Main;
import de.Client.Main.Modules.Category;
import de.Client.Main.Modules.Module;
import de.Client.Main.Values.ValueBoolean;
import de.Client.Utils.TimeHelper;
import net.minecraft.block.*;
import net.minecraft.client.Minecraft;
import net.minecraft.enchantment.Enchantment;
import net.minecraft.enchantment.EnchantmentHelper;
import net.minecraft.entity.Entity;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.init.Blocks;
import net.minecraft.item.ItemBow;
import net.minecraft.item.ItemStack;
import net.minecraft.network.play.client.*;
import net.minecraft.potion.Potion;
import net.minecraft.util.BlockPos;
import net.minecraft.util.EnumFacing;
import net.minecraft.util.MathHelper;
import net.minecraft.util.MovementInput;
import org.newdawn.slick.Color;

import java.util.Random;

public class Glide extends Module{
	public boolean nextTick;
	public ValueBoolean Cubecraft = new ValueBoolean("Cubecraft",true);
	public ValueBoolean hypixel = new ValueBoolean("Hypixel",false);
	public ValueBoolean AAC = new ValueBoolean("AAC",false);
    public ValueBoolean AACVelocity = new ValueBoolean("AACVelocity",false);
    public ValueBoolean NCPBow = new ValueBoolean("NCPBow",false);
    public ValueBoolean AACWall = new ValueBoolean("AACWall",false);
    public ValueBoolean AACWallAdvanced = new ValueBoolean("AACWallAdvanced",false);
    public ValueBoolean Neptune = new ValueBoolean("Neptune",false);
    public ValueBoolean Cobra = new ValueBoolean("Cobra",false);
	public int airtime;
	public boolean rejoin;
	private float speedTimer = 1.35F;
	private int timer;
	public static boolean yport;
	private double save;
	public static boolean canStep;
	private boolean stop;
	public static boolean boost = false;
	private float ground = 0.0F;
	private boolean shouldreset;
	private int timerDelay;
	private float headStart;
	private int airTicks;
	private int groundTicks;
	private int packets;
	private double lastDist;
	private boolean groundBoolean;
	private int state;
	private boolean isSpeeding;
	private double lastHDistance;
	public static double yOffset;
	private int stage;
	private double moveSpeed;
	public TimeHelper time = new TimeHelper();
	public Glide() {
		super("Glide",Category.MOVEMENT,0);
		addValue(Cubecraft);
        addValue(this.NCPBow);
		addValue(this.AAC);
        addValue(this.AACVelocity);
        addValue(this.AACWall);
        addValue(this.AACWallAdvanced);
		addValue(this.hypixel);
        addValue(this.Neptune);
        addValue(this.Cobra);
	}
	
	public void onDisable(){
		mc.timer.timerSpeed = 1;
		if(this.Cubecraft.getValue() || this.AAC.getValue()){
			mc.thePlayer.setSpeed(0);
		}
		super.onDisable();
	}
    public float directionToFly;
	public  void  onEnable(){
	    if(this.AACWallAdvanced.getValue()){
	        directionToFly = mc.thePlayer.rotationYaw;
        }
        this.shouldreset = true;
        this.disabling = true;
		if(this.Cubecraft.getValue()){
			if (mc.thePlayer != null) {
				this.moveSpeed = getBaseMoveSpeed();
			}
			this.lastDist = 0.0D;
			this.stage = 1;
			this.speed = 0;
		}
		speed = 0;

	}
	public double getBaseMoveSpeed()
	{
		double baseSpeed = 0.2873D;
		if (mc.thePlayer.isPotionActive(Potion.moveSpeed))
		{
			int amplifier = mc.thePlayer.getActivePotionEffect(Potion.moveSpeed).getAmplifier();
			baseSpeed *= (1.0D + 0.2D * (amplifier + 1));
		}
		return baseSpeed;
	}
	@EventTarget
	private void onReceive(PacketSendEvent event) {

        if(this.NCPBow.getValue()) {
            C03PacketPlayer p = (C03PacketPlayer) event.getPacket();
            p.pitch = 50;
            event.setPacket(p);
        }





    }

	@EventTarget
	private void onUpdate(UpdateEvent event)
	{
		boolean speedy = mc.thePlayer.isPotionActive(Potion.moveSpeed);
		double xDist = mc.thePlayer.posX - mc.thePlayer.prevPosX;
		double zDist = mc.thePlayer.posZ - mc.thePlayer.prevPosZ;
		this.lastDist = Math.sqrt(xDist * xDist + zDist * zDist);
	}
	public int packetDelay;
	@EventTarget(3)
    public void onSendPacket(PacketSendEvent event) {

        if (this.hypixel.getValue())
            if ((!event.isCancelled()) &&
                    ((event.getPacket() instanceof C03PacketPlayer))) {
                C03PacketPlayer packet = (C03PacketPlayer) event.getPacket();
                if (mc.thePlayer.ticksExisted % 2 == 0) {
                    packet.y += Math.pow(10.0D, -7.0D) ;
                    mc.thePlayer.sendQueue.addToSendQueue(new C0BPacketEntityAction(mc.thePlayer,C0BPacketEntityAction.Action.START_SPRINTING));
                }
                    mc.thePlayer.sendQueue.addToSendQueue(new C0BPacketEntityAction(mc.thePlayer,C0BPacketEntityAction.Action.STOP_SPRINTING));

                packet.field_149474_g = (!this.nextTick);
                event.setPacket(packet);
                mc.thePlayer.onGround = true;
                mc.thePlayer.setSprinting(true);
                mc.thePlayer.setSpeed(mc.thePlayer.getSpeed()*1.05);
                mc.timer.timerSpeed = 1.3f;
            }
            if(Neptune.getValue()) {
            if(mc.thePlayer.onGround){
                this.speed = mc.thePlayer.posY;
                Main.getMain.cmdManager.sendChatMessage("test");
            }
                mc.thePlayer.motionY = 0;
                if ((!event.isCancelled()) &&
                        ((event.getPacket() instanceof C03PacketPlayer))) {
                    C03PacketPlayer packet = (C03PacketPlayer) event.getPacket();
                    if (mc.thePlayer.ticksExisted % 2 == 0) {
                        packet.y += Math.pow(10.0D, -7.0D);
                        //  mc.thePlayer.sendQueue.addToSendQueue(new C0BPacketEntityAction(mc.thePlayer, C0BPacketEntityAction.Action.START_SPRINTING));
                    }
                    //  mc.thePlayer.sendQueue.addToSendQueue(new C0BPacketEntityAction(mc.thePlayer, C0BPacketEntityAction.Action.STOP_SPRINTING));

                    packet.field_149474_g = (!this.nextTick);
                    event.setPacket(packet);
                    //   mc.thePlayer.onGround = true;
                    //   mc.thePlayer.setSprinting(true);
                    if (mc.gameSettings.keyBindForward.pressed || mc.gameSettings.keyBindBack.pressed || mc.gameSettings.keyBindRight.pressed || mc.gameSettings.keyBindLeft.pressed) {
                        mc.thePlayer.setSpeed(0.5);

                    } else {
                        mc.thePlayer.setSpeed(0);
                    }
                    if (mc.gameSettings.keyBindJump.pressed && speed > mc.thePlayer.posY) {
                        mc.thePlayer.motionY += 1;
                    }
                    if (mc.gameSettings.keyBindSneak.pressed) {
                        mc.thePlayer.motionY -= 0.4;
                    }
                }
            }

    }

    /*/
        if(mc.thePlayer.onGround){
            if(mc.thePlayer.hurtTime > 0) {
                mc.thePlayer.motionY = 0.42;
             //   mc.thePlayer.setSpeed(5);
                airTicks = 5;
                mc.timer.timerSpeed = 0.5f;
                this.rejoin = false;
            }
            }else{
                if(mc.thePlayer.hurtTime > 0) {
                    if(mc.thePlayer.onGround){
                        mc.thePlayer.jump();

                    }else if(mc.thePlayer.motionY < 0.1111111 || this.rejoin){
                    airTicks++;
                        this.rejoin = true;
                    //mc.thePlayer.jump();
                    mc.thePlayer.motionY =0.2222 + airTicks * 0.11;
         //           mc.thePlayer.setSpeed(5);
                    ;
                    if (airTicks > 2) {
                        airTicks = -2;
                    }
                }
            }
        }
        /*/
    //    mc.thePlayer.isChild() = true;
/*/
/*/
/*/
            if(this.shouldreset) {
                //DAMAGE start
                if (mc.thePlayer.onGround) {

                    mc.timer.timerSpeed = 2f;
                    airTicks =5;
                    mc.thePlayer.motionY = 0.42;
                    this.nextTick = true;
                    if (mc.thePlayer.hurtResistantTime > 5) {
                        //Abfrage ob Damage klappt
                        this.shouldreset = false;
                        mc.thePlayer.motionY = 0;
                    }
                } else {
                    if (this.nextTick) {
                        if (mc.thePlayer.motionY < 0) {
                            nextTick = false;
                            mc.thePlayer.sendQueue.addToSendQueue(new C03PacketPlayer.C04PacketPlayerPosition(mc.thePlayer.posX,mc.thePlayer.posY+3,mc.thePlayer.posZ,false));

                        }
                    }
                }
                //Damage end
            }else {
                if(mc.thePlayer.onGround) {
                    mc.thePlayer.motionY = 0.25;
                }
                mc.timer.timerSpeed = 0.5f;
                //VERZWEIFLUNG

                       // mc.thePlayer.motionY = 0.0101 + airTicks * 0.05;


                    airTicks++;

                    if (airTicks > 4) {
                        airTicks = 0;
                    }
            }

/*/
            /*/
        if(mc.thePlayer.onGround){
            if(mc.thePlayer.hurtResistantTime > 15){
                mc.thePlayer.motionY = 0.3;
                airTicks = 0;
            }

        }else{
            if(mc.thePlayer.hurtResistantTime > 15){
                airTicks++;
            mc.thePlayer.motionY = 0.3- airTicks * 0.05;
            if(airTicks > 5){
                airTicks = 0;
            }
            //    mc.thePlayer.setSpeed(5);
                mc.timer.timerSpeed = 0.5f;
            }
        /*/

//OWNACFLY



    public double speed = 0;
    public boolean  disabling= true;
    public BlockPos posToGo = new BlockPos(0,0,0);
    public void onUpdate() {
     

        if(false) {
            if (mc.thePlayer.onGround) {
                this.directionToFly = (float) mc.thePlayer.posY;
            }
            Main.getMain.cmdManager.sendChatMessage(directionToFly - mc.thePlayer.posY + "");
            if (directionToFly - mc.thePlayer.posY > 4) {
                mc.thePlayer.sendQueue.addToSendQueue(new C03PacketPlayer.C04PacketPlayerPosition(mc.thePlayer.posX, mc.thePlayer.posY, mc.thePlayer.posZ, true));
                Main.getMain.cmdManager.sendChatMessage("test");
            }
            if (mc.thePlayer.hurtResistantTime > 0) {
                mc.thePlayer.setPosition(mc.thePlayer.posX, directionToFly + 1, mc.thePlayer.posZ);
                mc.thePlayer.motionY = -1;
                if (mc.gameSettings.keyBindForward.pressed || mc.gameSettings.keyBindLeft.pressed || mc.gameSettings.keyBindRight.pressed || mc.gameSettings.keyBindBack.pressed) {
                    mc.thePlayer.setSpeed(2);
                    if (mc.gameSettings.keyBindSprint.pressed) {
                        mc.thePlayer.setSpeed(4);
                    }
                } else {
                    mc.thePlayer.setSpeed(0);
                }
                if (mc.gameSettings.keyBindJump.pressed) {
                    directionToFly += 0.4;
                }
                if (mc.gameSettings.keyBindSneak.pressed) {
                    directionToFly -= 0.4;
                }
            }
        }

        if(this.Cobra.getValue()) {



                double blocks = 9;
                double x = Math.cos(Math.toRadians(mc.thePlayer.rotationYaw + 90.0F));
                double z = Math.sin(Math.toRadians(mc.thePlayer.rotationYaw + 90.0F));
                double y = mc.thePlayer.posY;



                        mc.thePlayer.sendQueue.addToSendQueue(new C03PacketPlayer.C06PacketPlayerPosLook(mc.thePlayer.posX + (1.0D * blocks * x + 0.0D * blocks * z), mc.thePlayer.posY, mc.thePlayer.posZ + (1.0D * blocks * z - 0.0D * blocks * x), new Random().nextInt(360), mc.thePlayer.rotationPitch, true));
         //   mc.thePlayer.sendQueue.addToSendQueue(new C03PacketPlayer.C06PacketPlayerPosLook((mc.thePlayer.posX + (1.0D * blocks * x + 0.0D * blocks * z)),Integer.MAX_VALUE, mc.thePlayer.posZ + (1.0D * blocks * z - 0.0D * blocks * x),new Random().nextInt(360), mc.thePlayer.rotationPitch, false));
                     mc.thePlayer.sendQueue.addToSendQueue(new C03PacketPlayer.C06PacketPlayerPosLook((mc.thePlayer.posX + (1.0D * blocks * x + 0.0D * blocks * z)),-Integer.MAX_VALUE, mc.thePlayer.posZ + (1.0D * blocks * z - 0.0D * blocks * x),new Random().nextInt(360), mc.thePlayer.rotationPitch, false));


                //   oldpacket.y +=2;
                //mc.thePlayer.setSpeed(1);

                //    mc.timer.timerSpeed = 0.5f;
                mc.thePlayer.motionY = 0;
            }

        if(this.NCPBow.getValue()){
            if(mc.thePlayer.onGround){
                speed = 0;
            }
            if(mc.thePlayer.hurtTime > 9){
             //   mc.thePlayer.motionY = 0.32;
                speed ++;
            }
            if(mc.thePlayer.hurtResistantTime > 10 &&!mc.thePlayer.onGround){
                MovementInput movementInput = mc.thePlayer.movementInput;
                float yaw = Minecraft.getMinecraft().thePlayer.rotationYaw;
                float strafe = movementInput.moveStrafe;
                double mx = Math.cos(Math.toRadians(yaw + 90.0F));
                double mz = Math.sin(Math.toRadians(yaw + 90.0F));
                int speed = EnchantmentHelper.getEnchantmentLevel(Enchantment.power.effectId, mc.thePlayer.getCurrentEquippedItem());
                if(speed == 00){
                    mc.thePlayer.setSpeed(0.7);
                }
            }

            mc.timer.timerSpeed = mc.thePlayer.motionY > 0 ? 0.2f: 0.1f;
            ItemStack stack = mc.thePlayer.getCurrentEquippedItem();
            if ((stack != null) && ((stack.getItem() instanceof ItemBow)))
            {
                this.airTicks += 1;
                if (this.airTicks >= 4)
                {
                    if(mc.thePlayer.onGround){
                        mc.thePlayer.jump();
                    }else{
                    }
                    mc.thePlayer.sendQueue.addToSendQueue(new C07PacketPlayerDigging(C07PacketPlayerDigging.Action.RELEASE_USE_ITEM, new BlockPos(mc.thePlayer.posX, mc.thePlayer.posY, mc.thePlayer.posZ), EnumFacing.DOWN));
                    this.airTicks = 0;
                }
                else
                {
                    mc.thePlayer.sendQueue.addToSendQueue(new C08PacketPlayerBlockPlacement(mc.thePlayer.inventory.getCurrentItem()));
                }
            }

        }

      //  mc.thePlayer.sleeping = true;



//        mc.thePlayer.motionY = 0.013;
/*/

        if (mc.thePlayer.hurtTime > 0 && this.disabling) {
            if(!mc.thePlayer.onGround) {
                mc.thePlayer.setSpeed(mc.thePlayer.getSpeed() * 1.3);
                if (mc.thePlayer.getSpeed() > 1.25) {
                    mc.thePlayer.setSpeed(1.25);
                    this.disabling = false;
                }
                this.speed = mc.thePlayer.getSpeed();
                mc.thePlayer.motionY += 0.013;
            }else{
                mc.thePlayer.jump();
                mc.thePlayer.setSpeed(mc.thePlayer.getSpeed() * 1.1);
            }
        }else{

        //    mc.thePlayer.motionY =- 0.013;
            if(speed > 0.2) {
                if(mc.thePlayer.onGround){
                    mc.thePlayer.jump();
                }
                mc.thePlayer.setSpeed(speed);
            }
            speed /= 1.02;
        }
/*/
/*/
        if (mc.theWorld.getBlockState(new BlockPos(mc.thePlayer.posX, mc.thePlayer.posY - 1, mc.thePlayer.posZ)).getBlock() instanceof BlockIce || mc.theWorld.getBlockState(new BlockPos(mc.thePlayer.posX, mc.thePlayer.posY - 1, mc.thePlayer.posZ)).getBlock() instanceof BlockPackedIce) {
            mc.thePlayer.motionX *= 1.2;
            mc.thePlayer.motionZ *= 1.2;
            this.nextTick = ! this.nextTick;
            if(this.nextTick) {
                mc.thePlayer.setSpeed((mc.thePlayer.getSpeed() * -1) -0.03);
            }else{
                mc.thePlayer.setSpeed(mc.thePlayer.getSpeed()+0.03);
            }
            if (mc.thePlayer.getSpeed() > 1.2) {
                mc.thePlayer.setSpeed(1.2);
                this.disabling = false;
            }
            if (!this.disabling) {
                mc.thePlayer.setSpeed(1.15);
            }
            this.speed = 0;
            double blocks = mc.thePlayer.getSpeed();
            double x = Math.cos(Math.toRadians(mc.thePlayer.rotationYaw + 90.0F));
            double z = Math.sin(Math.toRadians(mc.thePlayer.rotationYaw + 90.0F));
            double y = mc.thePlayer.posY;
            this.speed = mc.thePlayer.getSpeed();
            Block b = mc.theWorld.getBlockState(new BlockPos(mc.thePlayer.posX + (1.0D * blocks * x + 0.0D * blocks * z), mc.thePlayer.posY-1, mc.thePlayer.posZ + (1.0D * blocks * z - 0.0D * blocks * x))).getBlock();
            if(!((b instanceof BlockPackedIce) && !((b instanceof BlockIce)))){
                if(mc.thePlayer.onGround) {
                    mc.thePlayer.jump();
                }
            }
        }else{

            if(speed > 0.2){
                if(!mc.thePlayer.onGround){
                    mc.thePlayer.motionY += 0.013;
                }
                mc.thePlayer.setSpeed(speed);
                speed /= 1.02;
            }
            if(mc.thePlayer.isCollidedHorizontally){
                speed = 0;
            }


        }
/*/
/*/
        if(speed < mc.thePlayer.getSpeed()) {
            speed = mc.thePlayer.getSpeed()+0.6;
        }else{
            if(!mc.thePlayer.onGround) {
                mc.thePlayer.setSpeed(speed);
                speed /= 1.02;
            }
        }
        mc.thePlayer.motionY += 0.013;
/*/
      //  Main.getMain.cmdManager.sendChatMessage( mc.theWorld.getBlockState(new BlockPos(mc.thePlayer.posX,mc.thePlayer.posY,mc.thePlayer.posZ)).getBlock()+"");
        if(this.AACWallAdvanced.getValue()) {
            if (!mc.thePlayer.onGround) {
                if(airTicks < 2) {
                    mc.thePlayer.motionY = 0;
                }else{
                    mc.thePlayer.motionY = -0.1;
                }
                airTicks++;
            }else{
                airTicks = 0;
            }
            if(mc.gameSettings.keyBindAttack.pressed){
                int canstart = 0;
                for(int i = -6;i < 3; ++i ){
                    Block block = mc.theWorld.getBlockState(new BlockPos(mc.thePlayer.posX+i,mc.thePlayer.posY-1,mc.thePlayer.posZ)).getBlock();
                    Block block2 = mc.theWorld.getBlockState(new BlockPos(mc.thePlayer.posX+i,mc.thePlayer.posY,mc.thePlayer.posZ)).getBlock();
                    Block block3 = mc.theWorld.getBlockState(new BlockPos(mc.thePlayer.posX+i,mc.thePlayer.posY+1,mc.thePlayer.posZ)).getBlock();
                    Block block4 = mc.theWorld.getBlockState(new BlockPos(mc.thePlayer.posX+i,mc.thePlayer.posY+2,mc.thePlayer.posZ)).getBlock();
                    if(block != Blocks.air){
                        if(block2 == Blocks.air){
                            if(block3 == Blocks.air){
                                if(block4 != Blocks.air){
                                    canstart ++;
                                }
                            }
                        }
                    }
                }
                for(int i = -6;i < 3; ++i ){
                    Block block = mc.theWorld.getBlockState(new BlockPos(mc.thePlayer.posX,mc.thePlayer.posY-1,mc.thePlayer.posZ+i)).getBlock();
                    Block block2 = mc.theWorld.getBlockState(new BlockPos(mc.thePlayer.posX,mc.thePlayer.posY,mc.thePlayer.posZ+i)).getBlock();
                    Block block3 = mc.theWorld.getBlockState(new BlockPos(mc.thePlayer.posX,mc.thePlayer.posY+1,mc.thePlayer.posZ+i)).getBlock();
                    Block block4 = mc.theWorld.getBlockState(new BlockPos(mc.thePlayer.posX,mc.thePlayer.posY+2,mc.thePlayer.posZ+i)).getBlock();
                    if(block != Blocks.air){
                        if(block2 == Blocks.air){
                            if(block3 == Blocks.air){
                                if(block4 != Blocks.air){
                                    canstart  ++;
                                }
                            }
                        }
                    }
                }
                if(canstart >= 10) {
                    shouldreset = false;
                    mc.gameSettings.keyBindForward.pressed = false;
                }else{
                    Main.getMain.cmdManager.sendChatMessage("§4Cant Start Here");
                }
            }
            if (this.disabling && !this.shouldreset) {
                //  mc.timer.timerSpeed = 1f;
                //mc.thePlayer.rotationYaw =  90;
                double rotation2 = mc.thePlayer.rotationYaw > 0 ? -mc.thePlayer.rotationYaw : mc.thePlayer.rotationYaw;
                boolean reverse = mc.thePlayer.rotationYaw > 0;
                double rotation = ((int) rotation2 % 360) * -1;
                double yaw = 0;
                if (rotation <= 45 || rotation > 315) {
                    yaw = 0;
                }
                if (rotation > 45 && rotation < 135) {

                    yaw = 90;
                }
                if (rotation >= 135 && rotation < 225) {

                    yaw = 180;
                }
                if (rotation >= 225 && rotation <= 315) {

                    yaw = 270;
                }
                if (!reverse) {
                    yaw *= -1;
                }
                mc.gameSettings.keyBindForward.pressed = false;
                mc.thePlayer.rotationYaw = (float) yaw;
                mc.thePlayer.setSpeed(mc.thePlayer.getSpeed() + 0.17);
                mc.thePlayer.setSpeed(mc.thePlayer.getSpeed() * 1.8);
                Main.getMain.cmdManager.sendChatMessage("" + ((mc.thePlayer.getSpeed() > 10 ? 10 : mc.thePlayer.getSpeed()) / 10.0f) * 100 + " %");
                this.speed = mc.thePlayer.getSpeed();
                this.nextTick = !this.nextTick;
                if (this.nextTick) {
                    mc.thePlayer.setSpeed(mc.thePlayer.getSpeed() * -1);

                } else {
                    mc.thePlayer.setSpeed(mc.thePlayer.getSpeed());
                }
                if (mc.thePlayer.getSpeed() > 10) {
                    this.disabling = false;
                }
            } else {
                if (!this.shouldreset) {
                    //      mc.timer.timerSpeed = 0.05F;
                    //   SunAPI.sendChatMessage("§4 TIMER SPEED 0.05 REAL SPEED IS 20 TIME FASTER!");
                    mc.thePlayer.setSpeed(speed);
                    if (mc.thePlayer.onGround) {
                        mc.thePlayer.jump();
                    }
                    speed /= 1.035;

                    mc.thePlayer.rotationYaw = this.directionToFly;
                }

            }
            if (this.Cubecraft.getValue()) {

                    mc.timer.timerSpeed = 0.3f;
                    mc.thePlayer.motionY += 0.05;
                   // mc.thePlayer.addSpeed(0.05);

            }
        }

        if(this.AACWall.getValue()) {
            if (!mc.thePlayer.onGround) {
                mc.thePlayer.motionY += 0.013;
            }
            if (this.disabling) {
                //  mc.timer.timerSpeed = 1f;
                //mc.thePlayer.rotationYaw =  90;
                double rotation2 = mc.thePlayer.rotationYaw > 0 ? -mc.thePlayer.rotationYaw : mc.thePlayer.rotationYaw;
                boolean reverse = mc.thePlayer.rotationYaw > 0;
                double rotation = ((int) rotation2 % 360) * -1;
                double yaw = 0;
                if (rotation <= 45 || rotation > 315) {
                    yaw = 0;
                }
                if (rotation > 45 && rotation < 135) {

                    yaw = 90;
                }
                if (rotation >= 135 && rotation < 225) {

                    yaw = 180;
                }
                if (rotation >= 225 && rotation <= 315) {

                    yaw = 270;
                }
                if (!reverse) {
                    yaw *= -1;
                }

                mc.thePlayer.rotationYaw = (float) yaw;
                mc.thePlayer.setSpeed(mc.thePlayer.getSpeed() + 0.17);
                mc.thePlayer.setSpeed(mc.thePlayer.getSpeed() * 1.8);
                Main.getMain.cmdManager.sendChatMessage("" + ((mc.thePlayer.getSpeed() > 10 ? 10 : mc.thePlayer.getSpeed()) / 10.0f) * 100 + " %");
                this.speed = mc.thePlayer.getSpeed();
                this.nextTick = !this.nextTick;
                if (this.nextTick) {
                    mc.thePlayer.setSpeed(mc.thePlayer.getSpeed() * -1);

                } else {
                    mc.thePlayer.setSpeed(mc.thePlayer.getSpeed());
                }
                if (mc.thePlayer.getSpeed() > 10) {
                    this.disabling = false;
                }
            } else {


                //      mc.timer.timerSpeed = 0.050.05F;
                //   SunAPI.sendChatMessage("§4 TIMER SPEED 0.05 REAL SPEED IS 20 TIME FASTER!");
                mc.thePlayer.setSpeed(speed);
                if (mc.thePlayer.onGround) {
                    mc.thePlayer.jump();
                }
                speed /= 1.035;

            }
        }
        if (this.Cubecraft.getValue()) {
                    mc.timer.timerSpeed = 0.3f;
                mc.thePlayer.motionY +=0.055;
        }
    if(this.AACVelocity.getValue()) {
        if (mc.thePlayer.onGround) {
            this.rejoin = false;
            this.nextTick = true;
            mc.thePlayer.jump();
    //        mc.thePlayer.setSpeed(0.3);
            this.airTicks = 0;
        }
        if (mc.thePlayer.fallDistance > 0.5) {
            this.rejoin = true;
        }
        if (this.rejoin) {
            this.nextTick = !this.nextTick;
            mc.thePlayer.setSpeed(nextTick ? 0.75 : 0);
            this.airTicks++;

            mc.thePlayer.motionY += 0.013;
            mc.timer.timerSpeed = 0.2f;

        } else {
            if (!mc.thePlayer.onGround) {
                if (this.nextTick) {

                        mc.thePlayer.motionX *= -1;
                        mc.thePlayer.motionZ *= -1;
                        this.nextTick = false;
              //      this.rejoin = true;
                }
            }
        }
    }

		 	if(this.AAC.getValue()) {
		 	    if(mc.theWorld.getBlockState(new BlockPos(mc.thePlayer.posX,mc.thePlayer.posY,mc.thePlayer.posZ)).getBlock() instanceof BlockFence){
		 	        if(mc.thePlayer.onGround) {
                        mc.thePlayer.motionY = 8;

                        return;
                    }
                }
                if(mc.theWorld.getBlockState(new BlockPos(mc.thePlayer.posX,mc.thePlayer.posY-1,mc.thePlayer.posZ)).getBlock() instanceof BlockSlime){
                    if(mc.thePlayer.onGround){
                        mc.thePlayer.motionY = 1.4;
                        return;
                    }
                }
				if (mc.thePlayer.onGround) {
					mc.thePlayer.setSprinting(true);
					mc.thePlayer.jump();
					mc.thePlayer.motionX *= 1.05;
					mc.thePlayer.motionZ *= 1.05;
					airtime = 0;
					mc.thePlayer.motionY = 1;
				} else {
                    mc.thePlayer.motionY += 0.013;
					mc.timer.timerSpeed = 1f;
					if (mc.thePlayer.fallDistance > 5.46) {
					    mc.thePlayer.motionY = 0;
                        mc.thePlayer.setSpeed(5);
					}
					nextTick = !this.nextTick;

				}
			}

			
			
	}
	
	
	

}

minecraft_de_Client_Main_Modules_mods_Movment_Longjump.java

package de.Client.Main.Modules.mods.Movment;


import java.util.List;

import de.Client.Events.EventTarget;
import de.Client.Events.Events.MoveEvent;
import de.Client.Events.Events.PacketReceiveEvent;
import de.Client.Events.Events.UpdateEvent;
import de.Client.Main.Modules.Category;
import de.Client.Main.Modules.Module;
import de.Client.Main.Values.ValueBoolean;
import de.Client.Utils.TimeHelper;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.network.play.client.C03PacketPlayer;
import net.minecraft.network.play.server.S08PacketPlayerPosLook;
import net.minecraft.potion.Potion;
import net.minecraft.util.AxisAlignedBB;
import org.lwjgl.opengl.Display;

public class Longjump extends Module {
    private ValueBoolean NoDMG;
    private ValueBoolean Glide;
    private ValueBoolean Cubecraft;
    private ValueBoolean TAC;
    private boolean cancel;
    private boolean speedTick;
    private float speedTimer = (float) 1.35;
    private int timer;
    public static boolean yport;

    private double save;
    public static boolean canStep;
    private boolean stop;
    public static boolean boost = false;
    private float ground = 0.0F;

    private boolean shouldreset;

    private int timerDelay;
    private float headStart;
    private int airTicks;

    private int groundTicks;

    private int packets;

    private boolean groundBoolean;

    private int state;

    private boolean isSpeeding;

    private double lastHDistance;

    public static double yOffset;
    private int stage;
    private double moveSpeed;
    private double lastDist;
    private ValueBoolean CubecraftGlide;

    public Longjump() {
        super("LongJump",  Category.MOVEMENT,0);
        addValue(this.Cubecraft = new ValueBoolean("Cubecraft", false));
        addValue(this.CubecraftGlide = new ValueBoolean("CubecraftGlide", false));
        addValue(this.Glide = new ValueBoolean("Glide", false));
    }
    @EventTarget
    private void onUpdate(UpdateEvent event) {

        boolean speedy = this.mc.thePlayer.isPotionActive(Potion.moveSpeed);
        double xDist = this.mc.thePlayer.posX - this.mc.thePlayer.prevPosX;
        double zDist = this.mc.thePlayer.posZ - this.mc.thePlayer.prevPosZ;
        this.lastDist = Math.sqrt(xDist * xDist + zDist * zDist);

    }
    @Override
    public void onEnable(){
        try{
            mc.timer.timerSpeed = 1;


            this.isSpeeding = false;
            this.moveSpeed = (mc.thePlayer == null ? 0.2873D : getBaseMoveSpeed());
            if(this.Cubecraft.getValue()){
                mc.thePlayer.motionX = 0;
                mc.thePlayer.motionZ = 0;
            }
            this.isSpeeding = false;

            // SunRiseAPI.sendChatMessage("No longer requires horizontal collision
            // to bypass.");
            this.stop = true;
            boost = true;
            this.stage = 1;
            time.reset();
            //	 EventManager.register(this);
        }catch(Exception e){

        }
        super.onEnable();
    }
    @Override
    public void onDisable(){
        mc.timer.timerSpeed = 1;
        super.onDisable();

    }
    public TimeHelper time = new TimeHelper();
    private boolean jumped;

    public void setMoveSpeed(MoveEvent event, final double speed) {
        double forward = mc.thePlayer.movementInput.moveForward;
        double strafe = mc.thePlayer.movementInput.moveStrafe;
        float yaw = mc.thePlayer.rotationYaw;
        if (forward == 0.0 && strafe == 0.0) {
            event.setX(0.0);
            event.setZ(0.0);
        }
        else {
            if (forward != 0.0) {
                if (strafe > 0.0) {
                    yaw += ((forward > 0.0) ? -45 : 45);
                }
                else if (strafe < 0.0) {
                    yaw += ((forward > 0.0) ? 45 : -45);
                }
                strafe = 0.0;
                if (forward > 0.0) {
                    forward = 1.0;
                }
                else if (forward < 0.0) {
                    forward = -1.0;
                }
            }
            event.setX(forward * speed * Math.cos(Math.toRadians(yaw + 90.0f)) + strafe * speed * Math.sin(Math.toRadians(yaw + 90.0f)));
            event.setZ(forward * speed * Math.sin(Math.toRadians(yaw + 90.0f)) - strafe * speed * Math.cos(Math.toRadians(yaw + 90.0f)));
        }
    }

    private double getBaseMoveSpeed() {
        double baseSpeed = 0.2873D;
        if (this.mc.thePlayer.isPotionActive(Potion.moveSpeed)) {
            int amplifier = this.mc.thePlayer.getActivePotionEffect(Potion.moveSpeed).getAmplifier();
            baseSpeed *= (1.0D + 0.2D * (amplifier + 1));
        }
        return baseSpeed;
    }
    @EventTarget
    public void onPacketReceiveEvent(PacketReceiveEvent e){
        if(e.getPacket() instanceof S08PacketPlayerPosLook){
            this.toggleModule();
        }
    }


    @EventTarget
    public void onMove2(MoveEvent event) {
        if(this.CubecraftGlide.getValue()){
            this.Cubecraft.setValue(true);
        }

        if (this.Cubecraft.getValue() && this.getState()) {
            if(this.CubecraftGlide.getValue()){
                event.y /= 200;
                mc.thePlayer.motionY /= 200;
            }else{
                mc.timer.timerSpeed = 0.85f;
            }
            if (time.hasReached((this.CubecraftGlide.getValue() ? 200 : 200)) && !mc.thePlayer.isCollidedHorizontally) {
                if (mc.thePlayer.moveForward == 0.0f && mc.thePlayer.moveStrafing == 0.0f) {
                    this.moveSpeed = this.getBaseMoveSpeed();
                }
                if (this.stage == 1 && mc.thePlayer.isCollidedVertically
                        && (mc.thePlayer.moveForward != 0.0f || mc.thePlayer.moveStrafing != 0.0f)) {
                    this.moveSpeed = 1 + this.getBaseMoveSpeed();
                } else if (this.stage == 2 && mc.thePlayer.isCollidedVertically
                        && (mc.thePlayer.moveForward != 0.0f || mc.thePlayer.moveStrafing != 0.0f)) {
                    event.setY(mc.thePlayer.motionY = 0.43);
                    this.jumped = true;
                    this.moveSpeed *= 2.149;
                } else if (this.stage == 3) {
                    final double difference = 0.66 * (this.lastDist - this.getBaseMoveSpeed());
                    this.moveSpeed = this.lastDist - difference;
                } else {
                    final List collidingList = mc.theWorld.getCollidingBoundingBoxes(mc.thePlayer,
                            mc.thePlayer.boundingBox.offset(0.0, mc.thePlayer.motionY, 0.0));
                    if ((collidingList.size() > 0 || mc.thePlayer.isCollidedVertically) && this.stage > 0) {
                        if (1.5 * this.getBaseMoveSpeed() > this.moveSpeed) {
                            this.stage = 0;
                        } else {
                            this.stage = ((mc.thePlayer.moveForward != 0.0f
                                    || mc.thePlayer.moveStrafing != 0.0f) ? 1 : 0);
                        }
                    }
                    this.moveSpeed = this.lastDist - this.lastDist / 159.0;
                }
                this.moveSpeed = Math.max(this.moveSpeed, this.getBaseMoveSpeed());
                if (this.stage > 0) {
                    this.setMoveSpeed(event, this.moveSpeed);
                }
                if (mc.thePlayer.moveForward != 0.0f || mc.thePlayer.moveStrafing != 0.0f) {
                    ++this.stage;
                }

            } else {
                this.jumped = false;
                mc.thePlayer.motionX /= 13;
                mc.thePlayer.motionZ /= 13;
            }
        }
    }
    private double getDistance(EntityPlayer player, double distance)
    {
        List<AxisAlignedBB> boundingBoxes = player.worldObj.getCollidingBoundingBoxes(mc.thePlayer,player.getEntityBoundingBox().addCoord(0.0D, -distance, 0.0D));
        if (boundingBoxes.isEmpty()) {
            return 0.0D;
        }
        double y = 0.0D;
        for (AxisAlignedBB boundingBox : boundingBoxes) {
            if (boundingBox.maxY > y) {
                y = boundingBox.maxY;
            }
        }
        return player.posY - y;
    }
    public void updatePosition(double x, double y, double z)
    {
        this.mc.thePlayer.sendQueue.addToSendQueue(new C03PacketPlayer.C04PacketPlayerPosition(x, y, z, this.mc.thePlayer.onGround));
    }
    public void onUpdate(){

        if(this.Cubecraft.getValue()){



            return;
        }
        if(mc.thePlayer.moveForward == 0 && mc.thePlayer.moveStrafing == 0){
            mc.thePlayer.motionX = 0;
            mc.thePlayer.motionZ = 0;
        }
        if(mc.gameSettings.keyBindForward.pressed && !mc.gameSettings.keyBindLeft.pressed && !mc.gameSettings.keyBindRight.pressed && !mc.gameSettings.keyBindBack.pressed){
            mc.thePlayer.setSprinting(false);
            if ((this.mc.theWorld != null) && (this.mc.thePlayer != null) &&
                    (this.mc.thePlayer.onGround) && (!this.mc.thePlayer.isDead)) {
                this.lastHDistance = 0.0D;
            }
            float direction = this.mc.thePlayer.rotationYaw + (this.mc.thePlayer.moveForward <  0 ? 180 : 0) + (this.mc.thePlayer.moveStrafing > 0.0F ? -90.0F * (this.mc.thePlayer.moveForward > 0.0F ? 0.5F : this.mc.thePlayer.moveForward < 0.0F ? -0.5F : 1.0F) : 0.0F) - (this.mc.thePlayer.moveStrafing < 0.0F ? -90.0F * (this.mc.thePlayer.moveForward > 0.0F ? 0.5F : this.mc.thePlayer.moveForward < 0.0F ? -0.5F : 1.0F) : 0.0F);

            float xDir = (float)Math.cos((direction + 90.0F) * 3.141592653589793D / 180.0D);
            float zDir = (float)Math.sin((direction + 90.0F) * 3.141592653589793D / 180.0D);
            if (!this.mc.thePlayer.isCollidedVertically)
            {
                this.airTicks += 1;
                this.isSpeeding = true;
                if (this.mc.gameSettings.keyBindSneak.pressed) {
                    this.mc.thePlayer.sendQueue.addToSendQueue(new C03PacketPlayer.C04PacketPlayerPosition(0.0D, 2.147483647E9D, 0.0D, false));
                }
                this.groundTicks = 0;
                if (!this.mc.thePlayer.isCollidedVertically)
                {
                    if (this.mc.thePlayer.motionY == -0.07190068807140403D) {
                        this.mc.thePlayer.motionY *= 0.3499999940395355D;
                    }
                    if (this.mc.thePlayer.motionY == -0.10306193759436909D) {
                        this.mc.thePlayer.motionY *= 0.550000011920929D;
                    }
                    if (this.mc.thePlayer.motionY == -0.13395038817442878D) {
                        this.mc.thePlayer.motionY *= 0.6700000166893005D;
                    }
                    if (this.mc.thePlayer.motionY == -0.16635183030382D) {
                        this.mc.thePlayer.motionY *= 0.6899999976158142D;
                    }
                    if (this.mc.thePlayer.motionY == -0.19088711097794803D) {
                        this.mc.thePlayer.motionY *= 0.7099999785423279D;
                    }
                    if (this.mc.thePlayer.motionY == -0.21121925191528862D) {
                        this.mc.thePlayer.motionY *= 0.20000000298023224D;
                    }
                    if (this.mc.thePlayer.motionY == -0.11979897632390576D) {
                        this.mc.thePlayer.motionY *= 0.9300000071525574D;
                    }
                    if (this.mc.thePlayer.motionY == -0.18758479151225355D) {
                        this.mc.thePlayer.motionY *= 0.7200000286102295D;
                    }
                    if (this.mc.thePlayer.motionY == -0.21075983825251726D) {
                        this.mc.thePlayer.motionY *= 0.7599999904632568D;
                    }
                    if ((this.Glide.getValue()))
                    {
                        //SunRiseAPI.sendChatMessage(mc.timer.timerSpeed + "");
                        if (this.mc.thePlayer.motionY == -0.23537393014173347D) {
                            this.mc.thePlayer.motionY *= 0.029999999329447746D;
                        }
                        if (this.mc.thePlayer.motionY == -0.08531999505205401D) {
                            this.mc.thePlayer.motionY *= -0.5D;
                        }
                        if (this.mc.thePlayer.motionY == -0.03659320313669756D) {
                            this.mc.thePlayer.motionY *= -0.10000000149011612D;
                        }
                        if (this.mc.thePlayer.motionY == -0.07481386749524899D) {
                            this.mc.thePlayer.motionY *= -0.07000000029802322D;
                        }
                        if (this.mc.thePlayer.motionY == -0.0732677700939672D) {
                            this.mc.thePlayer.motionY *= -0.05000000074505806D;
                        }
                        if (this.mc.thePlayer.motionY == -0.07480988066790395D) {
                            this.mc.thePlayer.motionY *= -0.03999999910593033D;
                        }
                        if (this.mc.thePlayer.motionY == -0.0784000015258789D) {
                            this.mc.thePlayer.motionY *= 0.10000000149011612D;
                        }
                        if (this.mc.thePlayer.motionY == -0.08608320193943977D) {
                            this.mc.thePlayer.motionY *= 0.10000000149011612D;
                        }
                        if (this.mc.thePlayer.motionY == -0.08683615560584318D) {
                            this.mc.thePlayer.motionY *= 0.05000000074505806D;
                        }
                        if (this.mc.thePlayer.motionY == -0.08265497329678266D) {
                            this.mc.thePlayer.motionY *= 0.05000000074505806D;
                        }
                        if (this.mc.thePlayer.motionY == -0.08245009535659828D) {
                            this.mc.thePlayer.motionY *= 0.05000000074505806D;
                        }
                        if (this.mc.thePlayer.motionY == -0.08244005633718426D) {
                            this.mc.thePlayer.motionY = -0.08243956442521608D;
                        }
                        if (this.mc.thePlayer.motionY == -0.08243956442521608D) {
                            this.mc.thePlayer.motionY = -0.08244005590677261D;
                        }
                        if ((this.mc.thePlayer.motionY > -0.1D) && (this.mc.thePlayer.motionY < -0.08D) && (!this.mc.thePlayer.onGround) && (this.mc.gameSettings.keyBindForward.pressed)) {
                            this.mc.thePlayer.motionY = -9.999999747378752E-5D;
                        }
                    }
                    else
                    {
                        if ((this.mc.thePlayer.motionY < -0.2D) && (this.mc.thePlayer.motionY > -0.24D)) {
                            this.mc.thePlayer.motionY *= 0.7D;
                        }
                        if ((this.mc.thePlayer.motionY < -0.25D) && (this.mc.thePlayer.motionY > -0.32D)) {
                            this.mc.thePlayer.motionY *= 0.8D;
                        }
                        if ((this.mc.thePlayer.motionY < -0.35D) && (this.mc.thePlayer.motionY > -0.8D)) {
                            this.mc.thePlayer.motionY *= 0.98D;
                        }
                        if ((this.mc.thePlayer.motionY < -0.8D) && (this.mc.thePlayer.motionY > -1.6D)) {
                            this.mc.thePlayer.motionY *= 0.99D;
                        }
                    }
                }
                if (this.headStart > 0.0F) {}
                mc.timer.timerSpeed = 0.85F;
                double[] speedVals = { 0.420606D, 0.417924D, 0.415258D, 0.412609D, 0.409977D, 0.407361D, 0.404761D, 0.402178D, 0.399611D, 0.39706D, 0.394525D, 0.392D, 0.3894D, 0.38644D, 0.383655D, 0.381105D, 0.37867D, 0.37625D, 0.37384D, 0.37145D, 0.369D, 0.3666D, 0.3642D, 0.3618D, 0.35945D, 0.357D, 0.354D, 0.351D, 0.348D, 0.345D, 0.342D, 0.339D, 0.336D, 0.333D, 0.33D, 0.327D, 0.324D, 0.321D, 0.318D, 0.315D, 0.312D, 0.309D, 0.307D, 0.305D, 0.303D, 0.3D, 0.297D, 0.295D, 0.293D, 0.291D, 0.289D, 0.287D, 0.285D, 0.283D, 0.281D, 0.279D, 0.277D, 0.275D, 0.273D, 0.271D, 0.269D, 0.267D, 0.265D, 0.263D, 0.261D, 0.259D, 0.257D, 0.255D, 0.253D, 0.251D, 0.249D, 0.247D, 0.245D, 0.243D, 0.241D, 0.239D, 0.237D };
                if (this.mc.gameSettings.keyBindForward.pressed)
                {
                    try
                    {
                        this.mc.thePlayer.motionX = (xDir * speedVals[(this.airTicks - 1)] * 3.0D);
                        this.mc.thePlayer.motionZ = (zDir * speedVals[(this.airTicks - 1)] * 3.0D);
                    }
                    catch (ArrayIndexOutOfBoundsException localArrayIndexOutOfBoundsException) {}
                }
                else
                {
                    this.mc.thePlayer.motionX = 0.0D;
                    this.mc.thePlayer.motionZ = 0.0D;
                }
            }
            else
            {
                mc.timer.timerSpeed = 1.0F;
                this.airTicks = 0;
                this.groundTicks += 1;
                this.headStart -= 1.0F;
                this.mc.thePlayer.motionX /= 13.0D;
                this.mc.thePlayer.motionZ /= 13.0D;
                if (this.groundTicks == 1)
                {
                    updatePosition(this.mc.thePlayer.posX, this.mc.thePlayer.posY, this.mc.thePlayer.posZ);
                    updatePosition(this.mc.thePlayer.posX + 0.0624D, this.mc.thePlayer.posY, this.mc.thePlayer.posZ);
                    updatePosition(this.mc.thePlayer.posX, this.mc.thePlayer.posY + 0.419D, this.mc.thePlayer.posZ);
                    updatePosition(this.mc.thePlayer.posX + 0.0624D, this.mc.thePlayer.posY, this.mc.thePlayer.posZ);
                    updatePosition(this.mc.thePlayer.posX, this.mc.thePlayer.posY + 0.419D, this.mc.thePlayer.posZ);
                }
                if (this.groundTicks > 2)
                {
                    this.groundTicks = 0;
                    this.mc.thePlayer.motionX = (xDir * 0.3D);
                    this.mc.thePlayer.motionZ = (zDir * 0.3D);
                    this.mc.thePlayer.motionY = 0.42399999499320984D;
                }
            }
        }

    }
}

minecraft_de_Client_Main_Modules_mods_Movment_NoFall.java

package de.Client.Main.Modules.mods.Movment;

import de.Client.Events.EventTarget;
import de.Client.Events.Events.MoveEvent;
import de.Client.Main.Main;
import de.Client.Main.Modules.Category;
import de.Client.Main.Modules.Module;
import de.Client.Utils.Macro;
import net.minecraft.entity.Entity;
import org.lwjgl.input.Controller;
import org.lwjgl.input.Controllers;
import org.lwjgl.input.Keyboard;

public class NoFall extends Module {

    public NoFall() {
        super("NoFall", Category.MOVEMENT, 0);
        // TODO Auto-generated constructor stub
    }

    @EventTarget
    public void onMove(MoveEvent e){
        if(!mc.thePlayer.onGround) {
            e.y = -999;
        }
    }

}

minecraft_de_Client_Main_Modules_mods_Movment_NoSlowDown.java

package de.Client.Main.Modules.mods.Movment;


import de.Client.Events.EventManager;
import de.Client.Events.EventTarget;
import de.Client.Events.Events.PacketSendEvent;
import de.Client.Events.Events.UpdateEvent;
import de.Client.Events.IEvent.State;
import de.Client.Main.Main;
import de.Client.Main.Modules.Category;
import de.Client.Main.Modules.Module;
import de.Client.Main.Values.ValueBoolean;
import de.Client.Render.ClickGui.Panels.Mini;
import de.Client.Render.ClickGui.Panels.Minitypes.MiniOneOfTwo;
import de.Client.Render.ClickGui.Panels.Minitypes.MiniValueBooleanToggleSimple;
import de.Client.Utils.TimeHelper;
import net.minecraft.network.Packet;
import net.minecraft.network.play.client.C03PacketPlayer;
import net.minecraft.network.play.client.C07PacketPlayerDigging;
import net.minecraft.network.play.client.C08PacketPlayerBlockPlacement;
import net.minecraft.network.play.client.C0BPacketEntityAction;
import net.minecraft.util.BlockPos;
import net.minecraft.util.EnumFacing;

import java.util.ArrayList;

public class NoSlowDown extends Module {

    public static ValueBoolean AAC = new ValueBoolean("AAC", false);
    public static ValueBoolean NCP = new ValueBoolean("NCP", false);
    public static ValueBoolean AACLatest = new ValueBoolean("AACLatest", false);
    public boolean nextTick;
    public float prevRotation;
    public TimeHelper t = new TimeHelper();
    public NoSlowDown() {
        super("NoSlowDown",Category.PLAYER, 0);
        addValue(AAC);
        addValue(NCP);
        addValue(AACLatest);
        this.displayName = "No Slowdown";
    }
    @Override
    public ArrayList<Mini> createArray(){
        ArrayList<Mini> minis = new ArrayList<>();
        minis.add( new MiniOneOfTwo(this,AAC,NCP));
        return minis;
    }

    @EventTarget
    public void onEvent(UpdateEvent pre)
    {
        if(pre.getState() == State.PRE){
            if(this.NCP.getValue() && mc.thePlayer.isBlocking()){
                mc.getNetHandler().addToSendQueue((Packet)new C08PacketPlayerBlockPlacement(mc.thePlayer.getHeldItem()));
                mc.getNetHandler().addToSendQueue((Packet)new C07PacketPlayerDigging(C07PacketPlayerDigging.Action.RELEASE_USE_ITEM, BlockPos.ORIGIN, EnumFacing.DOWN));
            }
        }

    }
    @EventTarget
    public void onPost(UpdateEvent post)
    {

        if(post.getState() == State.POST){
            if(this.NCP.getValue() && mc.thePlayer.isBlocking()){

                mc.getNetHandler().addToSendQueue((Packet)new C07PacketPlayerDigging(C07PacketPlayerDigging.Action.RELEASE_USE_ITEM, BlockPos.ORIGIN, EnumFacing.DOWN));
                mc.getNetHandler().addToSendQueue((Packet)new C08PacketPlayerBlockPlacement(mc.thePlayer.getHeldItem()));
            }
        }

    }


    public float getDiffrent(float f1, float f2){
        return (float)  Math.sqrt((f1-f2)*(f1-f2));
    }
    public void onUpdate(){
        if(this.AACLatest.getValue()) {
            if(mc.thePlayer.isBlocking()){
                if(mc.thePlayer.onGround) {
                    mc.thePlayer.motionX /= 1.2;
                    mc.thePlayer.motionZ /= 1.2;
                }else{
                    mc.thePlayer.motionX /= 1.05;
                    mc.thePlayer.motionZ /= 1.05;
                }
                this.nextTick = ! this.nextTick;
                if(this.nextTick){
                    mc.thePlayer.sendQueue.addToSendQueue(new C07PacketPlayerDigging(C07PacketPlayerDigging.Action.RELEASE_USE_ITEM, new BlockPos(-1,-1,-1), EnumFacing.fromAngle(-1.0D)));
                }else{
                    if(getDiffrent(mc.thePlayer.rotationYaw,prevRotation) < 10 ) {
                        if(t.hasReached(300)) {
                            mc.thePlayer.sendQueue.addToSendQueue(new C08PacketPlayerBlockPlacement(mc.thePlayer.inventory.getCurrentItem()));
                        }
                    }else{
                       t.reset();
                    }
                }
                    //mc.thePlayer.setSpeed(mc.thePlayer.getSpeed());
                this.prevRotation = mc.thePlayer.rotationYaw;
            }
        }

    }

    @EventTarget
    public void onPacketSendEvent(PacketSendEvent e){
        if(this.AACLatest.getValue()) {
            C03PacketPlayer p = (C03PacketPlayer) e.getPacket();
            //p.field_149474_g = false;
            e.setPacket(p);
        }
    }

    @EventTarget
    public void onAAC(UpdateEvent event){

        if(mc.thePlayer.isEating()){
            //	mc.thePlayer.motionX *= 0.65;
            //mc.thePlayer.motionZ *= 0.65;
        }
        if( mc.thePlayer.isSneaking() && mc.thePlayer.onGround){

        }

        if(this.AAC.getValue()){
            if(mc.thePlayer.isBlocking()){
                if(event.state == State.PRE){

                    mc.thePlayer.sendQueue.addToSendQueue(new C07PacketPlayerDigging(C07PacketPlayerDigging.Action.RELEASE_USE_ITEM, new BlockPos(-1,-1,-1), EnumFacing.fromAngle(-1.0D)));
                }
                if(event.state == State.POST){

                    mc.thePlayer.sendQueue.addToSendQueue(new C08PacketPlayerBlockPlacement(mc.thePlayer.inventory.getCurrentItem()));
                }
            }
        }
    }
    public void onEnable(){
        EventManager.register(this);
    }
    public void onDisable()
    {
        EventManager.unregister(this);
        mc.gameSettings.keyBindSneak.pressed = false;
        mc.getNetHandler().addToSendQueue((Packet)new C07PacketPlayerDigging(C07PacketPlayerDigging.Action.RELEASE_USE_ITEM, BlockPos.ORIGIN, EnumFacing.DOWN));
    }
}

minecraft_de_Client_Main_Modules_mods_Movment_SafeWalk.java

package de.Client.Main.Modules.mods.Movment;

import de.Client.Main.Modules.Category;
import de.Client.Main.Modules.Module;
import org.lwjgl.input.Keyboard;

public class SafeWalk extends Module {

    public SafeWalk() {
        super("SafeWalk", Category.MOVEMENT, Keyboard.KEY_Y);
        this.displayName = "Safe Walk";
    }
}

minecraft_de_Client_Main_Modules_mods_Movment_Speed.java

package de.Client.Main.Modules.mods.Movment;

import de.Client.Events.EventTarget;
import de.Client.Events.Events.EventSafeWalk;
import de.Client.Events.Events.MoveEvent;
import de.Client.Events.Events.PacketReceiveEvent;
import de.Client.Events.Events.UpdateEvent;
import de.Client.Events.IEvent.State;
import de.Client.Main.Main;
import de.Client.Main.Modules.Category;
import de.Client.Main.Modules.Module;
import de.Client.Main.Values.ValueBoolean;
import de.Client.Render.ClickGui.Panels.Mini;
import de.Client.Render.ClickGui.Panels.Minitypes.MiniExtendedValueArray;
import de.Client.Render.ClickGui.Panels.Minitypes.MiniValueBooleanToggleSimple;
import de.Client.Utils.MiniValueBooleanArray;
import de.Client.Utils.TimeHelper;
import net.minecraft.block.BlockStairs;
import net.minecraft.client.Minecraft;
import net.minecraft.client.entity.EntityPlayerSP;
import net.minecraft.entity.Entity;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.init.Blocks;
import net.minecraft.network.play.client.C02PacketUseEntity;
import net.minecraft.network.play.client.C03PacketPlayer;
import net.minecraft.network.play.server.S08PacketPlayerPosLook;
import net.minecraft.potion.Potion;
import net.minecraft.util.BlockPos;
import net.minecraft.util.EnumParticleTypes;
import net.minecraft.util.MathHelper;
import net.minecraft.util.MovementInput;
import optifine.MathUtils;
import org.lwjgl.Sys;
import org.newdawn.slick.font.effects.ConfigurableEffect;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;


public class Speed extends Module {
    public static ValueBoolean Bhop = new ValueBoolean("Bhop", true);
    public static ValueBoolean Bhoplatest = new ValueBoolean("Bhoplatest", false);
    public static ValueBoolean AACLowhop = new ValueBoolean("AACLowhop", false);
    public static ValueBoolean AACSkipHop = new ValueBoolean("AACSkipHop", false);
    public static ValueBoolean AACOnground = new ValueBoolean("AACOnground", false);
    public static ValueBoolean AACYport = new ValueBoolean("AACYport", false);
    public static ValueBoolean AACBhop = new ValueBoolean("AACBhop", false);
    public static ValueBoolean AACVeloity = new ValueBoolean("AACVelocity", false);
    public static ValueBoolean LowHop = new ValueBoolean("LHop", false);
    public static ValueBoolean LowHop2 = new ValueBoolean("LHop2", false);
    public static ValueBoolean yPort1 = new ValueBoolean("yPort", false);
    public static ValueBoolean yPortlatest = new ValueBoolean("yPortlatest", false);
    public static ValueBoolean Smooth = new ValueBoolean("Smooth", false);
    public ValueBoolean oldNcp = new ValueBoolean("oldNcp",false);
    private int motionDelay;
    public static float modifier = 4.3F;
    private int movement;
    private TimeHelper time = new TimeHelper();
    private int kekticks;

    private float height;
    boolean move;
    private boolean jumped;
    boolean canChangeMotion;
    public int bhop_ticks;
    public double bhop_moveSpeed;
    public double bhop_lastDist;
    public int frame_motionticks;
    public boolean frame_move;
    public int boost_motionDelay;
    public float boost_ground = 0.0F;
    public static boolean mode_BHop2 = false;
    private TimeHelper time2 = new TimeHelper();
    public static int BHop_Multiplier = 4;
    private String mode;


    public static ValueBoolean yPort;
    private double speed;
    private int level;
    private boolean disabling;

    public static double yOffset;
    private boolean cancel;
    private boolean speedTick;
    private float speedTimer = (float) 1.35;
    private int timer;
    public static boolean yport;
    public static int ticks;
    public static double moveSpeed;
    private double lastDist;
    private double save;
    public static boolean canStep;
    public static boolean boost = false;
    private float ground = 0.0F;

    private boolean shouldreset;
    private int timerDelay;
    private float headStart;
    private int airTicks;

    private int groundTicks;

    private int packets;

    private boolean groundBoolean;

    private int state;

    private boolean isSpeeding;

    private double lastHDistance;
    public Speed() {
        super("Speed", Category.MOVEMENT,0);
        addValue(Bhop);
        addValue(LowHop);
        addValue(LowHop2);
        addValue(yPort1);
        addValue(Bhoplatest);
        addValue(AACLowhop);
        addValue(AACSkipHop);
        addValue(AACVeloity);
        addValue(AACOnground);
        addValue(yPortlatest);
        addValue(AACYport);
        addValue(AACBhop);
        addValue(this.oldNcp);
    }

    @Override
    public ArrayList<Mini> createArray(){
        ArrayList<Mini> minis = new ArrayList<>();
        MiniExtendedValueArray miniExtendedValueArray;
            ArrayList<MiniValueBooleanArray> arrays = new ArrayList<>();
                ArrayList<ValueBoolean> ncp = new ArrayList<>();
                    ncp.add(Bhop);
                    ncp.add(LowHop);
                    ncp.add(LowHop2);
                    ncp.add(yPort1);
                    ncp.add(Bhoplatest);
            arrays.add(new MiniValueBooleanArray(ncp,"NCP"));
                ArrayList<ValueBoolean> aac = new ArrayList<>();
                    aac.add(AACLowhop);
                    aac.add(AACSkipHop);
                    aac.add(AACVeloity);
            arrays.add(new MiniValueBooleanArray(aac,"AAC"));
        miniExtendedValueArray = new MiniExtendedValueArray(this,arrays);
        minis.add(miniExtendedValueArray);
        minis.add(new MiniValueBooleanToggleSimple(this,Smooth));
        return minis;
    }
    @EventTarget
    public void onEnable() {

        speed = 0;
        cancel = true;
        this.move = true;
        this.canChangeMotion = false;
        if(this.AACLowhop.getValue()){
            cancel = true;
        }
        if(this.AACSkipHop.getValue()){
            ticks = 0;
        }
        // SunRiseAPI.sendChatMessage("No longer requires horizontal collision to bypass.");
        boolean stop = true;
        boost = true;

        this.bhop_lastDist = 0;
        double ticks = 1;
        this.moveSpeed = (mc.thePlayer == null ? 0.2873D
                : getBaseMoveSpeed());
        if(this.Bhoplatest.getValue()) {
            if (mc.thePlayer != null) {
                moveSpeed = getBaseMoveSpeed();
            }
            lastDist = 0.0D;
            this.ticks = 2;
        }
        super.onEnable();
    }

    @EventTarget
    public void onDisable() {
        mc.timer.timerSpeed = 1.0F;
        //	mc.gameSettings.viewBobbing = true;
        boost = false;
        super.onDisable();
    }


    public void onRender() {
        if (this.Smooth.getValue() && this.getState()) {
            if (!mc.thePlayer.onGround && !(mc.thePlayer.fallDistance > 1)
                    && !mc.thePlayer.isCollidedHorizontally) {
                mc.thePlayer.posY = mc.thePlayer.lastTickPosY;
                mc.thePlayer.fallDistance = 0;
            }
        }
    }
    @EventTarget
    private void onUpdate(UpdateEvent event) {
        double xDist = mc.thePlayer.posX - mc.thePlayer.prevPosX;
        double zDist = mc.thePlayer.posZ - mc.thePlayer.prevPosZ;
        this.lastDist = Math.sqrt(xDist * xDist + zDist * zDist);

        if(event.getState() == State.PRE){
            if(!mc.thePlayer.onGround && this.yPort1.getValue() && !mc.thePlayer.isCollidedHorizontally){
                mc.thePlayer.motionY = -999;
                //mc.thePlayer.sendQueue.addToSendQueue(new C03PacketPlayer(true));
                mc.timer.timerSpeed = 1.1f;
            }
        }



    }

    @EventTarget
    public void onReceive(PacketReceiveEvent e){
        if(e.getPacket() instanceof S08PacketPlayerPosLook){
            if (this.Bhop.getValue() || this.yPort1.getValue() || this.LowHop2.getValue() || this.LowHop.getValue()) {
                time2.reset();
            }
        }
    }

    @EventTarget
    public void onSafe(EventSafeWalk e){
        if(this.AACOnground.getValue()) {
            boolean safewalk = true;
            for (int i = 0; i < 4; ++i) {
                if (mc.theWorld.getBlockState(new BlockPos(mc.thePlayer.posX, mc.thePlayer.posY - 1 - i, mc.thePlayer.posZ)).getBlock() != Blocks.air) {
                    safewalk = false;
                }
            }
            e.setShouldWalkSafely(safewalk);
        }
    }


    public void onUpdate(){


        if(this.oldNcp.getValue()) {
            float yaw = Minecraft.getMinecraft().thePlayer.rotationYaw;
            MovementInput movementInput = mc.thePlayer.movementInput;
            float strafe = movementInput.moveStrafe;
            double mx = Math.cos(Math.toRadians(yaw + 90.0F));
            double mz = Math.sin(Math.toRadians(yaw + 90.0F));

            double speed2 = 3.2;

            this.canStep = false;
            if (true) {

                if ((Minecraft.getMinecraft().thePlayer.onGround) && (this.ground < 1.0F)) {
                    this.ground += 0.2F;
                }
                if (!Minecraft.getMinecraft().thePlayer.onGround) {
                    this.ground = 0.0F;
                }
                if ((this.ground == 1.0F) && (true)) {
                    if (Minecraft.getMinecraft().thePlayer.moveStrafing != 0.0F) {
                        speed2 -= 0.05D;
                    }
                    if (Minecraft.getMinecraft().thePlayer.isInWater()) {
                        speed2 -= 0.05D;
                    }
                    this.motionDelay += 1;
                    if (this.motionDelay == 1) {


                        EntityPlayerSP thePlayer16 = Minecraft.getMinecraft().thePlayer;
                        thePlayer16.motionX *= speed2;
                        EntityPlayerSP thePlayer17 = Minecraft.getMinecraft().thePlayer;
                        thePlayer17.motionZ *= speed2;
                        this.canStep = false;
                    } else if (this.motionDelay == 2) {

                        mc.timer.timerSpeed = 1.3F;
                        EntityPlayerSP thePlayer18 = Minecraft.getMinecraft().thePlayer;
                        thePlayer18.motionX /= 1.508D;
                        EntityPlayerSP thePlayer19 = Minecraft.getMinecraft().thePlayer;
                        thePlayer19.motionZ /= 1.508D;
                        this.canStep = true;
                    } else if (this.motionDelay == 3) {
                        mc.timer.timerSpeed = 1.1f;
                        EntityPlayerSP thePlayer16 = Minecraft.getMinecraft().thePlayer;
                        thePlayer16.motionX *= 1.02;
                        EntityPlayerSP thePlayer17 = Minecraft.getMinecraft().thePlayer;
                        thePlayer17.motionZ *= 1.02;
                        this.canStep = false;

                    } else if (this.motionDelay >= 4) {
                        mc.timer.timerSpeed = 1f;
                        EntityPlayerSP thePlayer16 = Minecraft.getMinecraft().thePlayer;
                        thePlayer16.motionX *= 1.0005;
                        EntityPlayerSP thePlayer17 = Minecraft.getMinecraft().thePlayer;
                        thePlayer17.motionZ *= 1.0005;
                        this.motionDelay = 0;
                    }
                }
            } else if (this.motionDelay == 1) {
                this.canStep = true;
                mc.timer.timerSpeed = 1.3F;
                EntityPlayerSP thePlayer20 = Minecraft.getMinecraft().thePlayer;
                thePlayer20.motionX /= 1.758D;
                EntityPlayerSP thePlayer21 = Minecraft.getMinecraft().thePlayer;
                thePlayer21.motionZ /= 1.758D;
                this.motionDelay = 0;
                return;
            }

            //  mc.gameSettings.keyBindForward.pressed = true;


        }
        if (AACBhop.getValue()) {
            if (this.isMoving(mc.thePlayer)) {
             if(mc.thePlayer.onGround){
                 mc.thePlayer.jump();
                 mc.thePlayer.motionY = 0.385;
                 mc.thePlayer.addSpeed(0.005);
             }else{
                 mc.thePlayer.addSpeed(0.002);
                 if(mc.thePlayer.motionY < 0){
                     mc.thePlayer.motionY -=0.013;

                 }else{
               //      mc.thePlayer.motionY -=0.007;
                 }
             }
            }
        }
        if(this.yPortlatest.getValue()){
            if(mc.thePlayer.onGround){
                mc.thePlayer.jump();
                mc.thePlayer.setSpeed(mc.thePlayer.getSpeed() / 1.59);
            }else{
               mc.thePlayer.motionY = -0.42;
                mc.thePlayer.setSpeed(mc.thePlayer.getSpeed() * 1.25);
            }
        }
        if(AACOnground.getValue()) {
            if (speed > 0.65 && mc.thePlayer.onGround) {
                cancel = false;
            }
            if (airTicks > 17) {
                speed = 0.3;
                cancel = true;
                airTicks = 0;
            }
            if (this.cancel) {

                if (mc.thePlayer.onGround) {
                    this.shouldreset = true;
                    mc.thePlayer.jump();
                    mc.thePlayer.motionY = 0.42;
                } else {
                    if (!mc.thePlayer.onGround) {
                        if (this.shouldreset) {
                            //this.airTicks = 0;
                            mc.thePlayer.motionX *= -1.2;
                            mc.thePlayer.motionZ *= -1.2;
                            this.shouldreset = false;
                        } else {
                            mc.thePlayer.motionX *= (1.06);
                            mc.thePlayer.motionZ *= (1.06);
                            //      mc.thePlayer.motionY -= 0.013;
                        }
                    }
                }
                if (mc.thePlayer.getSpeed() > speed) {
                    speed = mc.thePlayer.getSpeed();
                }
            } else {


                mc.thePlayer.setSpeed(speed + airTicks / 10 > 0.9 ? 0.9 : speed + airTicks / 10 );
                ++this.airTicks;
                if(airTicks > 17){
                 //   speed /= 2;
                }else{
                    speed = 0.8;
                }

            }
        }







       // Main.getMain.cmdManager.sendChatMessage(this.airTicks+"");
        if(this.AACVeloity.getValue()) {
            if (mc.thePlayer.onGround) {
                this.shouldreset = true;
                mc.thePlayer.jump();
                mc.thePlayer.motionY = 0.4;
                mc.thePlayer.setSpeed(mc.thePlayer.getSpeed());
            } else {
                if (!mc.thePlayer.onGround) {
                    if (this.shouldreset ) {
                        this.airTicks = 0;
                        mc.thePlayer.motionX *= -1.2;
                        mc.thePlayer.motionZ *= -1.2;
                        this.shouldreset = false;
                    }else{
                        mc.thePlayer.motionX *= (1.075);
                        mc.thePlayer.motionZ *= (1.075);
                        mc.thePlayer.motionY -= 0.013;
                    }
                }
            }
        }

        if(this.AACSkipHop.getValue()) {
            mc.thePlayer.motionY -= 0.013;

            int jumpticks = 5;
            if (ticks == jumpticks) {
                mc.thePlayer.setSpeed(0.1);
            }
            if (ticks <= 0) {
                if (mc.thePlayer.onGround) {
                    mc.thePlayer.setSpeed(5.2);
                    ticks = jumpticks;
                }
            } else {

                if (mc.thePlayer.onGround) {
                    ticks--;
                    mc.thePlayer.jump();


                }
            }
        }
        if(this.AACLowhop.getValue()) {
            if (mc.thePlayer.moveForward != 0 || mc.thePlayer.moveStrafing != 0) {
                if (mc.thePlayer.onGround) {
                    ticks++;
                    if (ticks >= 3) {
                        mc.thePlayer.setSpeed(0.358f);
                        mc.thePlayer.jump();
                        mc.thePlayer.motionY = 0.101f;
                        ticks = 0;
                    } else {
                        mc.thePlayer.jump();
                        mc.thePlayer.motionY = 0.386f;
                        mc.thePlayer.jumpMovementFactor *= mc.thePlayer.fallDistance;
                        mc.thePlayer.setSpeed((float) Math.sqrt(mc.thePlayer.motionX * mc.thePlayer.motionX
                                + mc.thePlayer.motionZ * mc.thePlayer.motionZ)
                                * ((mc.thePlayer.fallDistance >= 0.0) ? 1.014f : 1.0f));
                    }
                }else{
                    mc.thePlayer.motionY -=0.013;
                }
            } else {
                ticks = 2;
            }
        }

    }

    public boolean isMoving(EntityPlayer p){
        return mc.gameSettings.keyBindForward.pressed || mc.gameSettings.keyBindBack.pressed  || mc.gameSettings.keyBindLeft.pressed  || mc.gameSettings.keyBindRight.pressed ;
    }

    private double getBaseMoveSpeed() {
        double baseSpeed = 0.2873D;
        if (this.mc.thePlayer.isPotionActive(Potion.moveSpeed)) {
            int amplifier = this.mc.thePlayer.getActivePotionEffect(
                    Potion.moveSpeed).getAmplifier();
            baseSpeed *= (1.0D + 0.2D * (amplifier + 1));
        }
        return baseSpeed;
    }

    public static double round(double value, int places)
    {
        if (places < 0) {
            throw new IllegalArgumentException();
        }
        BigDecimal bd = new BigDecimal(value);
        bd = bd.setScale(places, RoundingMode.HALF_UP);
        return bd.doubleValue();
    }

    public static double roundToPlace(double value, int places) { if (places < 0) {
        throw new IllegalArgumentException();
    }
        BigDecimal bd = new BigDecimal(value);
        bd = bd.setScale(places, java.math.RoundingMode.HALF_UP);
        return bd.doubleValue();
    }
    public void setMoveSpeed(MoveEvent event, double speed) {
        double forward = mc.thePlayer.moveForward;
        double strafe = mc.thePlayer.moveStrafing;
        float yaw = mc.thePlayer.rotationYaw;
        if ((forward == 0.0D) && (strafe == 0.0D)) {
            event.setX(0.0D);
            event.setZ(0.0D);
        }
        else {
            if (forward != 0.0D) {
                if (strafe > 0.0D) {
                    yaw += (forward > 0.0D ? -45 : 45);
                }
                else if (strafe < 0.0D) {
                    yaw += (forward > 0.0D ? 45 : -45);
                }
                strafe = 0.0D;
                if (forward > 0.0D) {
                    forward = 1.0D;
                }
                else if (forward < 0.0D) {
                    forward = -1.0D;
                }
            }
            event.setX(forward * speed * Math.cos(Math.toRadians(yaw + 90.0F)) + strafe * speed * Math.sin(Math.toRadians(yaw + 90.0F)));
            event.setZ(forward * speed * Math.sin(Math.toRadians(yaw + 90.0F)) - strafe * speed * Math.cos(Math.toRadians(yaw + 90.0F)));
        }
    }

    @EventTarget
    public void onPreMotion(MoveEvent event) {


        if(AACYport.getValue()) {
            if (mc.thePlayer.isOnLadder() || mc.thePlayer.isInWater() || mc.thePlayer.isInWeb || mc.thePlayer.isCollidedHorizontally) {
                return;
            }
            if (mc.gameSettings.keyBindLeft.pressed || mc.gameSettings.keyBindRight.pressed || mc.gameSettings.keyBindForward.pressed || mc.gameSettings.keyBindBack.pressed) {
                if (mc.thePlayer.onGround) {
                    this.shouldreset = true;
                    float var1 = mc.thePlayer.rotationYaw * 0.017453292F;
                    event.x -= (double) (MathHelper.sin(var1) * 0.2F);
                    event.z += (double) (MathHelper.cos(var1) * 0.2F);

                    mc.thePlayer.motionX = event.x;
                    mc.thePlayer.motionZ = event.z;
                    event.y = 0.42;
                    speed++;
                    if (speed > 3) {
                        event.x *= 1.01;
                        event.z *= 1.01;
                        mc.timer.timerSpeed = 1f;
                    }
                    //     (()) mc.thePlayer.motionX

                } else {
                    mc.timer.timerSpeed = 1f;
                    if (speed > 3) {
                        event.x *= 1.025;
                        event.z *= 1.025;
                    }
                    if (this.shouldreset) {
                        event.y = mc.thePlayer.motionY = -0.21;
                        shouldreset = false;
                        //  event.x *= -1;
                        // event.z *= -1;
                    } else {
                        mc.thePlayer.motionY -= 0.013;
                    }
                }
            } else {
                speed = 0;
            }
        }
        if(this.Bhoplatest.getValue()){
            if(mc.thePlayer.onGround && ((mc.thePlayer.moveForward != 0.0F) || (mc.thePlayer.moveStrafing != 0.0F))){
                mc.timer.timerSpeed = 1.5f;
            }else{
                mc.timer.timerSpeed = 1;
            }
            if (roundToPlace(mc.thePlayer.posY - (int)mc.thePlayer.posY, 3) == roundToPlace(0.4D, 3)) {
                event.setY(mc.thePlayer.motionY = 0.31D);
            }
            else if (roundToPlace(mc.thePlayer.posY - (int)mc.thePlayer.posY, 3) == roundToPlace(0.71D, 3)) {
                event.setY(mc.thePlayer.motionY = 0.05);
            }
            else if (roundToPlace(mc.thePlayer.posY - (int)mc.thePlayer.posY, 3) == roundToPlace(0.75D, 3)) {
                event.setY(mc.thePlayer.motionY = -0.5D);
            }
            else if (roundToPlace(mc.thePlayer.posY - (int)mc.thePlayer.posY, 3) == roundToPlace(0.55D, 3)) {
                event.setY(mc.thePlayer.motionY = -0.2D);
            }
            else if (roundToPlace(mc.thePlayer.posY - (int)mc.thePlayer.posY, 3) == roundToPlace(0.41D, 3)) {
                event.setY(mc.thePlayer.motionY = -0.2D);
            }
            if ((ticks == 1) && ((mc.thePlayer.moveForward != 0.0F) || (mc.thePlayer.moveStrafing != 0.0F))) {
                moveSpeed = (2D * getBaseMoveSpeed() - 0.01D);
            }
            else if ((ticks == 2 ) && ((mc.thePlayer.moveForward != 0.0F) || (mc.thePlayer.moveStrafing != 0.0F)) ) {
                event.setY(mc.thePlayer.motionY = 0.4D);
                moveSpeed *=mc.thePlayer.hurtResistantTime <= 3 ?  1.47D : 2.1;
            }
            else if (ticks == 3) {
                double difference = 0.66D * (lastDist - getBaseMoveSpeed());
                moveSpeed = (lastDist - difference);
            }
            else {
               // List collidingList = ClientUtils.world().getCollidingBlockBoundingBoxes(ClientUtils.player(), playerboundingBox.offset(0.0D, mc.thePlayer.motionY, 0.0D));
                if ((mc.thePlayer.isCollidedVertically) && (ticks > 0)) {
                    ticks = (mc.thePlayer.moveForward != 0.0F) || (mc.thePlayer.moveStrafing != 0.0F) ? 1 : 0;
                }
                moveSpeed = (lastDist - lastDist / 200.0D);
            }
            setMoveSpeed(event, moveSpeed = Math.max(moveSpeed,getBaseMoveSpeed()));
            if ((mc.thePlayer.moveForward != 0.0F) || (mc.thePlayer.moveStrafing != 0.0F)) {
                ticks += 1;
            }
        }



        if (this.Bhop.getValue() || this.yPort1.getValue() || this.LowHop2.getValue() || this.LowHop.getValue()) {
            if (time2.hasReached(40)) {
                if (mc.thePlayer.fallDistance > 5) {

                    return;
                }
                if (this.yPort1.getValue()) {
                    this.moveSpeed *= 1.0002;
                }

                if (this.LowHop2.getValue() && mc.thePlayer.fallDistance < 0.2 && !mc.gameSettings.keyBindJump.pressed) {
                    mc.thePlayer.motionY /= 2.12f;
                    mc.timer.timerSpeed = 0.9f;
                }


                this.speedTick = (!this.speedTick);
                this.timerDelay += 1;
                this.timerDelay %= 5;
                if (this.timerDelay != 0) {
                    mc.timer.timerSpeed = 1.0F;
                } else {
                    if (isMoving(mc.thePlayer)) {
                        if (!this.LowHop.getValue()) {
                            if (!this.LowHop2.getValue()) {
                                //	net.minecraft.util.Timer.timerSpeed = 32767.0F;
                            }
                        }
                    }
                    if (isMoving(mc.thePlayer)) {
                        if (!this.LowHop.getValue()) {
                            if (!this.LowHop2.getValue()) {
                                //	net.minecraft.util.Timer.timerSpeed = this.speedTimer;
                            }
                        }
                        mc.thePlayer.motionX *= 1.0199999809265137D;
                        mc.thePlayer.motionZ *= 1.0199999809265137D;
                    }
                }
                if (mc.thePlayer.onGround) {
                    if (isMoving(mc.thePlayer)) {
                        this.level = 2;
                    }
                }


                if ((this.level == 1)
                        && ((mc.thePlayer.moveForward != 0.0F) || (mc.thePlayer.moveStrafing != 0.0F))) {
                    this.level = 2;
                    this.moveSpeed = (1.35D * getBaseMoveSpeed() - 0.01D);
                } else if (this.level == 2) {
                    this.level = 3;
                    if (this.Bhop.getValue() || this.yPort1.getValue()) {
                        if (time.hasReached(200)) {
                            event.y = 0.399399995803833D;
                            mc.thePlayer.motionY = 0.399399995803833D;
                        } else {
                            return;
                        }
                    }
                    if (this.LowHop.getValue() && !this.yPort1.getValue()) {
                        event.y = 0.399399995803833D;
                    }
                    if (this.LowHop2.getValue() && !this.yPort1.getValue()) {
                        event.y = 0.4;
                    }
                    if (!this.LowHop2.getValue() || this.yPort1.getValue()) {
                        this.moveSpeed *= 2.149D;
                    } else {
                        this.moveSpeed *= 1.849D;
                    }
                } else if (this.level == 3) {
                    this.level = 4;
                    double difference = 0.66D * (this.lastDist - getBaseMoveSpeed());
                    if (!this.yPort1.getValue()) {
                        this.moveSpeed = (this.lastDist - difference);
                    } else {
                        this.moveSpeed = (this.lastDist - difference) + 0.000000001;
                    }
                } else {
                    // if
                    //((mc.theWorld.getCollidingBoundingBoxes(mc.thePlayer,
                    //mc.thePlayer.boundingBox.offset(0.0D,
                    //mc.thePlayer.motionY, 0.0D)).size() > 0) ||
                    //(mc.thePlayer.isCollidedVertically)) {
                    //this.level = 1;
                    //	 }
                    this.moveSpeed = (this.lastDist - this.lastDist / 159.0D);
                }
                this.moveSpeed = Math.max(this.moveSpeed, getBaseMoveSpeed());
                MovementInput movementInput = mc.thePlayer.movementInput;
                float forward = movementInput.moveForward;
                float strafe = movementInput.moveStrafe;
                float yaw = Minecraft.getMinecraft().thePlayer.rotationYaw;
                if ((forward == 0.0F) && (strafe == 0.0F)) {
                    event.x = 0.0D;
                    event.z = 0.0D;
                } else if (forward != 0.0F) {
                    if (strafe >= 1.0F) {
                        yaw += (forward > 0.0F ? -45 : 45);
                        strafe = 0.0F;
                    } else if (strafe <= -1.0F) {
                        yaw += (forward > 0.0F ? 45 : -45);
                        strafe = 0.0F;
                    }
                    if (forward > 0.0F) {
                        forward = 1.0F;
                    } else if (forward < 0.0F) {
                        forward = -1.0F;
                    }
                }
                double mx = Math.cos(Math.toRadians(yaw + 90.0F));
                double mz = Math.sin(Math.toRadians(yaw + 90.0F));
                double motionX = forward * this.moveSpeed * mx + strafe
                        * this.moveSpeed * mz;
                double motionZ = forward * this.moveSpeed * mz - strafe
                        * this.moveSpeed * mx;
                event.x = (forward * this.moveSpeed * mx + strafe * this.moveSpeed
                        * mz);
                event.z = (forward * this.moveSpeed * mz - strafe * this.moveSpeed
                        * mx);
                canStep = true;
                mc.thePlayer.stepHeight = 0.6F;
                if ((forward == 0.0F) && (strafe == 0.0F)) {
                    event.x = 0.0D;
                    event.z = 0.0D;
                } else {
                    boolean collideCheck = false;
                    if
                            (Minecraft.getMinecraft().theWorld.getCollidingBoundingBoxes(mc.thePlayer,
                            mc.thePlayer.boundingBox.expand(0.5D, 0.0D,
                                    0.5D)).size() > 0 && this.LowHop2.getValue()) {
                        collideCheck = true;
                    }
                    if (forward != 0.0F) {
                        if (strafe >= 1.0F) {
                            yaw += (forward > 0.0F ? -45 : 45);
                            strafe = 0.0F;
                        } else if (strafe <= -1.0F) {
                            yaw += (forward > 0.0F ? 45 : -45);
                            strafe = 0.0F;
                        }
                        if (forward > 0.0F) {
                            forward = 1.0F;
                        } else if (forward < 0.0F) {
                            forward = -1.0F;
                        }


                    }
                }
            }

        }
    }

}

minecraft_de_Client_Main_Modules_mods_Movment_Sprint.java

package de.Client.Main.Modules.mods.Movment;

        import de.Client.Events.EventTarget;
        import de.Client.Events.Events.PacketReceiveEvent;
        import de.Client.Main.Main;
        import de.Client.Main.Modules.Category;
        import de.Client.Main.Modules.Module;
        import de.Client.Utils.Macro;
        import net.minecraft.client.entity.EntityPlayerSP;
        import net.minecraft.client.network.NetworkPlayerInfo;
        import net.minecraft.entity.Entity;
        import net.minecraft.entity.player.EntityPlayer;
        import net.minecraft.network.play.client.C02PacketUseEntity;
        import net.minecraft.network.play.client.C03PacketPlayer;
        import net.minecraft.network.play.server.S0CPacketSpawnPlayer;
        import net.minecraft.network.play.server.S18PacketEntityTeleport;
        import org.lwjgl.Sys;
        import org.lwjgl.input.Controller;
        import org.lwjgl.input.Controllers;
        import org.lwjgl.input.Keyboard;

        import java.util.ArrayList;



public class Sprint extends Module {

    public Sprint() {
        super("Sprint", Category.MOVEMENT, Keyboard.KEY_Y);
        // TODO Auto-generated constructor stub
}

    @Override
    public void onUpdate(){
        if(mc.thePlayer.onGround && !mc.thePlayer.isSprinting() && (mc.gameSettings.keyBindForward.pressed || mc.gameSettings.keyBindBack.pressed || mc.gameSettings.keyBindLeft.pressed || mc.gameSettings.keyBindRight.pressed)) {
            mc.thePlayer.setSprinting(true);
        }
    }

    @Override
    public boolean isModuleImportant(){
        return false;
    }


}

minecraft_de_Client_Main_Modules_mods_Movment_Step.java

package de.Client.Main.Modules.mods.Movment;

import de.Client.Events.EventTarget;
import de.Client.Events.Events.MoveEvent;
import de.Client.Main.Main;
import de.Client.Main.Modules.Category;
import de.Client.Main.Modules.Module;
import de.Client.Main.Values.ValueBoolean;
import de.Client.Utils.Macro;
import net.minecraft.client.Minecraft;
import net.minecraft.entity.Entity;
import net.minecraft.init.Blocks;
import net.minecraft.network.play.client.C03PacketPlayer;
import net.minecraft.util.BlockPos;
import org.lwjgl.input.Controller;
import org.lwjgl.input.Controllers;
import org.lwjgl.input.Keyboard;

import java.awt.*;

public class Step extends Module {

    public Step() {
        super("Step", Category.MOVEMENT, 0);
        // TODO Auto-generated constructor stub

    }
    public ValueBoolean AAC = new ValueBoolean("AACOld",false);
    public ValueBoolean AACNew = new ValueBoolean("AACNew",false);
    public int stepTicks;
    @EventTarget
    public void onMove(MoveEvent moveEvent) {
        if(AAC.getValue()) {
            if (mc.thePlayer.isInWater() || mc.thePlayer.isOnLadder()) {
                return;
            }
            if (mc.thePlayer.onGround) {
                if (stepTicks > 0) {
                    stepTicks = 0;
                    mc.thePlayer.setSpeed(0);
                }
            }
            mc.thePlayer.stepHeight = 0.9f;
            double blocks = 0.5 + mc.thePlayer.getSpeed();
            double x = Math.cos(Math.toRadians(mc.thePlayer.rotationYaw + 90.0F));
            double z = Math.sin(Math.toRadians(mc.thePlayer.rotationYaw + 90.0F));
            double y = mc.thePlayer.posY;
            BlockPos pos = new BlockPos(mc.thePlayer.posX + (1.0D * blocks * x + 0.0D * blocks * z), mc.thePlayer.posY, mc.thePlayer.posZ + (1.0D * blocks * z - 0.0D * blocks * x));
            double diffrent = mc.theWorld.getBlockState(pos).getBlock().getCollisionBoundingBox(mc.theWorld, pos, mc.theWorld.getBlockState(pos)).maxY - mc.thePlayer.posY;
            BlockPos pos2 = new BlockPos(mc.thePlayer.posX + (1.0D * blocks * x + 0.0D * blocks * z), mc.thePlayer.posY + 1, mc.thePlayer.posZ + (1.0D * blocks * z - 0.0D * blocks * x));
            double diffrent2 = 0;
            if (mc.theWorld.getBlockState(pos2).getBlock() != Blocks.air) {
                diffrent2 = mc.theWorld.getBlockState(pos2).getBlock().getCollisionBoundingBox(mc.theWorld, pos2, mc.theWorld.getBlockState(pos)).maxY - mc.thePlayer.posY - 1;
            }


            if (diffrent2 > 0.1) {
                return;
            }
            if (mc.thePlayer.onGround) {

                if (diffrent > 0.5) {
                    moveEvent.y = 0.42;
                    if (diffrent > 0) {
                        //        mc.thePlayer.motionY = 0.42;
                        //      stepTicks = 55;
                    }
                }
            }
            if (diffrent > 0.5) {
                mc.thePlayer.motionY += 0.015;
                mc.thePlayer.onGround = true;
                double blocks2 = 1;
                stepTicks++;
                //  mc.thePlayer.sendQueue.addToSendQueue(new C03PacketPlayer.C04PacketPlayerPosition(mc.thePlayer.posX + (1.0D * blocks * x + 0.0D * blocks * z), mc.thePlayer.posY, mc.thePlayer.posZ + (1.0D * blocks * z - 0.0D * blocks * x),false));
                //    mc.thePlayer.sendQueue.addToSendQueue(new C03PacketPlayer.C04PacketPlayerPosition(mc.thePlayer.posX + (1.0D * -blocks * x + 0.0D * -blocks * z), mc.thePlayer.posY, mc.thePlayer.posZ + (1.0D * -blocks * z - 0.0D * -blocks * x),false));
                // mc.thePlayer.setPosition(mc.thePlayer.posX + (1.0D * blocks2 * x + 0.0D * blocks2 * z), mc.thePlayer.posY+0., mc.thePlayer.posZ + (1.0D * blocks2 * z - 0.0D * blocks2 * x));
                mc.thePlayer.setSpeed(0.3);
                mc.thePlayer.jump();
            }
        }
        if(AACNew.getValue() ) {
            if (mc.thePlayer.isInWater() || mc.thePlayer.isOnLadder()) {
                return;
            }

            if (mc.thePlayer.onGround) {
                if (stepTicks > 0) {
                    stepTicks = 0;
                    mc.thePlayer.setSpeed(0);
                }
            }
         //   mc.thePlayer.stepHeight = 0.9f;
            double blocks = 2 + mc.thePlayer.getSpeed();
            double x = Math.cos(Math.toRadians(mc.thePlayer.rotationYaw + 90.0F));
            double z = Math.sin(Math.toRadians(mc.thePlayer.rotationYaw + 90.0F));
            double y = mc.thePlayer.posY;
            BlockPos pos = new BlockPos(mc.thePlayer.posX + (1.0D * blocks * x + 0.0D * blocks * z), mc.thePlayer.posY, mc.thePlayer.posZ + (1.0D * blocks * z - 0.0D * blocks * x));
            double diffrent = mc.theWorld.getBlockState(pos).getBlock().getCollisionBoundingBox(mc.theWorld, pos, mc.theWorld.getBlockState(pos)).maxY - mc.thePlayer.posY;
            BlockPos pos2 = new BlockPos(mc.thePlayer.posX + (1.0D * blocks * x + 0.0D * blocks * z), mc.thePlayer.posY + 1, mc.thePlayer.posZ + (1.0D * blocks * z - 0.0D * blocks * x));
            double diffrent2 = 0;
            if (mc.theWorld.getBlockState(pos2).getBlock() != Blocks.air) {
                diffrent2 = mc.theWorld.getBlockState(pos2).getBlock().getCollisionBoundingBox(mc.theWorld, pos2, mc.theWorld.getBlockState(pos)).maxY - mc.thePlayer.posY - 1;
            }


            if (diffrent2 > 0.5) {
                return;
            }
            if (mc.thePlayer.onGround) {
                mc.thePlayer.stepHeight = 0.5f;
                if (diffrent > 0.5) {
                    moveEvent.y = 0.42;
                    mc.thePlayer.jump();
                    if (diffrent > 0) {
                        //        mc.thePlayer.motionY = 0.42;
                        //      stepTicks = 55;
                    }
                }
            }else{
                moveEvent.y += 0.013;

            }
            stepTicks --;
            if(stepTicks > 0){
                mc.thePlayer.setSpeed(0.4);
            }


                double blocks2 = 1;
                stepTicks++;
                //  mc.thePlayer.sendQueue.addToSendQueue(new C03PacketPlayer.C04PacketPlayerPosition(mc.thePlayer.posX + (1.0D * blocks * x + 0.0D * blocks * z), mc.thePlayer.posY, mc.thePlayer.posZ + (1.0D * blocks * z - 0.0D * blocks * x),false));
                //    mc.thePlayer.sendQueue.addToSendQueue(new C03PacketPlayer.C04PacketPlayerPosition(mc.thePlayer.posX + (1.0D * -blocks * x + 0.0D * -blocks * z), mc.thePlayer.posY, mc.thePlayer.posZ + (1.0D * -blocks * z - 0.0D * -blocks * x),false));
                // mc.thePlayer.setPosition(mc.thePlayer.posX + (1.0D * blocks2 * x + 0.0D * blocks2 * z), mc.thePlayer.posY+0., mc.thePlayer.posZ + (1.0D * blocks2 * z - 0.0D * blocks2 * x));
                mc.thePlayer.setSpeed(0.3);
                this.stepTicks = 20;




        }



    }
}

minecraft_de_Client_Main_Modules_mods_Player_AutoArmor.java

/*/
package de.Client.Main.Modules.mods.Player;

import de.Client.Main.Main;
import de.Client.Main.Modules.Category;
import de.Client.Main.Modules.Module;
import de.Client.Main.Values.ValueBoolean;
import de.Client.Render.ClickGui.Panels.Mini;
import de.Client.Render.ClickGui.Panels.Minitypes.MiniValueBooleanToggleSimple;
import de.Client.Utils.TimeHelper;
import java.util.ArrayList;
import net.minecraft.client.Minecraft;
import net.minecraft.client.entity.EntityPlayerSP;
import net.minecraft.client.gui.inventory.GuiInventory;
import net.minecraft.client.multiplayer.PlayerControllerMP;
import net.minecraft.enchantment.Enchantment;
import net.minecraft.enchantment.EnchantmentHelper;
import net.minecraft.entity.player.InventoryPlayer;
import net.minecraft.inventory.Container;
import net.minecraft.inventory.Slot;
import net.minecraft.item.Item;
import net.minecraft.item.ItemArmor;
import net.minecraft.item.ItemStack;

public class AutoArmor
        extends Module
{
    public AutoArmor()
    {
        super("AutoArmor", Category.PLAYER, 0);
        addValue(openInv);
    }

    public static ValueBoolean openInv = new ValueBoolean("Inventory", false);
    public static ValueBoolean nyra = new ValueBoolean("nyra", false);
    private TimeHelper time = new TimeHelper();
    private final int[] boots = { 313, 309, 317, 305, 301 };
    private final int[] chestplate = { 311, 307, 315, 303, 299 };
    private final int[] helmet = { 310, 306, 314, 302, 298 };
    private final int[] leggings = { 312, 308, 316, 304, 300 };

    public ArrayList<Mini> createArray()
    {
        ArrayList<Mini> minis = new ArrayList();
        minis.add(new MiniValueBooleanToggleSimple(this, openInv));
        return minis;
    }

    public void onUpdate()
    {
        if (!this.time.hasReached(125L)) {
            return;
        }
        if ((!(this.mc.currentScreen instanceof GuiInventory)) && (openInv.getValue())) {
            return;
        }
        int item = -1;
        for(int i = 0; i < 4; ++i){
            if(Minecraft.getMinecraft().thePlayer.inventory.armorInventory[i] == null){
                item = this.findBestArmor(i);
               Main.getMain.cmdManager.sendChatMessage(i + "    "  + i);
            }
        }
        boolean hasInvSpace = false;
        ItemStack[] arritemStack = this.mc.thePlayer.inventory.mainInventory;
        int n3 = arritemStack.length;
        int n2 = 0;
        while (n2 < n3)
        {
            ItemStack stack = arritemStack[n2];
            if (stack == null)
            {
                hasInvSpace = true;
                break;
            }
            n2++;
        }
        if (item != -1)
        {
            this.mc.playerController.windowClick(0, item, 0, 1, this.mc.thePlayer);

            this.time.reset();
        }
    }

    public int findBestArmor(int item){
        System.out.println(item);
        ArrayList<ItemStack> bestItems;
        double bestDamageReduceAmount = -1;
        ItemStack s =null;
        for(ItemStack stack : mc.thePlayer.inventory.mainInventory){
            if(stack != null) {
                if (stack.getItem() instanceof ItemArmor) {
                    ItemArmor armor = (ItemArmor) stack.getItem();
                    if (armor.armorType == item) {
                        if (armor.damageReduceAmount > bestDamageReduceAmount) {

                            double protectionLevel =  EnchantmentHelper.getEnchantmentLevel(Enchantment.field_180310_c.effectId, stack);
                            bestDamageReduceAmount = armor.damageReduceAmount + protectionLevel / 10.0d;
                            System.out.println(bestDamageReduceAmount + " re"+  protectionLevel);
                            s = stack;
                        }
                    }
                }
            }
        }
        return findItem(s);
    }


    private int findItem(ItemStack id)
    {
        int index = 9;
        while (index < 45)
        {
            ItemStack item = this.mc.thePlayer.inventoryContainer.getSlot(index).getStack();
            if ((item != null) && item == id) {
                return index;
            }
            index++;
        }
        return -1;
    }
    private int findItem(int id)
    {
        int index = 9;
        while (index < 45)
        {
            ItemStack item = this.mc.thePlayer.inventoryContainer.getSlot(index).getStack();
            if ((item != null) && (Item.getIdFromItem(item.getItem()) == id)) {
                return index;
            }
            index++;
        }
        return -1;
    }
}
/*/
package de.Client.Main.Modules.mods.Player;

import de.Client.Main.Modules.Category;
import de.Client.Main.Modules.Module;
import de.Client.Main.Values.ValueBoolean;
import de.Client.Render.ClickGui.Panels.Mini;
import de.Client.Render.ClickGui.Panels.Minitypes.MiniValueBooleanToggleSimple;
import de.Client.Utils.TimeHelper;
import java.util.ArrayList;
import net.minecraft.client.Minecraft;
import net.minecraft.client.entity.EntityPlayerSP;
import net.minecraft.client.gui.inventory.GuiInventory;
import net.minecraft.client.multiplayer.PlayerControllerMP;
import net.minecraft.entity.player.InventoryPlayer;
import net.minecraft.inventory.Container;
import net.minecraft.inventory.Slot;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;

public class AutoArmor
        extends Module
{
    public AutoArmor()
    {
        super("AutoArmor", Category.PLAYER, 0);
        addValue(openInv);
    }

    public static ValueBoolean openInv = new ValueBoolean("Inventory", false);
    public static ValueBoolean nyra = new ValueBoolean("nyra", false);
    private TimeHelper time = new TimeHelper();
    private final int[] boots = { 313, 309, 317, 305, 301 };
    private final int[] chestplate = { 311, 307, 315, 303, 299 };
    private final int[] helmet = { 310, 306, 314, 302, 298 };
    private final int[] leggings = { 312, 308, 316, 304, 300 };

    public ArrayList<Mini> createArray()
    {
        ArrayList<Mini> minis = new ArrayList();
        minis.add(new MiniValueBooleanToggleSimple(this, openInv));
        return minis;
    }

    public void onUpdate()
    {
        if (!getState()) {
            return;
        }
        if (!this.time.hasReached(125L)) {
            return;
        }
        if ((!(this.mc.currentScreen instanceof GuiInventory)) && (openInv.getValue())) {
            return;
        }
        boolean dropkek = false;
        int item = -1;
        if (this.mc.thePlayer.inventory.armorInventory[0] == null)
        {
            int[] arrn = this.boots;
            int n2 = arrn.length;
            int n = 0;
            while (n < n2)
            {
                int id = arrn[n];
                if (findItem(id) != -1)
                {
                    item = findItem(id);
                    break;
                }
                n++;
            }
        }
        if (armourIsBetter(0, this.boots))
        {
            item = 8;
            dropkek = true;
        }
        if (this.mc.thePlayer.inventory.armorInventory[3] == null)
        {
            int[] arrn = this.helmet;
            int n2 = arrn.length;
            int n = 0;
            while (n < n2)
            {
                int id = arrn[n];
                if (findItem(id) != -1)
                {
                    item = findItem(id);
                    break;
                }
                n++;
            }
        }
        if (armourIsBetter(3, this.helmet))
        {
            item = 5;
            dropkek = true;
        }
        if (this.mc.thePlayer.inventory.armorInventory[1] == null)
        {
            int[] arrn = this.leggings;
            int n2 = arrn.length;
            int n = 0;
            while (n < n2)
            {
                int id = arrn[n];
                if (findItem(id) != -1)
                {
                    item = findItem(id);
                    break;
                }
                n++;
            }
        }
        if (armourIsBetter(1, this.leggings))
        {
            item = 7;
            dropkek = true;
        }
        if (this.mc.thePlayer.inventory.armorInventory[2] == null)
        {
            int[] arrn = this.chestplate;
            int n2 = arrn.length;
            int n = 0;
            while (n < n2)
            {
                int id = arrn[n];
                if (findItem(id) != -1)
                {
                    item = findItem(id);
                    break;
                }
                n++;
            }
        }
        if (armourIsBetter(2, this.chestplate))
        {
            item = 6;
            dropkek = true;
        }
        boolean hasInvSpace = false;
        ItemStack[] arritemStack = this.mc.thePlayer.inventory.mainInventory;
        int n3 = arritemStack.length;
        int n2 = 0;
        while (n2 < n3)
        {
            ItemStack stack = arritemStack[n2];
            if (stack == null)
            {
                hasInvSpace = true;
                break;
            }
            n2++;
        }
        dropkek = (dropkek) && (!hasInvSpace);
        boolean bl = dropkek;
        if (item != -1)
        {
            this.mc.playerController.windowClick(0, item, 0, 1, this.mc.thePlayer);

            this.time.reset();
        }
    }

    public boolean armourIsBetter(int slot, int[] armourtype)
    {
        if (this.mc.thePlayer.inventory.armorInventory[slot] != null)
        {
            int currentIndex = 0;
            int finalCurrentIndex = -1;
            int invIndex = 0;
            int finalInvIndex = -1;
            int[] arrn = armourtype;
            int n = arrn.length;
            int n2 = 0;
            while (n2 < n)
            {
                int armour2 = arrn[n2];
                if (Item.getIdFromItem(this.mc.thePlayer.inventory.armorInventory[slot].getItem()) == armour2)
                {
                    finalCurrentIndex = currentIndex;
                    break;
                }
                currentIndex++;
                n2++;
            }
            arrn = armourtype;
            n = arrn.length;
            n2 = 0;
            while (n2 < n)
            {
                int armour2 = arrn[n2];
                if (findItem(armour2) != -1)
                {
                    finalInvIndex = invIndex;
                    break;
                }
                invIndex++;
                n2++;
            }
            if (finalInvIndex > -1) {
                return finalInvIndex < finalCurrentIndex;
            }
        }
        return false;
    }

    private int findItem(int id)
    {
        int index = 9;
        while (index < 45)
        {
            ItemStack item = this.mc.thePlayer.inventoryContainer.getSlot(index).getStack();
            if ((item != null) && (Item.getIdFromItem(item.getItem()) == id)) {
                return index;
            }
            index++;
        }
        return -1;
    }
}

minecraft_de_Client_Main_Modules_mods_Player_Autotool.java

package de.Client.Main.Modules.mods.Player;

import com.google.common.collect.Multimap;
import de.Client.Events.EventTarget;
import de.Client.Events.Events.PacketReceiveEvent;
import de.Client.Events.Events.PacketSendEvent;
import de.Client.Events.Events.UpdateEvent;
import de.Client.Events.IEvent.State;
import de.Client.Main.Main;
import de.Client.Main.Modules.Category;
import de.Client.Main.Modules.Module;
import de.Client.Main.Modules.mods.Combat.KillAura;
import de.Client.Main.Modules.mods.Movment.NoSlowDown;
import de.Client.Main.Values.ValueBoolean;
import de.Client.Render.ClickGui.Panels.Mini;
import de.Client.Render.ClickGui.Panels.Minitypes.MiniValueBooleanToggleSimple;
import de.Client.Utils.TimeHelper;
import net.minecraft.block.state.IBlockState;
import net.minecraft.client.Minecraft;
import net.minecraft.entity.ai.attributes.AttributeModifier;
import net.minecraft.item.ItemStack;
import net.minecraft.item.ItemSword;
import net.minecraft.network.Packet;
import net.minecraft.network.play.client.C02PacketUseEntity;
import net.minecraft.network.play.client.C07PacketPlayerDigging;
import net.minecraft.network.play.client.C08PacketPlayerBlockPlacement;
import net.minecraft.network.play.client.C09PacketHeldItemChange;
import net.minecraft.util.BlockPos;
import net.minecraft.util.EnumFacing;
import org.lwjgl.input.Keyboard;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.Map;


public class Autotool extends Module {
    public ValueBoolean ItemSpoof = new ValueBoolean("ItemSpoof",true);
    public ValueBoolean AutoSword = new ValueBoolean("AutoSword",true);
    public Autotool() {
        super("Autotool", Category.PLAYER, Keyboard.KEY_NONE);
        // TODO Auto-generated constructor stub
        addValue(ItemSpoof);
        addValue(AutoSword);
    }

    @Override
    public ArrayList<Mini> createArray(){
        ArrayList<Mini> minis = new ArrayList<>();
        minis.add( new MiniValueBooleanToggleSimple(this,AutoSword));
        minis.add( new MiniValueBooleanToggleSimple(this,ItemSpoof));
        return minis;
    }
    public TimeHelper t = new TimeHelper();
    public boolean itemFix;
    @EventTarget
    public void onPacketSend(PacketSendEvent e) {
        if (this.getState()) {
            if (e.getPacket() instanceof C02PacketUseEntity) {
                if(this.AutoSword.getValue()) {
                    if (mc.objectMouseOver.entityHit != null) {
                        float bestDamage = 1.0F;
                        int bestSlot = -1;
                        for (int i = 0; i < 9; i++) {
                            net.minecraft.item.ItemStack item = mc.thePlayer.inventory.getStackInSlot(i);
                            if (item != null) {
                                if (this.getItemDamage(item) > bestDamage) {
                                    bestSlot = i;
                                    bestDamage = this.getItemDamage(item);
                                }
                            }
                        }
                        if (bestSlot != -1) {
                            ;

                            itemFix = true;
                        }
                        System.out.println("test" + bestSlot);
                    }
                }
            }
        }
    }
    private float getItemDamage(final ItemStack itemStack) {
        final Multimap multimap = itemStack.getAttributeModifiers();
        if(!multimap.isEmpty()) {
            final Iterator iterator = multimap.entries().iterator();
            if(iterator.hasNext()) {
                final Map.Entry entry = (Map.Entry) iterator.next();
                final AttributeModifier attributeModifier = (AttributeModifier) entry.getValue();
                double damage;
                if(attributeModifier.getOperation() != 1 && attributeModifier.getOperation() != 2) {
                    damage = attributeModifier.getAmount();
                } else {
                    damage = attributeModifier.getAmount() * 100.0;
                }
                if(attributeModifier.getAmount() > 1.0) {
                    return 1.0F + (float) damage;
                }
                return 1.0F;
            }
        }
        return 1.0F;
    }
    @EventTarget
    public void onUpdate(UpdateEvent e){
        if(e.getState() == State.POST) {

            if (mc.gameSettings.keyBindAttack.pressed && mc.objectMouseOver != null &&
                    (mc.objectMouseOver.func_178782_a() != null) &&
                    (mc.theWorld.getBlockState(mc.objectMouseOver.func_178782_a())
                            .getBlock().getMaterial() != net.minecraft.block.material.Material.air)) {
                int item = this.setSlot(mc.objectMouseOver.func_178782_a());
                if (item > -1 && item <= 9) {
                    //   mc.playerController.curBlockDamageMP += mc.thePlayer.inventory.getStackInSlot(item).getStrVsBlock( mc.theWorld.getBlockState(mc.objectMouseOver.func_178782_a()).getBlock());
                    mc.playerController.curBlockDamageMP -= mc.theWorld.getBlockState(mc.objectMouseOver.func_178782_a())
                            .getBlock().getPlayerRelativeBlockHardness(this.mc.thePlayer, this.mc.thePlayer.worldObj, mc.objectMouseOver.func_178782_a());
                    int oldItem = mc.thePlayer.inventory.currentItem;
                    mc.thePlayer.inventory.currentItem = item;
                    mc.playerController.curBlockDamageMP += mc.theWorld.getBlockState(mc.objectMouseOver.func_178782_a())
                            .getBlock().getPlayerRelativeBlockHardness(this.mc.thePlayer, this.mc.thePlayer.worldObj, mc.objectMouseOver.func_178782_a());
                    mc.thePlayer.inventory.currentItem = oldItem;
                    itemFix = true;
                }
            }
        }
        if(e.getState() == State.PRE){
            if(this.ItemSpoof.getValue()) {
                if(itemFix) {
                    mc.thePlayer.sendQueue.addToSendQueue(new C09PacketHeldItemChange(mc.thePlayer.inventory.currentItem));
                    if(Main.getMain.moduleManager.getModule(NoSlowDown.class).getState){
                        mc.getNetHandler().addToSendQueue((Packet)new C07PacketPlayerDigging(C07PacketPlayerDigging.Action.RELEASE_USE_ITEM, BlockPos.ORIGIN, EnumFacing.DOWN));
                        mc.getNetHandler().addToSendQueue((Packet)new C08PacketPlayerBlockPlacement(mc.thePlayer.getHeldItem()));

                    }
                    itemFix = false;
                }
            }else{
                if(this.itemFix){
                    if(!mc.gameSettings.keyBindAttack.pressed){
                        mc.thePlayer.sendQueue.addToSendQueue(new C09PacketHeldItemChange(mc.thePlayer.inventory.currentItem));

                        itemFix = false;
                    }
                }
            }

        }
    }

    @EventTarget
    public void onPacketReceive(PacketReceiveEvent e){
        if (mc.gameSettings.keyBindAttack.pressed &&  mc.objectMouseOver != null && e.getPacket() instanceof C09PacketHeldItemChange &&
                (mc.objectMouseOver.func_178782_a() != null) &&
                (mc.theWorld.getBlockState(mc.objectMouseOver.func_178782_a())
                        .getBlock().getMaterial() != net.minecraft.block.material.Material.air)) {
            C09PacketHeldItemChange packetHeldItemChange = (C09PacketHeldItemChange) e.getPacket();
            float bestSpeed = 1.0F;
            int bestSlot = -1;
            IBlockState blockState = mc.theWorld.getBlockState(mc.objectMouseOver.func_178782_a());
            for (int i = 0; i < 9; i++) {
                net.minecraft.item.ItemStack item = mc.thePlayer.inventory.getStackInSlot(i);
                if (item != null) {
                    float speed = item.getStrVsBlock(blockState.getBlock());
                    if (speed > bestSpeed) {
                        bestSpeed = speed;
                        bestSlot = i;
                    }
                }
            }
            if (bestSlot != -1) {
                if(packetHeldItemChange.getSlotId() != bestSlot){
                    e.setCancelled(true);
                }
            }
        }
    }



    public int setSlot(BlockPos blockPos) {
        float bestSpeed = 1.0F;
        int bestSlot = -1;
        IBlockState blockState = mc.theWorld.getBlockState(blockPos);
        for (int i = 0; i < 9; i++) {
            net.minecraft.item.ItemStack item = mc.thePlayer.inventory.getStackInSlot(i);
            if (item != null) {
                float speed = item.getStrVsBlock(blockState.getBlock());
                if (speed > bestSpeed) {
                    bestSpeed = speed;
                    bestSlot = i;
                }
            }
        }
        if (bestSlot != -1) {
            mc.thePlayer.sendQueue.addToSendQueue(new C09PacketHeldItemChange(bestSlot));
            return bestSlot;
 //           mc.thePlayer.inventory.currentItem = bestSlot;
        }
        return Integer.MAX_VALUE;
    }

    @Override
    public boolean isModuleImportant() {
        return false;
    }
}

minecraft_de_Client_Main_Modules_mods_Player_ChestAura.java

package de.Client.Main.Modules.mods.Player;

import de.Client.Main.Modules.Category;
import de.Client.Main.Modules.Module;
import de.Client.Utils.TimeHelper;
import net.minecraft.block.Block;
import net.minecraft.block.BlockChest;
import net.minecraft.client.Minecraft;
import net.minecraft.network.play.client.C03PacketPlayer;
import net.minecraft.util.BlockPos;
import net.minecraft.util.EnumFacing;
import net.minecraft.util.MathHelper;
import net.minecraft.util.Vec3;

import java.util.ArrayList;
import java.util.List;

public class ChestAura 
extends Module {
    public ChestAura() {
        super("ChestAura", Category.PLAYER, 0);
    }

    private TimeHelper time = new TimeHelper();
    private TimeHelper invTime = new TimeHelper();
    private List<BlockPos> emptiedChests = new ArrayList();
    private List<BlockPos> clickedChests = new ArrayList();


	 public float[] getRotationsNeeded(BlockPos entity) {
	        double diffY;
	        if (entity == null) {
	            return null;
	        }
	        double diffX = entity.x - (Minecraft.getMinecraft().thePlayer.posX);
	        double diffZ = entity.z  - (Minecraft.getMinecraft().thePlayer.posZ);
	
	            diffY = entity.y + 0.5- (Minecraft.getMinecraft().thePlayer.posY + (double)Minecraft.getMinecraft().thePlayer.getEyeHeight());
	        
	        double dist = MathHelper.sqrt_double(diffX * diffX + diffZ * diffZ);
	        float yaw = (float)(Math.atan2(diffZ, diffX) * 180.0 / 3.141592653589793) - 90.0f;
	        float pitch = (float)(- Math.atan2(diffY, dist) * 180.0 / 3.141592653589793);
	        return new float[]{Minecraft.getMinecraft().thePlayer.rotationYaw + MathHelper.wrapAngleTo180_float(yaw - Minecraft.getMinecraft().thePlayer.rotationYaw), Minecraft.getMinecraft().thePlayer.rotationPitch + MathHelper.wrapAngleTo180_float(pitch - Minecraft.getMinecraft().thePlayer.rotationPitch)};
	    }

    
    
    @Override
    public void onUpdate() {

        boolean clickBlock = false;
    	    byte radius;
    	    if (this.mc.currentScreen == null && mc.thePlayer.onGround) {

				if (this.time.hasReached(250L)) {
    	        radius = 5;
    	        for (int y = radius; y >= -radius; y--) {
    	          for (int x = -radius; x < radius; x++)
    	            for (int z = -radius; z < radius; z++) {

							time.reset();
                        int posX = ((int) Math.floor(this.mc.thePlayer.posX) + x);
                        int posY = ((int) Math.floor(this.mc.thePlayer.posY) + y);
                        int posZ = ((int) Math.floor(this.mc.thePlayer.posZ) + z);
    	              if (this.mc.thePlayer.getDistanceSq(this.mc.thePlayer.posX + x, this.mc.thePlayer.posY + y, this.mc.thePlayer.posZ + z) <= 16.0D) {
    	                Block block =mc.theWorld.getBlockState(new BlockPos(posX, posY, posZ)).getBlock();
    	                if(block instanceof BlockChest){
    	                	 BlockPos pos =  new BlockPos(posX, posY, posZ);
    	                	if(!this.emptiedChests.contains(pos)){
    	                		float rot[] = this.getRotationsNeeded(new BlockPos(posX, posY, posZ));
    	                		this.emptiedChests.add(pos);
    	                		mc.thePlayer.sendQueue.addToSendQueue(new C03PacketPlayer.C06PacketPlayerPosLook(mc.thePlayer.posX, mc.thePlayer.posY, mc.thePlayer.posZ, rot[0], rot[1], mc.thePlayer.onGround));
    	                	    mc.thePlayer.swingItem(); 
    	                		mc.playerController.func_178890_a(mc.thePlayer, mc.theWorld, mc.thePlayer.getHeldItem(), new BlockPos(posX, posY, posZ), EnumFacing.DOWN, new Vec3(mc.thePlayer.posX, mc.thePlayer.posY, mc.thePlayer.posZ));
    	                		
    	                		
    	                	}
    	                		
    	                }
    	              }
    
    	            }
    	        }
    	    }
    	    }
    }
    
        
    


  public void onEnable() {
    this.emptiedChests.clear();
    this.clickedChests.clear();
  }
}
  

minecraft_de_Client_Main_Modules_mods_Player_ChestStealer.java

package de.Client.Main.Modules.mods.Player;

import com.google.common.collect.Multimap;
import de.Client.Main.Modules.Category;
import de.Client.Main.Modules.Module;
import de.Client.Main.Values.ValueBoolean;
import de.Client.Main.Values.ValueDouble;
import de.Client.Render.ClickGui.Panels.Mini;
import de.Client.Render.ClickGui.Panels.Minitypes.MiniValueBooleanToggleSimple;
import de.Client.Utils.TimeHelper;
import net.minecraft.block.Block;
import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.inventory.GuiChest;
import net.minecraft.client.gui.inventory.GuiInventory;
import net.minecraft.enchantment.Enchantment;
import net.minecraft.enchantment.EnchantmentHelper;
import net.minecraft.entity.ai.attributes.AttributeModifier;
import net.minecraft.init.Blocks;
import net.minecraft.init.Items;
import net.minecraft.inventory.Container;
import net.minecraft.item.*;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

public class ChestStealer extends Module {

	public static ValueDouble Speed;
	public static ValueBoolean Silent;
	public static ValueBoolean Priority;

	public ChestStealer() {
		super("ChestStealer", Category.PLAYER, 0);
        addValue(this.Priority = new ValueBoolean("Priority",true));
		addValue(this.Silent = new ValueBoolean("Silent", false));
		addValue(this.Speed = new ValueDouble("Speed", 80,200,200));
	}
	public boolean isValidItemStack(ItemStack in, boolean skyWars, List<ItemStack> wholeChest) {

        if ((Block.getBlockFromItem(in.getItem()) != null) && (hasBlocks() < 256) && (skyWars) && (Block.getBlockFromItem(in.getItem()) != Blocks.tnt)) {
            return true;
        }
        if (goodFood(in)) {
            return true;
        }
        if (bestWeapon(in, wholeChest)) {
            return true;
        }
        if (bestArmor(in, wholeChest)) {
            return true;
        }
        return bestBow(in, wholeChest) || (in.getItem() instanceof ItemEnderPearl);
    }
	  
	  private boolean bestBow(ItemStack in, List<ItemStack> wholeChest)
	  {
	    if (!(in.getItem() instanceof ItemBow)) {
	      return false;
	    }
	    double bestNum = 0.0D;
	    for (byte isNull = 9; isNull <= 44; isNull = (byte)(isNull + 1))
	    {
	      ItemStack stack = this.mc.thePlayer.inventoryContainer.getSlot(isNull).getStack();
	      if (bowValue(stack) >= bestNum) {
	        bestNum = bowValue(stack);
	      }
	    }
	    boolean inChest = false;
	    for (ItemStack itemStack : wholeChest) {
	      if ((itemStack != null) && (bowValue(itemStack) >= bestNum) && (!itemStack.equals(in)))
	      {
	        bestNum = bowValue(itemStack);
	        inChest = true;
	      }
	    }
          return inChest ? bowValue(in) >= bestNum : bowValue(in) > bestNum;
      }
	  
	  private double bowValue(ItemStack in)
	  {
	    double damage = 0.0D;
	    damage += EnchantmentHelper.getEnchantmentLevel(Enchantment.punch.effectId, in) * 1.25D;
	    damage += EnchantmentHelper.getEnchantmentLevel(Enchantment.power.effectId, in);
	    damage += EnchantmentHelper.getEnchantmentLevel(Enchantment.flame.effectId, in) * 0.5D;
	    damage += EnchantmentHelper.getEnchantmentLevel(Enchantment.infinity.effectId, in) * 0.5D;
	    
	    return damage;
	  }
	  
	  private boolean goodFood(ItemStack in)
	  {
	    if ((in.getItem() instanceof ItemFood))
	    {
	      if ((in.getItem() instanceof ItemAppleGold)) {
	        return true;
	      }
	      if (in.getMaxStackSize() == 1)
	      {
              return hasFood() <= 5;
          }
            return !((hasFood() >= 10) && (((ItemFood) in.getItem()).getHealAmount(in) <= 4));
        }
	    return false;
	  }
	  
	  private int hasFood()
	  {
	    int out = 0;
	    for (byte isNull = 9; isNull <= 44; isNull = (byte)(isNull + 1))
	    {
	      ItemStack stack = Minecraft.getMinecraft().thePlayer.inventoryContainer.getSlot(isNull).getStack();
	      if ((stack != null) && 
	        ((stack.getItem() instanceof ItemFood))) {
	        out += stack.stackSize;
	      }
	    }
	    return out;
	  }
	  
	  private int hasBlocks()
	  {
	    int out = 0;
	    for (byte isNull = 9; isNull <= 44; isNull = (byte)(isNull + 1))
	    {
	      ItemStack stack = Minecraft.getMinecraft().thePlayer.inventoryContainer.getSlot(isNull).getStack();
	      if ((stack != null) && 
	        (Block.getBlockFromItem(stack.getItem()) != null)) {
	        out += stack.stackSize;
	      }
	    }
	    return out;
	  }
	  
	  private boolean bestArmor(ItemStack in, List<ItemStack> wholeChest)
	  {
	    if ((in.getItem() instanceof ItemArmor))
	    {
	      ItemArmor armor = (ItemArmor)in.getItem();
	      double value = getSortDouble(in);
	     
	      if (isHelmet(armor))
	      {
	    	  
	        boolean best = true;
	        if ((this.mc.thePlayer.inventoryContainer.getSlot(5).getHasStack()) && 
	          (value < getSortDouble(this.mc.thePlayer.inventoryContainer.getSlot(5).getStack()) + 0.01D)) {
	          best = false;
	        }
	        for (ItemStack itemStack : wholeChest) {
	          if ((itemStack != null) && 
	            (isHelmet(itemStack.getItem())) && 
	            (value < getSortDouble(itemStack) + 0.01D) && (!in.equals(itemStack))) {
	            best = false;
	          }
	        }
	        for (byte isNull = 9; isNull <= 44; isNull = (byte)(isNull + 1))
	        {
	          ItemStack stack = Minecraft.getMinecraft().thePlayer.inventoryContainer.getSlot(isNull).getStack();
	          if ((stack != null) && 
	            (isHelmet(stack.getItem())) && 
	            (value < getSortDouble(stack) + 0.01D)) {
	            best = false;
	          }
	        }
	        return best;
	      }
	      if (isChest(armor))
	      {
	        boolean best = true;
	        if ((this.mc.thePlayer.inventoryContainer.getSlot(6).getHasStack()) && 
	          (value < getSortDouble(this.mc.thePlayer.inventoryContainer.getSlot(6).getStack()) + 0.01D)) {
	          best = false;
	        }
	        for (ItemStack itemStack : wholeChest) {
	          if ((itemStack != null) && 
	            (isChest(itemStack.getItem())) && 
	            (value < getSortDouble(itemStack) + 0.01D) && (!in.equals(itemStack))) {
	            best = false;
	          }
	        }
	        for (byte isNull = 9; isNull <= 44; isNull = (byte)(isNull + 1))
	        {
	          ItemStack stack = Minecraft.getMinecraft().thePlayer.inventoryContainer.getSlot(isNull).getStack();
	          if ((stack != null) && 
	            (isChest(stack.getItem())) && 
	            (value < getSortDouble(stack) + 0.01D)) {
	            best = false;
	          }
	        }
	        return best;
	      }
	      if (isLeggings(armor))
	      {
	        boolean best = true;
	        if ((this.mc.thePlayer.inventoryContainer.getSlot(7).getHasStack()) && 
	          (value < getSortDouble(this.mc.thePlayer.inventoryContainer.getSlot(7).getStack()) + 0.01D)) {
	          best = false;
	        }
	        for (ItemStack itemStack : wholeChest) {
	          if ((itemStack != null) && 
	            (isLeggings(itemStack.getItem())) && 
	            (value < getSortDouble(itemStack) + 0.01D) && (!in.equals(itemStack))) {
	            best = false;
	          }
	        }
	        for (byte isNull = 9; isNull <= 44; isNull = (byte)(isNull + 1))
	        {
	          ItemStack stack = Minecraft.getMinecraft().thePlayer.inventoryContainer.getSlot(isNull).getStack();
	          if ((stack != null) && 
	            (isLeggings(stack.getItem())) && 
	            (value < getSortDouble(stack) + 0.01D)) {
	            best = false;
	          }
	        }
	        return best;
	      }
	      if (isBoots(armor))
	      {
	        boolean best = true;
	        if ((this.mc.thePlayer.inventoryContainer.getSlot(8).getHasStack()) && 
	          (value < getSortDouble(this.mc.thePlayer.inventoryContainer.getSlot(8).getStack()) + 0.01D)) {
	          best = false;
	        }
	        for (ItemStack itemStack : wholeChest) {
	          if ((itemStack != null) && 
	            (isBoots(itemStack.getItem())) && 
	            (value < getSortDouble(itemStack) + 0.01D) && (!in.equals(itemStack))) {
	            best = false;
	          }
	        }
	        for (byte isNull = 9; isNull <= 44; isNull = (byte)(isNull + 1))
	        {
	          ItemStack stack = Minecraft.getMinecraft().thePlayer.inventoryContainer.getSlot(isNull).getStack();
	          if ((stack != null) && 
	            (isBoots(stack.getItem())) && 
	            (value < getSortDouble(stack) + 0.01D)) {
	            best = false;
	          }
	        }
	        return best;
	      }
	    }
	    return false;
	  }
	  
	  private boolean isHelmet(Item item)
	  {
	    return ((item instanceof ItemArmor)) && (item.getUnlocalizedName().startsWith("item.helmet"));
	  }
	  
	  private boolean isChest(Item item)
	  {
	    return ((item instanceof ItemArmor)) && (item.getUnlocalizedName().startsWith("item.chestplate"));
	  }
	  
	  private boolean isLeggings(Item item)
	  {
	    return ((item instanceof ItemArmor)) && (item.getUnlocalizedName().startsWith("item.leggings"));
	  }
	  
	  private boolean isBoots(Item item)
	  {
	    return ((item instanceof ItemArmor)) && (item.getUnlocalizedName().startsWith("item.boots"));
	  }
	  
	  private boolean bestWeapon(ItemStack in, List<ItemStack> wholeChest)
	  {
	    double bestNum = 0.0D;
	    for (byte isNull = 9; isNull <= 44; isNull = (byte)(isNull + 1))
	    {
	      ItemStack stack = this.mc.thePlayer.inventoryContainer.getSlot(isNull).getStack();
	      if (getItemAttackDamage(stack) >= bestNum) {
	        bestNum = getItemAttackDamage(stack);
	      }
	    }
	    boolean inChest = false;
	    for (ItemStack itemStack : wholeChest) {
	      if ((getItemAttackDamage(itemStack) >= bestNum) && (!itemStack.equals(in)))
	      {
	        bestNum = getItemAttackDamage(itemStack);
	        inChest = true;
	      }
	    }
          return inChest ? getItemAttackDamage(in) >= bestNum : getItemAttackDamage(in) > bestNum;
      }
	  
	  private double getItemAttackDamage(ItemStack item)
	  {
	    return getAttackOldAttackDamage(item);
	  }
	  
	  private double getAttackOldAttackDamage(ItemStack stack)
	  {
	    if (stack == null) {
	      return -1.0D;
	    }
	    Item in = stack.getItem();
	    double damage = -1.0D;
	    if (in == Items.wooden_shovel) {
	      damage = 1.0D;
	    }
	    if (in == Items.wooden_pickaxe) {
	      damage = 2.0D;
	    }
	    if (in == Items.wooden_axe) {
	      damage = 3.0D;
	    }
	    if (in == Items.golden_shovel) {
	      damage = 1.0D;
	    }
	    if (in == Items.golden_pickaxe) {
	      damage = 2.0D;
	    }
	    if (in == Items.golden_axe) {
	      damage = 3.0D;
	    }
	    if (in == Items.stone_shovel) {
	      damage = 2.0D;
	    }
	    if (in == Items.stone_pickaxe) {
	      damage = 3.0D;
	    }
	    if (in == Items.stone_axe) {
	      damage = 4.0D;
	    }
	    if (in == Items.iron_shovel) {
	      damage = 3.0D;
	    }
	    if (in == Items.iron_pickaxe) {
	      damage = 4.0D;
	    }
	    if (in == Items.iron_axe) {
	      damage = 5.0D;
	    }
	    if (in == Items.diamond_shovel) {
	      damage = 4.0D;
	    }
	    if (in == Items.diamond_pickaxe) {
	      damage = 5.0D;
	    }
	    if (in == Items.diamond_axe) {
	      damage = 6.0D;
	    }
	    if (in == Items.wooden_sword) {
	      damage = 4.0D;
	    }
	    if (in == Items.golden_sword) {
	      damage = 4.0D;
	    }
	    if (in == Items.stone_sword) {
	      damage = 5.0D;
	    }
	    if (in == Items.iron_sword) {
	      damage = 6.0D;
	    }
	    if (in == Items.diamond_sword) {
	      damage = 7.0D;
	    }
	    damage += EnchantmentHelper.getEnchantmentLevel(Enchantment.field_180314_l.effectId, stack) * 1.25D;
	    damage += EnchantmentHelper.getEnchantmentLevel(Enchantment.fireAspect.effectId, stack) * 0.25D;
	    return damage;
	  }
	  
	  private double getSortDouble(ItemStack item)
	  {
	    if (!(item.getItem() instanceof ItemArmor)) {
	      return 0.0D;
	    }
	    double sortvalue = 0.0D;
	    if (item.getUnlocalizedName().contains("diamond")) {
	      sortvalue = 0.4D;
	    }
	    if (item.getUnlocalizedName().contains("iron")) {
	      sortvalue = 0.3D;
	    }
	    if (item.getUnlocalizedName().contains("gold")) {
	      sortvalue = 0.0D;
	    }
	    if (item.getUnlocalizedName().contains("leather")) {
	      sortvalue = 0.1D;
	    }
	    if (item.getUnlocalizedName().contains("chain")) {
	      sortvalue = 0.2D;
	    }
	    ItemArmor armor = (ItemArmor)item.getItem();
	    
	    sortvalue += armor.damageReduceAmount + EnchantmentHelper.getEnchantmentLevel(Enchantment.field_180310_c.effectId, item);
	    
	    return sortvalue;
	  }
	private TimeHelper time = new TimeHelper();
	int slot = 0;
	boolean skip = false;

	public boolean isContainerEmpty(Container container) {
		boolean temp = true;
		int i = 0;
		for (int slotAmount = container.inventorySlots.size() == 90 ? 54 : 27; i < slotAmount; i++) {
			if (container.getSlot(i).getHasStack()) {
				temp = false;
			}
		}
		return temp;
	}

	  private float getItemDamage(ItemStack itemStack) {
		  Iterator iterator;
		  Multimap multimap = itemStack.getAttributeModifiers();
		  if (!multimap.isEmpty() && (iterator = multimap.entries().iterator()).hasNext()) {
		   Map.Entry entry = (Map.Entry) iterator.next();
		   AttributeModifier attributeModifier = (AttributeModifier) entry.getValue();
		   double damage = attributeModifier.getOperation() != 1 && attributeModifier.getOperation() != 2
		     ? attributeModifier.getAmount() : attributeModifier.getAmount() * 100.0;
		   if (attributeModifier.getAmount() > 1.0) {
		    return 1.0f + (float) damage;
		   }
		   return 1.0f;
		  }
		  return 1.0f;
		 }

    @Override
    public ArrayList<Mini> createArray(){
        ArrayList<Mini> minis = new ArrayList<>();
        minis.add( new MiniValueBooleanToggleSimple(this,Priority));
        return minis;
    }
	@Override
	public void onUpdate() {
		
		if (!this.getState())
			return;
		
		
		
		if(this.Silent.getValue()){
            if (mc.theWorld != null) {
                if (mc.currentScreen instanceof GuiChest) {
                    mc.gameSettings.keyBindUseItem.pressed = false;
                }
            }
        }
		if(!this.Priority.getValue()){
		
			
			
		if (mc.thePlayer == null || mc.theWorld == null)
			return;
		if ((mc.currentScreen instanceof GuiInventory)) {
			mc.playerController.updateController();
		}
		if (mc.theWorld != null) {
			if (mc.currentScreen instanceof GuiChest) {
				
				
				GuiChest chest = (GuiChest) mc.currentScreen;
				if (isContainerEmpty(mc.thePlayer.openContainer)) {
					mc.thePlayer.closeScreen();
				}
				if (chest.lowerChestInventory.getName().contains("Where") || chest.lowerChestInventory.getName().contains("Lobby Teleporter") || chest.lowerChestInventory.getName().contains("Shop") ||chest.lowerChestInventory.getName().contains("Spiel") || chest.lowerChestInventory.getName().contains("Teleporter") || chest.lowerChestInventory.getName().contains("Spiel ausw�hlen")) {
					return;
				}

				for (int i = this.slot; this.slot < chest.lowerChestInventory.getSizeInventory(); ++this.slot) {
					if (chest.inventorySlots.getSlot(this.slot).getHasStack()) {
						if (!this.time.hasReached((long) this.Speed.getValue())) {
							break;
						}
						
						mc.playerController.windowClick(chest.inventorySlots.windowId, this.slot, 1,1, mc.thePlayer);
						this.time.reset();
						if (isContainerEmpty(mc.thePlayer.openContainer)) {
							mc.thePlayer.closeScreen();
						}
					}
					
				}
			} else {
				this.slot = 0;
			}
		}
	}else{
		 if ((this.mc.currentScreen instanceof GuiChest))
	      {
	        if (time.hasReached((long) this.Speed.getValue()))
	        {
	          if (this.slot == ((GuiChest)this.mc.currentScreen).lowerChestInventory.getSizeInventory() - 1) {
	            return;
	          }
	          List<ItemStack> items = new ArrayList();
	          for (int i = 0; i < ((GuiChest)this.mc.currentScreen).lowerChestInventory.getSizeInventory(); i++) {
	            items.add(((GuiChest)this.mc.currentScreen).lowerChestInventory.getStackInSlot(i));
	          }
	          for (int x = this.slot; x < ((GuiChest)this.mc.currentScreen).lowerChestInventory.getSizeInventory(); x++) {
	            try
	            {
	              if ((((GuiChest)this.mc.currentScreen).lowerChestInventory.getStackInSlot(x) != null) && 
	                (isValidItemStack(((GuiChest)this.mc.currentScreen).lowerChestInventory.getStackInSlot(x), true, items)))
	              {
	                this.mc.playerController.windowClick(((GuiChest)this.mc.currentScreen).inventorySlots.windowId, x, 0, 1, this.mc.thePlayer);
	                this.time.reset();
	                this.slot = x;
	                return;
	              }
	            }
	            catch (Exception ex)
	            {
	              ex.printStackTrace();
	            }
	          }
	          this.slot = ((GuiChest)this.mc.currentScreen).lowerChestInventory.getSizeInventory();
	          this.mc.thePlayer.closeScreen();
	        }
	      }
	      else {
	        this.slot = 0;
	      }
	    }
	
	}
}

minecraft_de_Client_Main_Modules_mods_Player_FakeLag.java

package de.Client.Main.Modules.mods.Player;

import
        de.Client.Events.EventTarget;
import de.Client.Events.Events.PacketReceiveEvent;
import de.Client.Events.Events.PacketSendEvent;
import de.Client.Main.Main;
import de.Client.Main.Modules.Category;
import de.Client.Main.Modules.Module;
import de.Client.Utils.Macro;
import de.Client.Utils.TimeHelper;
import net.minecraft.entity.Entity;
import net.minecraft.network.Packet;
import net.minecraft.network.play.client.C03PacketPlayer;
import net.minecraft.network.play.server.*;
import org.lwjgl.Sys;
import org.lwjgl.input.Controller;
import org.lwjgl.input.Controllers;
import org.lwjgl.input.Keyboard;

import java.util.ArrayList;


public class FakeLag extends Module {

    public FakeLag() {
        super("FakeLag", Category.PLAYER, Keyboard.KEY_NONE);
        // TODO Auto-generated constructor stub
    }

    public TimeHelper t = new TimeHelper();

    public ArrayList<Packet> receivedPackets = new ArrayList();
    public ArrayList<Packet> sendPacket = new ArrayList();

    @EventTarget
    public void onPacketReceiveevent(PacketReceiveEvent e){

        receivedPackets.add(e.getPacket());
        e.setCancelled(true);

    }

    @EventTarget
    public void onPacketSend(PacketSendEvent e){
        sendPacket.add(e.getPacket());
        e.setCancelled(true);
     //   this.toggleModule();
    }

    public void onDisable(){
        /*/
        for(Packet p : this.receivedPackets){
            p.processPacket(mc.getN);
        }
        for(Packet p : this.sendPacket){
            mc.thePlayer.sendQueue.addToSendQueue(p);
        }
        /*/
    }

}

minecraft_de_Client_Main_Modules_mods_Player_InvCleaner.java

package de.Client.Main.Modules.mods.Player;

import com.google.common.collect.Multimap;
import de.Client.Events.EventTarget;
import de.Client.Events.Events.UpdateEvent;
import de.Client.Events.IEvent.State;
import de.Client.Main.Modules.Category;
import de.Client.Main.Modules.Module;
import de.Client.Main.Values.ValueBoolean;
import de.Client.Main.Values.ValueDouble;
import de.Client.Utils.TimeHelper;
import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.inventory.GuiContainerCreative;
import net.minecraft.client.gui.inventory.GuiInventory;
import net.minecraft.enchantment.EnchantmentHelper;
import net.minecraft.entity.EnumCreatureAttribute;
import net.minecraft.entity.ai.attributes.AttributeModifier;
import net.minecraft.item.*;

import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.concurrent.CopyOnWriteArrayList;

/**
 * Created by Daniel on 16.07.2017.
 */
public class InvCleaner extends Module{
    
    public InvCleaner() {
        super("InvCleaner", Category.PLAYER,0);
        addValue(OPENINV);
        addValue(MOVING);
        addValue(ARMOR);
        addValue(TOOLS);
        addValue(DELAY);
        this.time = new TimeHelper();
    }

    public static ValueBoolean OPENINV = new ValueBoolean("OpenInv", true);
    public static ValueBoolean MOVING = new ValueBoolean("Moving", false);

    public static ValueBoolean ARMOR = new ValueBoolean("Armor", true);
    public static ValueBoolean TOOLS = new ValueBoolean("Tools", true);
    public static ValueDouble DELAY = new ValueDouble("Delay", 1.25, 0.0, 5.0);

    private TimeHelper time;

    @EventTarget
    public void onPreMotion(UpdateEvent e) {
        if(!(e.getState() == State.PRE)){
                return;
        }
        if(mc.thePlayer.isUsingItem()) {
            return;
        }
        if(!OPENINV.getValue() || ((mc.currentScreen instanceof GuiInventory || mc.currentScreen instanceof GuiContainerCreative) && OPENINV.getValue())) {
            if(this.time.hasReached((long) (this.DELAY.getValue() * 100))) {
                CopyOnWriteArrayList<Integer> items = new CopyOnWriteArrayList<Integer>();
                for(int slot = 0; slot < 45; slot++) {
                    if(mc.thePlayer.inventoryContainer.getSlot(slot).getHasStack()) {
                        ItemStack item = mc.thePlayer.inventoryContainer.getSlot(slot).getStack();
                        if(mc.thePlayer.inventory.armorInventory[0] == item
                                || mc.thePlayer.inventory.armorInventory[1] == item
                                || mc.thePlayer.inventory.armorInventory[2] == item
                                || mc.thePlayer.inventory.armorInventory[3] == item)
                            continue;
                        if(item != null && item.getItem() != null && Item.getIdFromItem(item.getItem()) != 0 && !stackIsUseful(slot)) {
                            items.add(slot);
                        }
                    }
                }
                if(!items.isEmpty()) {
                    mc.playerController.windowClick(mc.thePlayer.inventoryContainer.windowId, items.get(0), 1, 4, mc.thePlayer);
                    items.remove(0);
                    this.time.reset();
                } else {
                    // Nachricht - Fertig
                    return;
                }
            }
        }
    }

    private boolean stackIsUseful(int slot) {
        ItemStack itemStack = mc.thePlayer.inventoryContainer.getSlot(slot).getStack();

        boolean hasAlreadyOrBetter = false;

        if(itemStack.getItem() instanceof ItemSword || itemStack.getItem() instanceof ItemPickaxe
                || itemStack.getItem() instanceof ItemAxe) {
            for (int o = 0; o < 45; ++o) {
                if(o == slot)
                    continue;
                if(mc.thePlayer.inventoryContainer.getSlot(o).getHasStack()) {
                    ItemStack item = mc.thePlayer.inventoryContainer.getSlot(o).getStack();
                    if(item != null && item.getItem() instanceof ItemSword || item.getItem() instanceof ItemAxe
                            || item.getItem() instanceof ItemPickaxe) {
                        float damageFound = getItemDamage(itemStack);
                        damageFound += EnchantmentHelper.func_152377_a(itemStack, EnumCreatureAttribute.UNDEFINED);

                        float damageCurrent = getItemDamage(item);
                        damageCurrent += EnchantmentHelper.func_152377_a(item, EnumCreatureAttribute.UNDEFINED);

                        if(damageCurrent > damageFound) {
                            hasAlreadyOrBetter = true;
                            break;
                        }
                    }
                }
            }
        } else if(itemStack.getItem() instanceof ItemArmor) {
            for (int o = 0; o < 45; ++o) {
                if(slot == o)
                    continue;
                if(mc.thePlayer.inventoryContainer.getSlot(o).getHasStack()) {
                    ItemStack item = mc.thePlayer.inventoryContainer.getSlot(o).getStack();
                    if(item != null && item.getItem() instanceof ItemArmor) {

                        List<Integer> helmet = Arrays.asList(298, 314, 302, 306, 310);
                        List<Integer> chestplate = Arrays.asList(299, 315, 303, 307, 311);
                        List<Integer> leggings = Arrays.asList(300, 316, 304, 308, 312);
                        List<Integer> boots = Arrays.asList(301, 317, 305, 309, 313);

                        if(helmet.contains(Item.getIdFromItem(item.getItem()))
                                && helmet.contains(Item.getIdFromItem(itemStack.getItem()))) {
                            if(helmet.indexOf(Item.getIdFromItem(itemStack.getItem())) < helmet
                                    .indexOf(Item.getIdFromItem(item.getItem()))) {
                                hasAlreadyOrBetter = true;
                                break;
                            }
                        } else if(chestplate.contains(Item.getIdFromItem(item.getItem()))
                                && chestplate.contains(Item.getIdFromItem(itemStack.getItem()))) {
                            if(chestplate.indexOf(Item.getIdFromItem(itemStack.getItem())) < chestplate
                                    .indexOf(Item.getIdFromItem(item.getItem()))) {
                                hasAlreadyOrBetter = true;
                                break;
                            }
                        } else if(leggings.contains(Item.getIdFromItem(item.getItem()))
                                && leggings.contains(Item.getIdFromItem(itemStack.getItem()))) {
                            if(leggings.indexOf(Item.getIdFromItem(itemStack.getItem())) < leggings
                                    .indexOf(Item.getIdFromItem(item.getItem()))) {
                                hasAlreadyOrBetter = true;
                                break;
                            }
                        } else if(boots.contains(Item.getIdFromItem(item.getItem()))
                                && boots.contains(Item.getIdFromItem(itemStack.getItem()))) {
                            if(boots.indexOf(Item.getIdFromItem(itemStack.getItem())) < boots
                                    .indexOf(Item.getIdFromItem(item.getItem()))) {
                                hasAlreadyOrBetter = true;
                                break;
                            }
                        }

                    }
                }
            }
        }

        for(int o = 0; o < 45; o++) {
            if(slot == o)
                continue;
            if(mc.thePlayer.inventoryContainer.getSlot(o).getHasStack()) {
                ItemStack item = mc.thePlayer.inventoryContainer.getSlot(o).getStack();
                if(item != null && (item.getItem() instanceof ItemSword || item.getItem() instanceof ItemAxe
                        || item.getItem() instanceof ItemBow || item.getItem() instanceof ItemFishingRod
                        || item.getItem() instanceof ItemArmor || item.getItem() instanceof ItemAxe
                        || item.getItem() instanceof ItemPickaxe || Item.getIdFromItem(item.getItem()) == 346)) {
                    Item found = (Item) item.getItem();
                    if(Item.getIdFromItem(itemStack.getItem()) == Item.getIdFromItem(item.getItem())) {
                        hasAlreadyOrBetter = true;
                        break;
                    }
                }
            }
        }
        if(Item.getIdFromItem(itemStack.getItem()) == 367)
            return false; // rotten flesh
        if(Item.getIdFromItem(itemStack.getItem()) == 30)
            return true; // cobweb
        if(Item.getIdFromItem(itemStack.getItem()) == 259)
            return true; // flint & steel
        if(Item.getIdFromItem(itemStack.getItem()) == 262)
            return true; // arrow
        if(Item.getIdFromItem(itemStack.getItem()) == 264)
            return true; // diamond
        if(Item.getIdFromItem(itemStack.getItem()) == 265)
            return true; // iron
        if(Item.getIdFromItem(itemStack.getItem()) == 346)
            return true; // fishing rod
        if(Item.getIdFromItem(itemStack.getItem()) == 384)
            return true; // bottle o' enchanting
        if(Item.getIdFromItem(itemStack.getItem()) == 345)
            return true; // compass
        if(Item.getIdFromItem(itemStack.getItem()) == 296)
            return true; // wheat
        if(Item.getIdFromItem(itemStack.getItem()) == 336)
            return true; // brick
        if(Item.getIdFromItem(itemStack.getItem()) == 266)
            return true; // gold ingot
        if(Item.getIdFromItem(itemStack.getItem()) == 280)
            return true; // stick
        if(itemStack.hasDisplayName())
            return true;
        if(hasAlreadyOrBetter) {
            return false;
        }
        if(itemStack.getItem() instanceof ItemArmor)
            return true;
        if(itemStack.getItem() instanceof ItemAxe)
            return true;
        if(itemStack.getItem() instanceof ItemBow)
            return true;
        if(itemStack.getItem() instanceof ItemSword)
            return true;
        if(itemStack.getItem() instanceof ItemPotion)
            return true;
        if(itemStack.getItem() instanceof ItemFlintAndSteel)
            return true;
        if(itemStack.getItem() instanceof ItemEnderPearl)
            return true;
        if(itemStack.getItem() instanceof ItemBlock)
            return true;
        if(itemStack.getItem() instanceof ItemFood)
            return true;
        if(itemStack.getItem() instanceof ItemPickaxe)
            return true;
        return false;
    }

    private float getItemDamage(final ItemStack itemStack) {
        final Multimap multimap = itemStack.getAttributeModifiers();
        if(!multimap.isEmpty()) {
            final Iterator iterator = multimap.entries().iterator();
            if(iterator.hasNext()) {
                final Map.Entry entry = (Map.Entry) iterator.next();
                final AttributeModifier attributeModifier = (AttributeModifier) entry.getValue();
                double damage;
                if(attributeModifier.getOperation() != 1 && attributeModifier.getOperation() != 2) {
                    damage = attributeModifier.getAmount();
                } else {
                    damage = attributeModifier.getAmount() * 100.0;
                }
                if(attributeModifier.getAmount() > 1.0) {
                    return 1.0F + (float) damage;
                }
                return 1.0F;
            }
        }
        return 1.0F;
    }


}

minecraft_de_Client_Main_Modules_mods_Player_InventoryMove.java

package de.Client.Main.Modules.mods.Player;

import de.Client.Main.Modules.Category;
import de.Client.Main.Modules.Module;
import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.GuiChat;
import net.minecraft.client.settings.KeyBinding;
import org.lwjgl.input.Keyboard;

public class InventoryMove extends Module {

    public InventoryMove() {
        super("InventoryMove", Category.PLAYER,0);
        displayName = "Inventory Move";
    }
    @Override
    public void onUpdate() {

        if(mc.thePlayer == null || mc.theWorld == null || mc.currentScreen instanceof GuiChat) {
            return;
        }



        KeyBinding[] moveKeys = {
                mc.gameSettings.keyBindForward,
                mc.gameSettings.keyBindBack,
                mc.gameSettings.keyBindLeft,
                mc.gameSettings.keyBindRight,
                mc.gameSettings.keyBindJump,
                mc.gameSettings.keyBindSneak
        };

        KeyBinding[] arrayOfKeyBinding;
        int j = (arrayOfKeyBinding = moveKeys).length;
        for(int i = 0; i < j; i++) {
            KeyBinding bind = arrayOfKeyBinding[i];
            KeyBinding.setKeyBindState(bind.getKeyCode(), Keyboard.isKeyDown(bind.getKeyCode()));





        }
    }
    public void onRender(){
        if(!getState()){
            return;
        }

        if((Minecraft.getMinecraft().currentScreen != null) && (!(Minecraft.getMinecraft().currentScreen instanceof GuiChat))) {


            if (Keyboard.isKeyDown((int)200)) {
                mc.thePlayer.rotationPitch -= 1.0f;
            }
            if (Keyboard.isKeyDown((int)208)) {
                mc.thePlayer.rotationPitch += 1.0f;
            }
            if (Keyboard.isKeyDown((int)203)) {
                mc.thePlayer.rotationYaw -= 1.0f;
            }
            if (Keyboard.isKeyDown((int)205)) {
                mc.thePlayer.rotationYaw += 1.0f;

            }
            if(mc.thePlayer.rotationPitch > 89){
                mc.thePlayer.rotationPitch = 89;
            }
            if(mc.thePlayer.rotationPitch < -89){
                mc.thePlayer.rotationPitch = -89;
            }
        }
    }

}

minecraft_de_Client_Main_Modules_mods_Player_NoRotate.java

package de.Client.Main.Modules.mods.Player;

import de.Client.Events.EventTarget;
import de.Client.Events.Events.PacketReceiveEvent;
import de.Client.Main.Main;
import de.Client.Main.Modules.Category;
import de.Client.Main.Modules.Module;
import de.Client.Utils.Macro;
import de.Client.Utils.TimeHelper;
import net.minecraft.entity.Entity;
import net.minecraft.network.play.client.C03PacketPlayer;
import net.minecraft.network.play.server.*;
import org.lwjgl.Sys;
import org.lwjgl.input.Controller;
import org.lwjgl.input.Controllers;
import org.lwjgl.input.Keyboard;


public class NoRotate extends Module {

    public NoRotate() {
        super("NoRotate", Category.PLAYER, Keyboard.KEY_NONE);
        // TODO Auto-generated constructor stub
    }

    public TimeHelper t = new TimeHelper();

    @EventTarget
    public void onPacketReceiveevent(PacketReceiveEvent e){

        if(e.getPacket() instanceof S08PacketPlayerPosLook){
            S08PacketPlayerPosLook packetPlayer = (S08PacketPlayerPosLook) e.getPacket();
            packetPlayer.field_148936_d = mc.thePlayer.rotationYaw;
            packetPlayer.field_148937_e = mc.thePlayer.rotationPitch;
            e.setPacket(packetPlayer);
        }

    }

    @Override
    public boolean isModuleImportant(){
        return false;
    }
}

minecraft_de_Client_Main_Modules_mods_Player_TerrainSpeed.java

package de.Client.Main.Modules.mods.Player;

import de.Client.Events.EventTarget;
import de.Client.Events.Events.PacketReceiveEvent;
import de.Client.Events.Events.PacketSendEvent;
import de.Client.Main.Main;
import de.Client.Main.Modules.Category;
import de.Client.Main.Modules.Module;
import de.Client.Main.Values.ValueBoolean;
import de.Client.Render.ClickGui.Panels.Mini;
import de.Client.Render.ClickGui.Panels.Minitypes.MiniOneOfTwo;
import de.Client.Utils.Macro;
import net.minecraft.block.*;
import net.minecraft.entity.Entity;
import net.minecraft.network.play.client.C03PacketPlayer;
import net.minecraft.network.play.server.*;
import net.minecraft.util.BlockPos;
import net.minecraft.world.World;
import org.lwjgl.Sys;
import org.lwjgl.input.Controller;
import org.lwjgl.input.Controllers;
import org.lwjgl.input.Keyboard;

import java.math.BigInteger;
import java.security.SecureRandom;
import java.util.ArrayList;
import java.util.Random;


public class TerrainSpeed extends Module {

    public TerrainSpeed() {
        super("TerrainSpeed", Category.MOVEMENT, Keyboard.KEY_NONE);
        // TODO Auto-generated constructor stub
        addValue(AAC);
        addValue(AACNEW);
        addValue(NCP);
    }
    public boolean icespeedjump = true;
    public double aacIceSpeed = 0;
    public ValueBoolean NCP = new ValueBoolean("NCP",true);
    public ValueBoolean AACNEW = new ValueBoolean("AACNEW",false);
    public ValueBoolean AAC = new ValueBoolean("AAC",false);
    @Override
    public ArrayList<Mini> createArray(){
        ArrayList<Mini> minis = new ArrayList<>();
        minis.add( new MiniOneOfTwo(this,AAC,NCP));
        return minis;
    }
    @EventTarget
    public void onPacketSend(PacketSendEvent e){
        if(e.getPacket() instanceof C03PacketPlayer && icespeedjump && this.AACNEW.getValue()){
            C03PacketPlayer packet = (C03PacketPlayer) e.getPacket();
            packet.y +=0.09;
            e.setPacket(packet);
        }
    }
    public void onUpdate() {
        if(this.AACNEW.getValue()){
            if((mc.theWorld.getBlockState(new BlockPos(mc.thePlayer.posX, mc.thePlayer.posY +1, mc.thePlayer.posZ)).getBlock() instanceof BlockLadder || mc.theWorld.getBlockState(new BlockPos(mc.thePlayer.posX, mc.thePlayer.posY +1, mc.thePlayer.posZ)).getBlock() instanceof BlockVine ) && ! mc.thePlayer.isOnLadder()){
                mc.thePlayer.motionY = 0.15;
            }
            if(mc.thePlayer.isOnLadder()){
                if(mc.gameSettings.keyBindJump.pressed){
                    mc.thePlayer.motionY = 0.15f;
                }
            }
            if(mc.theWorld.getBlockState(new BlockPos(mc.thePlayer.posX, mc.thePlayer.posY , mc.thePlayer.posZ)).getBlock() instanceof BlockSnow){
                if(!mc.gameSettings.keyBindJump.pressed){
                    if(mc.thePlayer.onGround) {
                        mc.thePlayer.jump();
                    }else{
                        mc.thePlayer.motionY = -1;
                    }
                }
            }
           if(mc.thePlayer.isInWeb){
               mc.thePlayer.isInWeb = false;
               icespeedjump = true;
                mc.thePlayer.motionY/=5;
                mc.gameSettings.keyBindJump.pressed = false;
           }else{
               this.icespeedjump = false;
           }
            if (mc.theWorld.getBlockState(new BlockPos(mc.thePlayer.posX, mc.thePlayer.posY - 1, mc.thePlayer.posZ)).getBlock() instanceof BlockIce || mc.theWorld.getBlockState(new BlockPos(mc.thePlayer.posX, mc.thePlayer.posY - 1, mc.thePlayer.posZ)).getBlock() instanceof BlockPackedIce ) {
               if( !(mc.theWorld.getBlockState(new BlockPos(mc.thePlayer.posX, mc.thePlayer.posY + 2, mc.thePlayer.posZ)).getBlock() instanceof BlockAir) ) {

                   mc.thePlayer.addSpeed(0.2);
                   if (mc.thePlayer.getSpeed() > this.aacIceSpeed) {
                       aacIceSpeed = mc.thePlayer.getSpeed();
                   }

               }
            }else{
               if(aacIceSpeed > 0.2 && mc.gameSettings.keyBindSprint.pressed){
                   mc.thePlayer.setSpeed(aacIceSpeed);
                   aacIceSpeed /= 1.02;
                   if(mc.thePlayer.isCollidedHorizontally){
                       aacIceSpeed = 0;
                   }
               }else{
                   aacIceSpeed = 0;
               }
            }
        }
        if (this.AAC.getValue()) {

            //AAC
            if (mc.theWorld.getBlockState(new BlockPos(mc.thePlayer.posX, mc.thePlayer.posY, mc.thePlayer.posZ)).getBlock() instanceof BlockSoulSand) {
               mc.thePlayer.setSpeed(0.07);
            }
            if (mc.thePlayer.isInWeb) {
                mc.thePlayer.motionY = 0.05;
                mc.thePlayer.setSpeed(0.55);
            }
            if (mc.theWorld.getBlockState(new BlockPos(mc.thePlayer.posX, mc.thePlayer.posY - 1, mc.thePlayer.posZ)).getBlock() instanceof BlockIce || mc.theWorld.getBlockState(new BlockPos(mc.thePlayer.posX, mc.thePlayer.posY - 1, mc.thePlayer.posZ)).getBlock() instanceof BlockPackedIce) {
                mc.thePlayer.motionX *= 1.2;
                mc.thePlayer.motionZ *= 1.2;
                mc.thePlayer.setSpeed(mc.thePlayer.getSpeed());
                if (mc.thePlayer.getSpeed() > 1.15) {
                    mc.thePlayer.setSpeed(1.15);
                }
                this.aacIceSpeed = 0;
                double blocks = mc.thePlayer.getSpeed();
                double x = Math.cos(Math.toRadians(mc.thePlayer.rotationYaw + 90.0F));
                double z = Math.sin(Math.toRadians(mc.thePlayer.rotationYaw + 90.0F));
                double y = mc.thePlayer.posY;
                this.aacIceSpeed = mc.thePlayer.getSpeed();
                Block b = mc.theWorld.getBlockState(new BlockPos(mc.thePlayer.posX + (1.0D * blocks * x + 0.0D * blocks * z), mc.thePlayer.posY-1, mc.thePlayer.posZ + (1.0D * blocks * z - 0.0D * blocks * x))).getBlock();
                if(!((b instanceof BlockPackedIce) && !((b instanceof BlockIce)))){
                    if(mc.thePlayer.onGround) {
                        mc.thePlayer.jump();
                        this.icespeedjump = false;
                    }
                }
            }else{

                if(aacIceSpeed > 0.2){
                    if(!mc.thePlayer.onGround){
                        mc.thePlayer.motionY -= 0.013;
                    }
                    mc.thePlayer.setSpeed(aacIceSpeed);
                    aacIceSpeed /= 1.02;
                }
                if(mc.thePlayer.isCollidedHorizontally){
                    aacIceSpeed = 0;
                }


            }

        }
        if (this.NCP.getValue()) {
            if (mc.gameSettings.keyBindForward.pressed || mc.gameSettings.keyBindBack.pressed) {
                if (mc.theWorld.getBlockState(new BlockPos(mc.thePlayer.posX, mc.thePlayer.posY-1, mc.thePlayer.posZ)).getBlock() instanceof BlockIce ||   (mc.theWorld.getBlockState(new BlockPos(mc.thePlayer.posX, mc.thePlayer.posY-1, mc.thePlayer.posZ)).getBlock() instanceof BlockPackedIce)) {
                       if(mc.thePlayer.onGround) {
                           mc.thePlayer.jump();
                           mc.thePlayer.setSpeed(1.25);
                           mc.thePlayer.motionY = 0.42399999499320984D;
                           icespeedjump = true;
                       }else{

                       }


                }
                if(icespeedjump){
                    if(!mc.thePlayer.onGround){
                       mc.thePlayer.setSpeed(mc.thePlayer.getSpeed());
                        if (this.mc.thePlayer.motionY == -0.07190068807140403D) {
                            this.mc.thePlayer.motionY *= 0.3499999940395355D;
                        }
                        if (this.mc.thePlayer.motionY == -0.10306193759436909D) {
                            this.mc.thePlayer.motionY *= 0.550000011920929D;
                        }
                        if (this.mc.thePlayer.motionY == -0.13395038817442878D) {
                            this.mc.thePlayer.motionY *= 0.6700000166893005D;
                        }
                        if (this.mc.thePlayer.motionY == -0.16635183030382D) {
                            this.mc.thePlayer.motionY *= 0.6899999976158142D;
                        }
                        if (this.mc.thePlayer.motionY == -0.19088711097794803D) {
                            this.mc.thePlayer.motionY *= 0.7099999785423279D;
                        }
                        if (this.mc.thePlayer.motionY == -0.21121925191528862D) {
                            this.mc.thePlayer.motionY *= 0.20000000298023224D;
                        }
                        if (this.mc.thePlayer.motionY == -0.11979897632390576D) {
                            this.mc.thePlayer.motionY *= 0.9300000071525574D;
                        }
                        if (this.mc.thePlayer.motionY == -0.18758479151225355D) {
                            this.mc.thePlayer.motionY *= 0.7200000286102295D;
                        }
                        if (this.mc.thePlayer.motionY == -0.21075983825251726D) {
                            this.mc.thePlayer.motionY *= 0.7599999904632568D;
                        }

                    }else{
                        if (mc.theWorld.getBlockState(new BlockPos(mc.thePlayer.posX, mc.thePlayer.posY-1, mc.thePlayer.posZ)).getBlock() instanceof BlockIce ||   (mc.theWorld.getBlockState(new BlockPos(mc.thePlayer.posX, mc.thePlayer.posY-1, mc.thePlayer.posZ)).getBlock() instanceof BlockPackedIce)) {

                        }else{
                            icespeedjump = false;
                        }
                    }
                }
                if (mc.theWorld.getBlockState(new BlockPos(mc.thePlayer.posX, mc.thePlayer.posY, mc.thePlayer.posZ)).getBlock() instanceof BlockSoulSand) {
                    mc.thePlayer.setSpeed(0.23);
                }
                if (mc.thePlayer.isInWeb) {
                    mc.thePlayer.setSpeed(0.29);
                    if (mc.thePlayer.onGround) {

                    }

                }
            }
        }
    }

    @Override
    public boolean isModuleImportant(){
        return false;
    }
}

minecraft_de_Client_Main_Modules_mods_Player_Velocity.java

package de.Client.Main.Modules.mods.Player;

import de.Client.Events.EventTarget;
import de.Client.Events.Events.PacketReceiveEvent;
import de.Client.Main.Main;
import de.Client.Main.Modules.Category;
import de.Client.Main.Modules.Module;
import de.Client.Main.Values.ValueBoolean;
import de.Client.Main.Values.ValueDouble;
import de.Client.Render.ClickGui.Panels.Mini;
import de.Client.Render.ClickGui.Panels.Minitypes.MiniValueBooleanToggleSimple;
import net.minecraft.network.play.server.S12PacketEntityVelocity;
import net.minecraft.util.BlockPos;
import net.minecraft.util.MathHelper;
import org.lwjgl.input.Keyboard;

import java.util.ArrayList;

public class Velocity extends Module {

	public ValueDouble horizontalMuliplier = new ValueDouble("horizontal",100,200,200);
	public ValueDouble verticalMuliplier = new ValueDouble("vertical",100,200,200);
	public ValueBoolean aac = new ValueBoolean("AAC",true);
	public Velocity() {
		super("Velocity", Category.PLAYER, Keyboard.KEY_NONE);
		addValue(this.horizontalMuliplier);
		addValue(this.verticalMuliplier);
		addValue(aac);
	}
    @Override
    public ArrayList<Mini> createArray(){
        ArrayList<Mini> minis = new ArrayList<>();
        minis.add( new MiniValueBooleanToggleSimple(this,aac));
        return minis;
    }
	public boolean fix;
	public double blockPos;
    public double oldblockpos;
	public void onUpdate(){
	    if(!this.aac.getValue()){
	        return;
        }
        /*/
        oldblockpos = mc.thePlayer.rotationYaw;
        if(mc.thePlayer.hurtTime <=0){
            blockPos = mc.thePlayer.rotationYaw;
        }else{
            if(blockPos < oldblockpos + 360){
                blockPos += 0.4;
            }
            //mc.thePlayer.setSpeed(0.4);
            mc.thePlayer.motionX = -MathHelper.sin((float) blockPos) * 0.8;
            mc.thePlayer.motionZ =  MathHelper.cos((float) blockPos) * 0.8;
            /*/
        if(mc.thePlayer.hurtTime > 0 && fix) {
            if(mc.thePlayer.getSpeed() < 0.35) {
                mc.thePlayer.addSpeed(0.22);
            }

                blockPos = mc.thePlayer.getSpeed();

        }else{
            fix = false;
        }
          /*/
            if (mc.thePlayer.hurtResistantTime >= 10) {
                if(mc.thePlayer.onGround){
                    mc.thePlayer.motionY = 0.101;
                    mc.thePlayer.setSpeed(mc.thePlayer.getSpeed());
                }else{
                    mc.thePlayer.motionY -= 0.01;
                }
            }
            /*/

    }
	
	@EventTarget
	public void onPacketReceiveEvent(PacketReceiveEvent e){
		if(e.getPacket() instanceof S12PacketEntityVelocity){
            S12PacketEntityVelocity velocity = (S12PacketEntityVelocity) e.getPacket();
            if(velocity.field_149417_a == mc.thePlayer.getEntityId()) {

                if(velocity.field_149416_c > 0 ){
                    this.fix = true;
                }
            }
        }
	}

}

minecraft_de_Client_Main_Modules_mods_Render_Babygame.java

package de.Client.Main.Modules.mods.Render;


import de.Client.Main.Modules.Category;
import de.Client.Main.Modules.Module;

public class Babygame extends Module {

    public Babygame() {
        super("Babygame", Category.RENDER,0);
    }




}

minecraft_de_Client_Main_Modules_mods_Render_BetterOverlay.java

package de.Client.Main.Modules.mods.Render;


import de.Client.Events.EventTarget;
import de.Client.Events.Events.DisplayGuiScreenEvent;
import de.Client.Events.Events.EventRenderWorldBackground;
import de.Client.Main.Main;
import de.Client.Main.Modules.Category;
import de.Client.Main.Modules.Module;
import de.Client.Main.Values.ValueBoolean;
import de.Client.Render.ClickGui.Panels.Mini;
import de.Client.Render.ClickGui.Panels.Minitypes.MiniOneOfTwo;
import de.Client.Render.GuiApi;
import de.Client.Utils.ShaderResourcepack;
import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.ScaledResolution;
import net.minecraft.client.renderer.EntityRenderer;
import net.minecraft.client.shader.Shader;
import net.minecraft.client.shader.ShaderGroup;
import net.minecraft.client.shader.ShaderUniform;
import net.minecraft.util.ResourceLocation;

import java.io.ByteArrayInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Field;
import java.util.*;

public class BetterOverlay extends Module {

    public BetterOverlay() {
        super("BetterOverlay", Category.RENDER,0);
        addValue(noOverlay);
        addValue(blurOverlay);
        fadeTime = 1000;
    }

    public ValueBoolean noOverlay = new ValueBoolean("None",false);
    public ValueBoolean blurOverlay = new ValueBoolean("Blur",true);
    private ShaderResourcepack dummyPack;
    @Override
    public void onEnable(){
        this.dummyPack = new ShaderResourcepack();
        this.dummyPack.func_110549_a(null);
        fadeTime = 350;
        super.onEnable();
    }

    @Override
    public boolean isModuleImportant(){
        return false;
    }
    @Override
    public ArrayList<Mini> createArray(){
        ArrayList<Mini> minis = new ArrayList<>();
        minis.add( new MiniOneOfTwo(this,noOverlay,blurOverlay));
        return minis;
    }
    public boolean enabled;
    @EventTarget
    public void renderWorldBackGround(DisplayGuiScreenEvent e){
        if(!blurOverlay.getValue()){
            return;
        }
        if(e.guiScreenbevor == null && e.guiScreenafter != null){
            Minecraft.getMinecraft().entityRenderer.func_175069_a(new ResourceLocation("shaders/post/fade_in_blur.json"));
            this.start = System.currentTimeMillis();
        }else{
            if(e.guiScreenbevor != null && e.guiScreenafter == null){
                Minecraft.getMinecraft().entityRenderer.stopUseShader();
            }
        }


    }
    private float getProgress() {
        return Math.min((System.currentTimeMillis() - this.start) / this.fadeTime, 1.0f);
    }
    protected boolean validPath(final ResourceLocation location) {
        return true;
    }
    public float radius1 = 5;

    private String[] blurExclusions;
    private Field _listShaders;
    private long start;
    private float fadeTime = 300;
    public int radius = 2;
    public int colorFirst = 75000000;
    public int colorSecond = 75000000;
    public int getBackgroundColor(final boolean second) {
        int color = second ? colorFirst: colorSecond;
        int a = color >>> 24;
        int r = color >> 16 & 0xFF;
        int b = color >> 8 & 0xFF;
        int g = color & 0xFF;
        final float prog = getProgress();
        a *= (int)prog;
        r *= (int)prog;
        g *= (int)prog;
        b *= (int)prog;
        return a << 24 | r << 16 | b << 8 | g;
    }
    @EventTarget
    public void renderWorldBackGround(EventRenderWorldBackground e){
        if(this.blurOverlay.getValue()){
            ScaledResolution sr = new ScaledResolution();
            GuiApi.drawGradientRect(0, 0,sr.getScaledWidth(), sr.getScaledHeight(), -1072689136, -804253680);
            final ShaderGroup sg = Minecraft.getMinecraft().entityRenderer.getShaderGroup();

                final List<Shader> shaders = Minecraft.getMinecraft().entityRenderer.theShaderGroup.listShaders;
                for (final Shader s : shaders) {
                    final ShaderUniform su = s.getShaderManager().getShaderUniform("Progress");
                    if (su != null) {
                        su.set(this.getProgress());
                    }
                }


        }
        if(this.blurOverlay.getValue() || this.noOverlay.getValue()) {
            e.setCancelled(true);
        }
    }


}

minecraft_de_Client_Main_Modules_mods_Render_ChestESP.java

package de.Client.Main.Modules.mods.Render;


import de.Client.Main.Main;
import de.Client.Main.Modules.Category;
import de.Client.Main.Modules.Module;
import de.Client.Main.Values.ValueBoolean;
import de.Client.Render.GuiApi;
import de.Client.Utils.TimeHelper;
import net.minecraft.block.BlockFlower;
import net.minecraft.block.BlockSapling;
import net.minecraft.client.renderer.GlStateManager;
import net.minecraft.client.renderer.Tessellator;
import net.minecraft.client.renderer.WorldRenderer;
import net.minecraft.client.renderer.entity.RenderManager;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.tileentity.TileEntityChest;
import net.minecraft.util.AxisAlignedBB;
import net.minecraft.util.BlockPos;
import org.lwjgl.opengl.GL11;

import java.util.ArrayList;


public class ChestESP extends Module {

    public ChestESP() {
        super("ChestESP", Category.RENDER, 0);
        addValue(mcd);
    }

    public static void drawBoundingBox(AxisAlignedBB aa) {
        Tessellator tessellator = Tessellator.getInstance();
        WorldRenderer worldRenderer = tessellator.getWorldRenderer();
        worldRenderer.startDrawingQuads();
        worldRenderer.addVertex(aa.minX, aa.minY, aa.minZ);
        worldRenderer.addVertex(aa.minX, aa.maxY, aa.minZ);
        worldRenderer.addVertex(aa.maxX, aa.minY, aa.minZ);
        worldRenderer.addVertex(aa.maxX, aa.maxY, aa.minZ);
        worldRenderer.addVertex(aa.maxX, aa.minY, aa.maxZ);
        worldRenderer.addVertex(aa.maxX, aa.maxY, aa.maxZ);
        worldRenderer.addVertex(aa.minX, aa.minY, aa.maxZ);
        worldRenderer.addVertex(aa.minX, aa.maxY, aa.maxZ);
        tessellator.draw();
        worldRenderer.startDrawingQuads();
        worldRenderer.addVertex(aa.maxX, aa.maxY, aa.minZ);
        worldRenderer.addVertex(aa.maxX, aa.minY, aa.minZ);
        worldRenderer.addVertex(aa.minX, aa.maxY, aa.minZ);
        worldRenderer.addVertex(aa.minX, aa.minY, aa.minZ);
        worldRenderer.addVertex(aa.minX, aa.maxY, aa.maxZ);
        worldRenderer.addVertex(aa.minX, aa.minY, aa.maxZ);
        worldRenderer.addVertex(aa.maxX, aa.maxY, aa.maxZ);
        worldRenderer.addVertex(aa.maxX, aa.minY, aa.maxZ);
        tessellator.draw();
        worldRenderer.startDrawingQuads();
        worldRenderer.addVertex(aa.minX, aa.maxY, aa.minZ);
        worldRenderer.addVertex(aa.maxX, aa.maxY, aa.minZ);
        worldRenderer.addVertex(aa.maxX, aa.maxY, aa.maxZ);
        worldRenderer.addVertex(aa.minX, aa.maxY, aa.maxZ);
        worldRenderer.addVertex(aa.minX, aa.maxY, aa.minZ);
        worldRenderer.addVertex(aa.minX, aa.maxY, aa.maxZ);
        worldRenderer.addVertex(aa.maxX, aa.maxY, aa.maxZ);
        worldRenderer.addVertex(aa.maxX, aa.maxY, aa.minZ);
        tessellator.draw();
        worldRenderer.startDrawingQuads();
        worldRenderer.addVertex(aa.minX, aa.minY, aa.minZ);
        worldRenderer.addVertex(aa.maxX, aa.minY, aa.minZ);
        worldRenderer.addVertex(aa.maxX, aa.minY, aa.maxZ);
        worldRenderer.addVertex(aa.minX, aa.minY, aa.maxZ);
        worldRenderer.addVertex(aa.minX, aa.minY, aa.minZ);
        worldRenderer.addVertex(aa.minX, aa.minY, aa.maxZ);
        worldRenderer.addVertex(aa.maxX, aa.minY, aa.maxZ);
        worldRenderer.addVertex(aa.maxX, aa.minY, aa.minZ);
        tessellator.draw();
        worldRenderer.startDrawingQuads();
        worldRenderer.addVertex(aa.minX, aa.minY, aa.minZ);
        worldRenderer.addVertex(aa.minX, aa.maxY, aa.minZ);
        worldRenderer.addVertex(aa.minX, aa.minY, aa.maxZ);
        worldRenderer.addVertex(aa.minX, aa.maxY, aa.maxZ);
        worldRenderer.addVertex(aa.maxX, aa.minY, aa.maxZ);
        worldRenderer.addVertex(aa.maxX, aa.maxY, aa.maxZ);
        worldRenderer.addVertex(aa.maxX, aa.minY, aa.minZ);
        worldRenderer.addVertex(aa.maxX, aa.maxY, aa.minZ);
        tessellator.draw();
        worldRenderer.startDrawingQuads();
        worldRenderer.addVertex(aa.minX, aa.maxY, aa.maxZ);
        worldRenderer.addVertex(aa.minX, aa.minY, aa.maxZ);
        worldRenderer.addVertex(aa.minX, aa.maxY, aa.minZ);
        worldRenderer.addVertex(aa.minX, aa.minY, aa.minZ);
        worldRenderer.addVertex(aa.maxX, aa.maxY, aa.minZ);
        worldRenderer.addVertex(aa.maxX, aa.minY, aa.minZ);
        worldRenderer.addVertex(aa.maxX, aa.maxY, aa.maxZ);
        worldRenderer.addVertex(aa.maxX, aa.minY, aa.maxZ);
        tessellator.draw();
    }

    public static void setColor(int colorHex, float alpha) {

        float red = (colorHex >> 16 & 0xFF) / 255.0F;
        float green = (colorHex >> 8 & 0xFF) / 255.0F;
        float blue = (colorHex & 0xFF) / 255.0F;
        GL11.glColor4f(red, green, blue, alpha == 0.0F ? 1.0F : alpha);
    }

    private ArrayList<BlockPos> matchingBlocks = new ArrayList();
    public TimeHelper timer = new TimeHelper();
    public ValueBoolean mcd = new ValueBoolean("MCD", false);


    public static void drawRect(double x, double y, double x2, double y2, WorldRenderer var10)
    {

    }
    public void onRender() {
       // Main.getMain.cmdManager.sendChatMessage(mc.theWorld.getBlockState(new BlockPos(mc.thePlayer.posX,mc.thePlayer.posY,mc.thePlayer.posZ)).getBlock()+"");
        if (!this.mcd.getValue()) {
            for (Object e : mc.theWorld.loadedTileEntityList) {
                TileEntity tileEntity = (TileEntity) e;
                if (tileEntity instanceof TileEntityChest) {
                    /*/
                    TileEntityChest tileEntityChest = (TileEntityChest) tileEntity;
                    double renderX = tileEntityChest.getPos().x - RenderManager.renderPosX;
                    double renderY = tileEntityChest.getPos().y - RenderManager.renderPosY;
                    double renderZ = tileEntityChest.getPos().z - RenderManager.renderPosZ;
                    GL11.glPushMatrix();
                    GL11.glTranslated(renderX, renderY, renderZ);
                    GL11.glPolygonOffset(1.0F, -1.0E7F);


                    GL11.glPushMatrix();
                    GL11.glEnable(GL11.GL_BLEND);
                    GL11.glBlendFunc(770, 771);
                    // GL11.glDisable(GL11.GL_LIGHTING);
                    GL11.glDisable(GL11.GL_TEXTURE_2D);
                    GL11.glEnable(GL11.GL_LINE_SMOOTH);
                    GL11.glDisable(GL11.GL_DEPTH_TEST);
                    GL11.glDepthMask(false);
                    setColor(Main.getMain.getPurple(15000, 55500000).getRGB(), 0.3f);
                    drawBoundingBox(new AxisAlignedBB(0.06, 0, 0.06, 0.94, 0.88, 0.94));

                    GL11.glDisable(GL11.GL_LINE_SMOOTH);
                    GL11.glEnable(GL11.GL_TEXTURE_2D);
                    // GL11.glEnable(GL11.GL_LIGHTING);
                    GL11.glEnable(GL11.GL_DEPTH_TEST);
                    GL11.glDepthMask(true);

                    GL11.glPopMatrix();
                    GL11.glScaled(1, 1, 1);
                    GL11.glPolygonOffset(1.0F, 1000000.0F);
                    GL11.glTranslated(-renderX, -renderY, -renderZ);
                    GL11.glPopMatrix();
                    /*/

                    GlStateManager.pushMatrix();
                    GlStateManager.enablePolygonOffset();
                    GlStateManager.doPolygonOffset(1.0F, -1500000.0F);
                    GlStateManager.translate(tileEntity.getPos().getX() - RenderManager.renderPosX + 0.5D, tileEntity.getPos().getY() - RenderManager.renderPosY + 0.5D, tileEntity.getPos().getZ() - RenderManager.renderPosZ + 0.5D);
                    GlStateManager.rotate(-RenderManager.playerViewY, 0F, 1.0F, 0.0F);
                    GlStateManager.rotate(RenderManager.playerViewX, 1F, 0.0F, 0.0F);
                    GlStateManager.scale(-0.02666667F, -0.02666667F, 0.02666667F);


                    GuiApi.drawRect(-22.5D, -22.5D, -6.5D, -18.5D, -16777216);
                    GuiApi.drawRect(22.5D, -22.5D, 6.5D, -18.5D, -16777216);
                    GuiApi.drawRect(-22.5D, 21.5D, -6.5D, 25.5D, -16777216);
                    GuiApi.drawRect(22.5D, 21.5D, 6.5D, 25.5D, -16777216);
                    GuiApi.drawRect(18.5D, 25.0D, 22.5D, 9.5D, -16777216);
                    GuiApi.drawRect(18.5D, -22.5D, 22.5D, -6.5D, -16777216);
                    GuiApi.drawRect(-18.5D, 25.0D, -22.5D, 9.5D, -16777216);
                    GuiApi.drawRect(-18.5D, -22.5D, -22.5D, -6.5D, -16777216);

                    GL11.glDisable(GL11.GL_DEPTH_TEST);
                    GuiApi.drawRect(-22.0D, -22.0D, -7.0D, -19.0D, Main.getMain.getClientColor().getRGB());
                    GuiApi.drawRect(-22.0D, 22.0D, -7.0D, 25.0D,Main.getMain.getClientColor().getRGB());
                    GuiApi.drawRect(19.0D, -22.0D, 22.0D, -7.0D, Main.getMain.getClientColor().getRGB());
                    GuiApi.drawRect(-19.0D, 22.0D, -22.0D, 10.0D, Main.getMain.getClientColor().getRGB());
                    GuiApi.drawRect(22.0D, 22.0D, 7.0D, 25.0D, Main.getMain.getClientColor().getRGB());
                    GuiApi.drawRect(22.0D, -22.0D, 7.0D, -19.0D,Main.getMain.getClientColor().getRGB());
                    GuiApi.drawRect(19.0D, 22.0D, 22.0D, 10.0D, Main.getMain.getClientColor().getRGB());
                    GuiApi.drawRect(-19.0D, -22.0D, -22.0D, -7.0D, Main.getMain.getClientColor().getRGB());
                    GL11.glEnable(GL11.GL_DEPTH_TEST);
                    GlStateManager.disablePolygonOffset();
                    GlStateManager.doPolygonOffset(1.0F, 1500000.0F);
                    GlStateManager.popMatrix();


                }
            }
        }
        if (mcd.getValue()) {
            if (timer.hasReached(3000L)) {
                timer.reset();
                this.matchingBlocks.clear();
                for (int y = 30; y >= -30; y--) {
                    for (int x = 30; x >= -30; x--) {
                        for (int z = 30; z >= -30; z--) {
                            int posX = (int) (mc.thePlayer.posX + x);
                            int posY = (int) (mc.thePlayer.posY + y);
                            int posZ = (int) (mc.thePlayer.posZ + z);
                            BlockPos pos = new BlockPos(posX, posY, posZ);


                            if (mc.theWorld.getBlockState(pos).getBlock() instanceof BlockFlower||mc.theWorld.getBlockState(pos).getBlock() instanceof BlockSapling) {
                                this.matchingBlocks.add(pos);
                            }


                        }
                    }
                }
            }

            for (BlockPos pos : this.matchingBlocks) {
                double renderX = pos.x - RenderManager.renderPosX;
                double renderY = pos.y - RenderManager.renderPosY;
                double renderZ = pos.z - RenderManager.renderPosZ;
                GL11.glPushMatrix();
                GL11.glTranslated(renderX, renderY, renderZ);
                GL11.glPolygonOffset(1.0F, -1.0E7F);


                GL11.glPushMatrix();
                GL11.glEnable(GL11.GL_BLEND);
                GL11.glBlendFunc(770, 771);
                // GL11.glDisable(GL11.GL_LIGHTING);
                GL11.glDisable(GL11.GL_TEXTURE_2D);
                GL11.glEnable(GL11.GL_LINE_SMOOTH);
                GL11.glDisable(GL11.GL_DEPTH_TEST);
                GL11.glDepthMask(false);
                setColor(Main.getMain.getPurple(15000, 55500000).getRGB(), 0.3f);
                drawBoundingBox(new AxisAlignedBB(0.06, 0, 0.06, 0.94, 0.88, 0.94));

                GL11.glDisable(GL11.GL_LINE_SMOOTH);
                GL11.glEnable(GL11.GL_TEXTURE_2D);
                // GL11.glEnable(GL11.GL_LIGHTING);
                GL11.glEnable(GL11.GL_DEPTH_TEST);
                GL11.glDepthMask(true);

                GL11.glPopMatrix();
                GL11.glScaled(1, 1, 1);
                GL11.glPolygonOffset(1.0F, 1000000.0F);
                GL11.glTranslated(-renderX, -renderY, -renderZ);
                GL11.glPopMatrix();
            }
        }
    }
}

minecraft_de_Client_Main_Modules_mods_Render_ESP.java

package de.Client.Main.Modules.mods.Render;


import de.Client.Events.EventTarget;
import de.Client.Events.Events.EventRenderScreen;
import de.Client.Main.Main;
import de.Client.Main.Modules.Category;
import de.Client.Main.Modules.Module;
import de.Client.Main.Values.ValueBoolean;
import de.Client.Render.GuiApi;
import net.minecraft.client.gui.ScaledResolution;
import net.minecraft.entity.Entity;
import net.minecraft.entity.EntityLivingBase;
import org.lwjgl.opengl.GL11;

import java.awt.*;


public class ESP extends Module {


    public ValueBoolean player = new ValueBoolean("players", true);

    public ESP() {
        super("ESP", Category.RENDER, 0);
    }

    @EventTarget
    public void on2D(EventRenderScreen screen) {
        Main.getMain.renderer2d.shouldConvert2d = true;
        for (Entity e : Main.getMain.renderer2d.upperPos1.keySet()) {
            if (!mc.theWorld.getLoadedEntityList().contains(e)) {
                return;
            }
            EntityLivingBase en = (EntityLivingBase) e;
            int n = (int) en.getHealth() * 100 / (int) en.getMaxHealth();
            float hX = Main.getMain.renderer2d.getHighestX(e);
            float lX = Main.getMain.renderer2d.getLowestX(e);
            float hY = Main.getMain.renderer2d.getHighestY(e);
            float lY = Main.getMain.renderer2d.getLowestY(e);
            float xDiff = hX - lX;
            float yDiff = hY - lY;
            ScaledResolution sr = new ScaledResolution();
            if (hX > 0 && lX < sr.getScaledWidth() && hY > 0 && lY < sr.getScaledHeight()) {
                if (hY - yDiff < 0 && lY + yDiff > sr.getScaledHeight() || hX - xDiff < 0 && lX + xDiff > sr.getScaledHeight()) {
                //    Main.getMain.cmdManager.sendChatMessage(xDiff + " X  ------ " + yDiff + " Y");
                    return;
                }
                double scale = mc.thePlayer.getDistanceToEntity(e);
                if(scale > 2){
                    scale = 2;
                }
                yDiff *= scale;
                xDiff *= scale;
                hX *= scale;
                lX *= scale;
                hY *= scale;
                lY *= scale;

                GL11.glScaled(1 / scale, 1 / scale, 1 / scale);
                GL11.glColor3f(0, 0, 0);
                GuiApi.drawRect(lX - 3, lY - 1, lX + 1, lY + yDiff / 3.5 + 1, 0xff000000);
                GuiApi.drawRect(hX - 1, lY - 1, hX + 3, lY + yDiff / 3.5 + 1, 0xff000000);
                GuiApi.drawRect(lX - 3, hY - yDiff / 3.5 - 1, lX + 1, hY + 1, 0xff000000);
                GuiApi.drawRect(hX - 1, hY - yDiff / 3.5 - 1, hX + 3, hY + 1, 0xff000000);
                GuiApi.drawRect(lX, hY - 3, lX + xDiff / 3.5 + 1, hY + 1, 0xff000000);
                GuiApi.drawRect(hX - xDiff / 3.5 - 1, hY - 3, hX, hY + 1, 0xff000000);
                GuiApi.drawRect(lX, lY - 1, lX + xDiff / 3.5 + 1, lY + 3, 0xff000000);
                GuiApi.drawRect(hX - xDiff / 3.5 - 1, lY - 1, hX, lY + 3, 0xff000000);
                GuiApi.drawRect(lX - 2, lY, lX, lY + yDiff / 3.5, Main.getMain.getClientColor().getRGB());
                GuiApi.drawRect(hX, lY, hX + 2, lY + yDiff / 3.5, Main.getMain.getClientColor().getRGB());
                GuiApi.drawRect(lX - 2, hY - yDiff / 3.5, lX, hY, Main.getMain.getClientColor().getRGB());
                GuiApi.drawRect(hX, hY - yDiff / 3.5, hX + 2, hY, Main.getMain.getClientColor().getRGB());
                GuiApi.drawRect(lX, hY - 2, lX + xDiff / 3.5, hY, Main.getMain.getClientColor().getRGB());
                GuiApi.drawRect(hX - xDiff / 3.5, hY - 2, hX, hY, Main.getMain.getClientColor().getRGB());
                GuiApi.drawRect(lX, lY, lX + xDiff / 3.5, lY + 2, Main.getMain.getClientColor().getRGB());
                GuiApi.drawRect(hX - xDiff / 3.5, lY, hX, lY + 2, Main.getMain.getClientColor().getRGB());
                GL11.glScaled(scale, scale, scale);
            }

        }



    }
}

minecraft_de_Client_Main_Modules_mods_Render_FullBright.java

package de.Client.Main.Modules.mods.Render;

import de.Client.Main.Modules.Category;
import de.Client.Main.Modules.Module;

public class FullBright extends Module {

	public FullBright() {
		super("FullBright", Category.RENDER, 0);
		// TODO Auto-generated constructor stub
	}
	
	public void onEnable(){
		if(mc.gameSettings.gammaSetting <= 100){
			mc.gameSettings.gammaSetting += 10;
		}
		
		
	}
	
	@Override
	public boolean isModuleImportant(){
		return false;
	}
	
	public void onDisable(){
		if(mc.gameSettings.gammaSetting - 10 >= 0){
			mc.gameSettings.gammaSetting -= 10;
		}
	}
	
}

minecraft_de_Client_Main_Modules_mods_Render_Gui.java

package de.Client.Main.Modules.mods.Render;

import de.Client.Main.Main;
import de.Client.Main.Modules.Category;
import de.Client.Main.Modules.Module;
import de.Client.Render.StaticClickGui.MainPanel;
import org.lwjgl.input.Keyboard;

public class Gui extends Module {

	public Gui() {
		super("Gui", Category.None, Keyboard.KEY_G);
	}
	@Override
	public void onEnable(){
		mc.displayGuiScreen(Main.getMain.getClickGui);
    //    mc.displayGuiScreen(new MainPanel());
		this.toggleModule();
	}
	

}

minecraft_de_Client_Main_Modules_mods_Render_Hurtcam.java

package de.Client.Main.Modules.mods.Render;

/**
 * Created by Daniel on 06.10.2017.
 */
public class Hurtcam {
}

minecraft_de_Client_Main_Modules_mods_Render_Nametags.java

package de.Client.Main.Modules.mods.Render;

import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;

import com.mojang.realmsclient.gui.ChatFormatting;
import de.Client.Events.EventTarget;
import de.Client.Events.Events.EventRenderScreen;
import de.Client.Main.Main;
import de.Client.Main.Modules.Category;
import de.Client.Main.Modules.Module;
import de.Client.Render.GuiApi;
import de.Client.Utils.ColorUtil;
import de.Client.Utils.FriendManager;
import de.Client.Utils.RayTraceUtils;
import de.Client.Utils.RenderAPI2d;
import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.*;
import net.minecraft.client.renderer.*;
import net.minecraft.client.renderer.entity.RenderManager;
import net.minecraft.client.renderer.vertex.DefaultVertexFormats;
import net.minecraft.client.renderer.vertex.VertexBuffer;
import net.minecraft.enchantment.Enchantment;
import net.minecraft.enchantment.EnchantmentHelper;
import net.minecraft.entity.Entity;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.entity.monster.EntityCreeper;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.init.Items;
import net.minecraft.item.*;
import net.minecraft.nbt.NBTTagList;
import net.minecraft.util.EnumChatFormatting;
import net.minecraft.util.StringUtils;
import net.minecraft.util.Vec3;
import optifine.Reflector;
import optifine.ReflectorForge;
import org.lwjgl.BufferUtils;
import org.lwjgl.opengl.Display;
import org.lwjgl.opengl.GL11;
import org.lwjgl.util.glu.GLU;

import java.awt.*;
import java.nio.FloatBuffer;
import java.nio.IntBuffer;
import java.text.DecimalFormat;
import java.util.*;
import java.util.List;
import java.util.regex.Pattern;

public class Nametags extends Module {

    public Nametags() {
        super("Nametags", Category.RENDER, 0);
        // TODO Auto-generated constructor stub
    }
    public void onRender()
    {

        try{

            for (Object o : mc.theWorld.playerEntities) {
                if(!((Entity) o).isInvisible()){

                    EntityPlayer p = (EntityPlayer)o;
                    if (!p.isEntityAlive()) continue;
                    if(!(p == mc.thePlayer && !p.isInvisible())){
                        mc.getRenderManager();
                        double pX = p.lastTickPosX + (p.posX - p.lastTickPosX) * (double)mc.timer.renderPartialTicks - RenderManager.renderPosX;
                        mc.getRenderManager();
                        double pY = p.lastTickPosY + (p.posY - p.lastTickPosY) * (double)mc.timer.renderPartialTicks - RenderManager.renderPosY;
                        mc.getRenderManager();
                        double pZ = p.lastTickPosZ + (p.posZ - p.lastTickPosZ) * (double)mc.timer.renderPartialTicks - RenderManager.renderPosZ;
                        if(p instanceof EntityPlayer) {

                            this.renderNameTag(p, (float)pX, (float)pY, (float)pZ,1);
                            // this.renderNameTag(player, x, y, z, delta);

                        }

                        GL11.glColor3f((float)1.0f, (float)1.0f, (float)1.0f);

                    }
                }
            }
        }catch(Exception dewdw){

        }
        //}

    }


    private void drawEnchantTag(String text, int x, int y)
    {
        GlStateManager.pushMatrix();
        GlStateManager.disableDepth();
        x = (int)(x * 1.75D);
        y -= 4;
        GL11.glScaled(0.57F, 0.57F, 0.57F);
        mc.fontRendererObj.drawString(text, x, -36 - y, -1);
        GlStateManager.enableDepth();
        GlStateManager.popMatrix();
    }

    private void renderNameTag(EntityPlayer player, double x, double y, double z, float delta)
    {
        double tempY = y;
        tempY += (player.isSneaking() ? 0.5D : 0.7D);

        Entity camera = mc.func_175606_aa();
        double originalPositionX = camera.posX;
        double originalPositionY = camera.posY;
        double originalPositionZ = camera.posZ;
        camera.posX = interpolate(camera.prevPosX, camera.posX, delta);
        camera.posY = interpolate(camera.prevPosY, camera.posY, delta);
        camera.posZ = interpolate(camera.prevPosZ, camera.posZ, delta);

        double distance = camera.getDistance(x + mc.getRenderManager().viewerPosX, y + mc.getRenderManager().viewerPosY, z +
                mc.getRenderManager().viewerPosZ);
        int width =(int) (mc.fontRendererObj.getStringWidth(getDisplayName(player)) / 2);

        double scale = 0.0038D * distance;
        if (distance <= 5.0D) {
            scale = 0.0195D;
        }
        scale *= 0.87;

        GlStateManager.pushMatrix();
        RenderHelper.enableStandardItemLighting();
        GlStateManager.enablePolygonOffset();
        GlStateManager.doPolygonOffset(1.0F, -1500000.0F);
        GlStateManager.disableLighting();
        GlStateManager.translate((float)x, (float)tempY + 1.4F, (float)z);
        GlStateManager.rotate(-mc.getRenderManager().playerViewY, 0.0F, 1.0F, 0.0F);
        GlStateManager.rotate(mc.getRenderManager().playerViewX, mc.gameSettings.thirdPersonView == 2 ? -1.0F : 1.0F, 0.0F, 0.0F);

        GlStateManager.scale(-scale, -scale, scale);
        GlStateManager.disableDepth();
        GlStateManager.enableBlend();

        GlStateManager.disableAlpha();
        GuiApi.drawRect((int)(-width - 2)-1, (int)(-(mc.fontRendererObj.FONT_HEIGHT + 1))-1, (int)(width + 2.0F)+1, (int) 1.0+1 , ColorUtil.transparency(Color.black,0.2));
            GuiApi.drawRect((int)(-width - 2), (int)(-(mc.fontRendererObj.FONT_HEIGHT + 1)), (int)(width + 2.0F), (int) 1.0 , ColorUtil.transparency(Color.black,0.5));

        GlStateManager.enableAlpha();
        mc.fontRendererObj.drawStringWithShadow(getDisplayName(player), -width, -(mc.fontRendererObj.FONT_HEIGHT - 1),
       // Main.getMain.verdanas.drawStringWithShadow(getDisplayName(player), -width, -(mc.fontRendererObj.FONT_HEIGHT - 1),
                getDisplayColour(player));
        if (true)
        {
            GlStateManager.pushMatrix();
            int xOffset = 0;
            for (int index = 3; index >= 0; index--)
            {
                ItemStack stack = player.inventory.armorInventory[index];
                if (stack != null) {
                    xOffset -= 8;
                }
            }
            if (player.getHeldItem() != null)
            {
                xOffset -= 8;
                ItemStack renderStack = player.getHeldItem().copy();
                if ((renderStack.hasEffect()) && (
                        ((renderStack.getItem() instanceof ItemTool)) || ((renderStack.getItem() instanceof ItemArmor)))) {
                    renderStack.stackSize = 1;
                }
                renderItemStack(renderStack, xOffset, -26);
                xOffset += 16;
            }
            for (int index = 3; index >= 0; index--)
            {
                ItemStack stack = player.inventory.armorInventory[index];
                if (stack != null)
                {
                    ItemStack armourStack = stack.copy();
                    if ((armourStack.hasEffect()) && (((armourStack.getItem() instanceof ItemTool)) ||
                            ((armourStack.getItem() instanceof ItemArmor)))) {
                        armourStack.stackSize = 1;
                    }
                    renderItemStack(armourStack, xOffset, -26);
                    xOffset += 16;
                }
            }
            GlStateManager.popMatrix();
        }
        camera.posX = originalPositionX;
        camera.posY = originalPositionY;
        camera.posZ = originalPositionZ;

        GlStateManager.enableDepth();
        GlStateManager.disableBlend();
        GlStateManager.disablePolygonOffset();
        GlStateManager.doPolygonOffset(1.0F, 1500000.0F);
        GlStateManager.popMatrix();
    }

    private void renderItemStack(ItemStack stack, int x, int y)
    {

        GlStateManager.pushMatrix();
        GlStateManager.depthMask(true);
        GlStateManager.clear(256);

        RenderHelper.enableStandardItemLighting();
        mc.getRenderItem().zLevel = -150.0F;

        GlStateManager.disableLighting();
        GlStateManager.disableDepth();
        GlStateManager.disableBlend();
        GlStateManager.enableLighting();
        GlStateManager.enableDepth();
        GlStateManager.disableLighting();
        GlStateManager.disableDepth();
        GlStateManager.disableAlpha();
        GlStateManager.disableAlpha();
        GlStateManager.disableBlend();
        GlStateManager.enableBlend();
        GlStateManager.enableAlpha();
        GlStateManager.enableAlpha();
        GlStateManager.enableLighting();
        GlStateManager.enableDepth();

        mc.getRenderItem().func_180450_b(stack, x, y);

        mc.getRenderItem().zLevel = 0.0F;
        RenderHelper.disableStandardItemLighting();

        GlStateManager.disableCull();
        GlStateManager.enableAlpha();
        GlStateManager.disableBlend();
        GlStateManager.disableLighting();
        GlStateManager.scale(0.5F, 0.5F, 0.5F);
        GlStateManager.disableDepth();
        renderEnchantmentText(stack, x, y);
        GlStateManager.enableDepth();
        GlStateManager.scale(2.0F, 2.0F, 2.0F);
        GlStateManager.popMatrix();
    }
    private void renderEnchantmentText(ItemStack stack, int x, int y)
    {
        int enchantmentY = y - 24;
        if ((stack.getEnchantmentTagList() != null) && (stack.getEnchantmentTagList().tagCount() >= 6))
        {
            mc.fontRendererObj.drawStringWithShadow("god", x * 2, enchantmentY, -3977919);
            return;
        }
        int color = -5592406;
        if ((stack.getItem() instanceof ItemArmor))
        {
            int protectionLevel =  EnchantmentHelper.getEnchantmentLevel(Enchantment.field_180310_c.effectId, stack);
            int projectileProtectionLevel =  EnchantmentHelper.getEnchantmentLevel(Enchantment.field_180308_g.effectId, stack);

            int blastProtectionLevel =  EnchantmentHelper.getEnchantmentLevel(Enchantment.blastProtection.effectId, stack);

            int fireProtectionLevel =  EnchantmentHelper.getEnchantmentLevel(Enchantment.fireProtection.effectId, stack);
            int thornsLevel = EnchantmentHelper.getEnchantmentLevel(Enchantment.thorns.effectId, stack);
            int featherFallingLevel = EnchantmentHelper.getEnchantmentLevel(Enchantment.field_180309_e.effectId, stack);
            if (protectionLevel > 0)
            {
                mc.fontRendererObj.drawStringWithShadow("pr" + protectionLevel, x * 2, enchantmentY, color);
                enchantmentY += 8;
            }
            if (projectileProtectionLevel > 0)
            {
                mc.fontRendererObj.drawStringWithShadow("pp" + projectileProtectionLevel, x * 2, enchantmentY, color);
                enchantmentY += 8;
            }
            if (blastProtectionLevel > 0)
            {
                mc.fontRendererObj.drawStringWithShadow("bp" + blastProtectionLevel, x * 2, enchantmentY, color);
                enchantmentY += 8;
            }
            if (fireProtectionLevel > 0)
            {
                mc.fontRendererObj.drawStringWithShadow("fp" + fireProtectionLevel, x * 2, enchantmentY, color);
                enchantmentY += 8;
            }
            if (thornsLevel > 0)
            {
                mc.fontRendererObj.drawStringWithShadow("tho" + thornsLevel, x * 2, enchantmentY, color);
                enchantmentY += 8;
            }
            if (featherFallingLevel > 0)
            {
                mc.fontRendererObj.drawStringWithShadow("ff" + featherFallingLevel, x * 2, enchantmentY, color);
                enchantmentY += 8;
            }
        }
        if ((stack.getItem() instanceof ItemBow))
        {
            int powerLevel =  EnchantmentHelper.getEnchantmentLevel(Enchantment.power.effectId, stack);
            int punchLevel =  EnchantmentHelper.getEnchantmentLevel(Enchantment.punch.effectId, stack);
            int flameLevel =  EnchantmentHelper.getEnchantmentLevel(Enchantment.flame.effectId, stack);
            if (powerLevel > 0)
            {
                mc.fontRendererObj.drawStringWithShadow("po" + powerLevel, x * 2, enchantmentY, color);
                enchantmentY += 8;
            }
            if (punchLevel > 0)
            {
                mc.fontRendererObj.drawStringWithShadow("pu" + punchLevel, x * 2, enchantmentY, color);
                enchantmentY += 8;
            }
            if (flameLevel > 0)
            {
                mc.fontRendererObj.drawStringWithShadow("fl" + flameLevel, x * 2, enchantmentY, color);
                enchantmentY += 8;
            }
        }
        if ((stack.getItem() instanceof ItemSword))
        {
            int sharpnessLevel = EnchantmentHelper.getEnchantmentLevel(Enchantment.field_180314_l.effectId, stack);
            int knockbackLevel = EnchantmentHelper.getEnchantmentLevel(Enchantment.field_180313_o.effectId, stack);
            int fireAspectLevel =  EnchantmentHelper.getEnchantmentLevel(Enchantment.fireAspect.effectId, stack);
            if (sharpnessLevel > 0)
            {
                mc.fontRendererObj.drawStringWithShadow("sh" + sharpnessLevel, x * 2, enchantmentY, color);
                enchantmentY += 8;
            }
            if (knockbackLevel > 0)
            {
                mc.fontRendererObj.drawStringWithShadow("kn" + knockbackLevel, x * 2, enchantmentY, color);
                enchantmentY += 8;
            }
            if (fireAspectLevel > 0)
            {
                mc.fontRendererObj.drawStringWithShadow("fa" + fireAspectLevel, x * 2, enchantmentY, color);
                enchantmentY += 8;
            }
        }
        if ((stack.getItem() == Items.golden_apple) && (stack.hasEffect())) {
            mc.fontRendererObj.drawStringWithShadow("god", x * 2, enchantmentY, -3977919);
        }
    }

    private String getDisplayName(EntityPlayer player)
    {
        String name = player.getDisplayName().getFormattedText();
        if(FriendManager.friends.containsKey(player.getName())){
              name = "§3"+FriendManager.friends.get(player.getName())[0];
        }
        if (name.contains(mc.getSession().getUsername())) {
            name = "You";
        }

        float health = player.getHealth();

        EnumChatFormatting color;
        if (health > 18.0F)
        {
            color = EnumChatFormatting.DARK_GREEN;
        }
        else
        {
            if (health > 16.0F)
            {
                color = EnumChatFormatting.GREEN;
            }
            else
            {

                if (health > 12.0F)
                {
                    color = EnumChatFormatting.YELLOW;
                }
                else
                {

                    if (health > 8.0F)
                    {
                        color = EnumChatFormatting.GOLD;
                    }
                    else
                    {

                        if (health > 5.0F) {
                            color = EnumChatFormatting.RED;
                        } else {
                            color = EnumChatFormatting.DARK_RED;
                        }
                    }
                }
            }
        }
        if (Math.floor(health) == health) {
            name = name + color + " " + (health > 0.0F ? (int)Math.floor(health * 5.0F) + "%" : "dead");
        } else {
            name = name + color + " " + (health > 0.0F ? (int)health * 5 + "%" : "dead");
        }
        return name;
    }

    private int getDisplayColour(EntityPlayer player)
    {
        int colour = -5592406;

        if (player.isInvisible()) {
            colour = -1113785;
        } else if (player.isSneaking()) {
            colour = -6481515;
        }
        return colour;
    }

    private double interpolate(double previous, double current, float delta)
    {
        return previous + (current - previous) * delta;
    }

    public enum EnumChatFormatting
    {
        BLACK("BLACK", '0', 0),
        DARK_BLUE("DARK_BLUE", '1', 1),
        DARK_GREEN("DARK_GREEN", '2', 2),
        DARK_AQUA("DARK_AQUA", '3', 3),
        DARK_RED("DARK_RED", '4', 4),
        DARK_PURPLE("DARK_PURPLE", '5', 5),
        GOLD("GOLD", '6', 6),
        GRAY("GRAY", '7', 7),
        DARK_GRAY("DARK_GRAY", '8', 8),
        BLUE("BLUE", '9', 9),
        GREEN("GREEN", 'a', 10),
        AQUA("AQUA", 'b', 11),
        RED("RED", 'c', 12),
        LIGHT_PURPLE("LIGHT_PURPLE", 'd', 13),
        YELLOW("YELLOW", 'e', 14),
        WHITE("WHITE", 'f', 15),
        OBFUSCATED("OBFUSCATED", 'k', true),
        BOLD("BOLD", 'l', true),
        STRIKETHROUGH("STRIKETHROUGH", 'm', true),
        UNDERLINE("UNDERLINE", 'n', true),
        ITALIC("ITALIC", 'o', true),
        RESET("RESET", 'r', -1);


        /**
         * Maps a name (e.g., 'underline') to its corresponding enum value (e.g., UNDERLINE).
         */
        private static final Map nameMapping = Maps.newHashMap();

        /**
         * Matches formatting codes that indicate that the client should treat the following text as bold, recolored,
         * obfuscated, etc.
         */
        private static final Pattern formattingCodePattern = Pattern.compile("(?i)" + String.valueOf('\u00a7') + "[0-9A-FK-OR]");
        private final String field_175748_y;

        /** The formatting code that produces this format. */
        private final char formattingCode;
        private final boolean fancyStyling;

        /**
         * The control string (section sign + formatting code) that can be inserted into client-side text to display
         * subsequent text in this format.
         */
        private final String controlString;
        private final int field_175747_C;
        private static final String __OBFID = "CL_00000342";

        private static String func_175745_c(String p_175745_0_)
        {
            return p_175745_0_.toLowerCase().replaceAll("[^a-z]", "");
        }

        private EnumChatFormatting(String p_i46291_3_, char p_i46291_4_, int p_i46291_5_)
        {
            this(p_i46291_3_, p_i46291_4_, false, p_i46291_5_);
        }

        private EnumChatFormatting(String p_i46292_3_, char p_i46292_4_, boolean p_i46292_5_)
        {
            this(p_i46292_3_, p_i46292_4_, p_i46292_5_, -1);
        }

        private EnumChatFormatting(String p_i46293_3_, char p_i46293_4_, boolean p_i46293_5_, int p_i46293_6_)
        {
            this.field_175748_y = p_i46293_3_;
            this.formattingCode = p_i46293_4_;
            this.fancyStyling = p_i46293_5_;
            this.field_175747_C = p_i46293_6_;
            this.controlString = "\u00a7" + p_i46293_4_;
        }

        public int func_175746_b()
        {
            return this.field_175747_C;
        }

        /**
         * False if this is just changing the color or resetting; true otherwise.
         */
        public boolean isFancyStyling()
        {
            return this.fancyStyling;
        }

        /**
         * Checks if this is a color code.
         */
        public boolean isColor()
        {
            return !this.fancyStyling && this != RESET;
        }

        /**
         * Gets the friendly name of this value.
         */
        public String getFriendlyName()
        {
            return this.name().toLowerCase();
        }

        public String toString()
        {
            return this.controlString;
        }

        /**
         * Returns a copy of the given string, with formatting codes stripped away.
         */
        public static String getTextWithoutFormattingCodes(String p_110646_0_)
        {
            return p_110646_0_ == null ? null : formattingCodePattern.matcher(p_110646_0_).replaceAll("");
        }

        /**
         * Gets a value by its friendly name; null if the given name does not map to a defined value.
         */
        public static EnumChatFormatting getValueByName(String p_96300_0_)
        {
            return p_96300_0_ == null ? null : (EnumChatFormatting)nameMapping.get(func_175745_c(p_96300_0_));
        }

        public static EnumChatFormatting func_175744_a(int p_175744_0_)
        {
            if (p_175744_0_ < 0)
            {
                return RESET;
            }
            else
            {
                EnumChatFormatting[] var1 = values();
                int var2 = var1.length;

                for (int var3 = 0; var3 < var2; ++var3)
                {
                    EnumChatFormatting var4 = var1[var3];

                    if (var4.func_175746_b() == p_175744_0_)
                    {
                        return var4;
                    }
                }

                return null;
            }
        }

        /**
         * Gets all the valid values. Args: @param par0: Whether or not to include color values. @param par1: Whether or not
         * to include fancy-styling values (anything that isn't a color value or the "reset" value).
         */
        public static Collection getValidValues(boolean p_96296_0_, boolean p_96296_1_)
        {
            ArrayList var2 = Lists.newArrayList();
            EnumChatFormatting[] var3 = values();
            int var4 = var3.length;

            for (int var5 = 0; var5 < var4; ++var5)
            {
                EnumChatFormatting var6 = var3[var5];

                if ((!var6.isColor() || p_96296_0_) && (!var6.isFancyStyling() || p_96296_1_))
                {
                    var2.add(var6.getFriendlyName());
                }
            }

            return var2;
        }

        static {
            EnumChatFormatting[] var0 = values();
            int var1 = var0.length;

            for (int var2 = 0; var2 < var1; ++var2)
            {
                EnumChatFormatting var3 = var0[var2];
                nameMapping.put(func_175745_c(var3.field_175748_y), var3);
            }
        }
    }

}

minecraft_de_Client_Main_Modules_mods_Render_NameTags2.java

package de.Client.Main.Modules.mods.Render;

import de.Client.Events.EventTarget;
import de.Client.Events.Events.EventRenderScreen;
import de.Client.Main.Main;
import de.Client.Main.Modules.Category;
import de.Client.Main.Modules.Module;
import de.Client.Main.Values.ValueBoolean;
import de.Client.Render.GuiApi;
import de.Client.Utils.ColorUtil;
import de.Client.Utils.FriendManager;
import de.Client.Utils.RenderAPI2d;
import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.ScaledResolution;
import net.minecraft.client.renderer.GlStateManager;
import net.minecraft.client.renderer.OpenGlHelper;
import net.minecraft.client.renderer.RenderHelper;
import net.minecraft.client.renderer.entity.RenderManager;
import net.minecraft.entity.Entity;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.init.Items;
import net.minecraft.item.ItemArmor;
import net.minecraft.item.ItemStack;
import net.minecraft.item.ItemTool;
import net.minecraft.util.ResourceLocation;
import org.lwjgl.input.Mouse;
import org.lwjgl.opengl.GL11;

import java.awt.*;
import java.util.ArrayList;
import java.util.HashMap;

/**
 * Created by Daniel on 27.08.2017.
 */
public class NameTags2 extends Module {

    public ValueBoolean renderEntity = new ValueBoolean("RenderEntity",true);
    public ValueBoolean nocollide = new ValueBoolean("nocollide",true);
    public EntityPlayer playerToRender;
    public ArrayList<float[]> nameTags= new ArrayList<float[]>();
    public NameTags2() {
        super("Nametags", Category.RENDER, 0);
        addValue(this.renderEntity);
        addValue(this.nocollide);
    }

    public static boolean mouse(int mouseX, int mouseY, double minX, double maxX, double minY, double maxY) {
        if((mouseX >= minX && mouseX <= maxX) && (mouseY >= minY && mouseY <= maxY)) {
            return true;
        }
        return false;
    }
    private void drawItem(ItemStack item, float x, float y) {
        if (item != null) {
            float var7 = (float) item.animationsToGo - Minecraft.getMinecraft().timer.renderPartialTicks;

            if (var7 > 0.0F) {
           //     GlStateManager.pushMatrix();
           //     float var8 = 1.0F + var7 / 5.0F;
           //     GlStateManager.translate((float) (x + 8), (float) (y + 12), 0.0F);
          //      GlStateManager.scale(1.0F / var8, (var8 + 1.0F) / 2.0F, 1.0F);
           //     GlStateManager.translate((float) (-(x + 8)), (float) (-(y + 12)), 0.0F);
            }

            Minecraft.getMinecraft().getRenderItem().func_180450_b_flat(item, x, y);

            if (var7 > 0.0F) {
           //     GlStateManager.popMatrix();
            }

            // Minecraft.getMinecraft().getRenderItem().func_175030_a2(this.mc.fontRendererObj, item, (int) x, (int) y);
        }
    }

    public static void drawEntityOnScreen(int p_147046_0_, int p_147046_1_, int p_147046_2_, float p_147046_3_, float p_147046_4_, EntityLivingBase p_147046_5_)
    {
        GlStateManager.enableColorMaterial();
        GlStateManager.pushMatrix();
        GlStateManager.translate((float)p_147046_0_, (float)p_147046_1_, 50.0F);
        GlStateManager.scale((float)(-p_147046_2_), (float)p_147046_2_, (float)p_147046_2_);
        GlStateManager.rotate(180.0F, 0.0F, 0.0F, 1.0F);
        float var6 = p_147046_5_.renderYawOffset;
        float var7 = p_147046_5_.rotationYaw;
        float var8 = p_147046_5_.rotationPitch;
        float var9 = p_147046_5_.prevRotationYawHead;
        float var10 = p_147046_5_.rotationYawHead;
        GlStateManager.rotate(135.0F, 0.0F, 1.0F, 0.0F);
        RenderHelper.enableStandardItemLighting();
        GlStateManager.rotate(-135.0F, 0.0F, 1.0F, 0.0F);
        GlStateManager.rotate(-((float)Math.atan((double)(p_147046_4_ / 40.0F))) * 20.0F, 1.0F, 0.0F, 0.0F);
        p_147046_5_.renderYawOffset = (float)Math.atan((double)(p_147046_3_ / 40.0F)) * 20.0F;
        p_147046_5_.rotationYaw = (float)Math.atan((double)(p_147046_3_ / 40.0F)) * 40.0F;
        p_147046_5_.rotationPitch = -((float)Math.atan((double)(p_147046_4_ / 40.0F))) * 20.0F;
        p_147046_5_.rotationYawHead = p_147046_5_.rotationYaw;
        p_147046_5_.prevRotationYawHead = p_147046_5_.rotationYaw;
        GlStateManager.translate(0.0F, 0.0F, 0.0F);
        RenderManager var11 = Minecraft.getMinecraft().getRenderManager();
        var11.func_178631_a(180.0F);
        var11.func_178633_a(false);
        var11.renderEntityWithPosYaw(p_147046_5_, 0.0D, 0.0D, 0.0D, 0.0F, 1.0F);
        var11.func_178633_a(true);
        p_147046_5_.renderYawOffset = var6;
        p_147046_5_.rotationYaw = var7;
        p_147046_5_.rotationPitch = var8;
        p_147046_5_.prevRotationYawHead = var9;
        p_147046_5_.rotationYawHead = var10;
        GlStateManager.popMatrix();
        RenderHelper.disableStandardItemLighting();
        GlStateManager.disableRescaleNormal();
        GlStateManager.setActiveTexture(OpenGlHelper.lightmapTexUnit);
        GlStateManager.func_179090_x();
        GlStateManager.setActiveTexture(OpenGlHelper.defaultTexUnit);
    }
    public boolean isRectInRectOther(double x, double y, double width, double height, double x2, double y2, double width2, double height2) {
        if(x2 <= (width)) {
            if((width2) >= x) {
                if((y2) <= (height)) {
                    if((height2) >= y) {
                        return true;
                    }
                }
            }
        }
        return false;
    }
    @EventTarget
    public void on2D(EventRenderScreen screen) {
        ScaledResolution sr = new ScaledResolution();
        Main.getMain.renderer2d.shouldConvert2d = true;
        playerToRender = null;
        nameTags.clear();
        for (Entity e : Main.getMain.renderer2d.upperPos1.keySet()) {
            if(!mc.theWorld.getLoadedEntityList().contains(e)){
                return;
            }
            float x = (Main.getMain.renderer2d.upperPos1.get(e)[0] + Main.getMain.renderer2d.upperPos2.get(e)[0] + Main.getMain.renderer2d.upperPos3.get(e)[0] + Main.getMain.renderer2d.upperPos4.get(e)[0]) / 4.0f;
            float lY = Main.getMain.renderer2d.getLowestY(e);
            float y = lY > 0 ? lY - 12 : -99;
            if(y == -99|| lY > sr.getScaledHeight() || x < -10 || x > sr.getScaledWidth()+10){
            //    Main.getMain.cmdManager.sendChatMessage(e.getName() + " Skip because not onscreen");
            }else {
                y-=4;
                int health = (int) (((EntityPlayer) e).getHealth() / ((EntityPlayer) e).getMaxHealth() * 100);
                String name = " " + health + "%";
                // System.out.println(ColorUtil.transparency(new Color(0x801F1F1F),0.8));

                float n = health;

                int R = (int) ((255 * (100 - n)) / 100);
                int G = (int) ((255 * n) / 100);
                int B = 0;
                float xOffset = -5f;
                Minecraft.getMinecraft().getTextureManager().bindTexture(new ResourceLocation("textures/gui/options_background.png"));
                if(!nocollide.getValue()) {
                    if (!renderEntity.getValue()) {
                        String playerName = FriendManager.friends.containsKey(e.getName()) ? FriendManager.friends.get(e.getName())[0] : e.getName();
                        GuiApi.drawBorderRectNoCorners(x - Main.getMain.verdanas.getWidth(playerName) / 2 - Main.getMain.verdanas.getWidth(name) / 2, y + 2, x + Main.getMain.verdanas.getWidth(playerName) / 2 + Main.getMain.verdanas.getWidth(name) / 2, y + 14, -870375649, -870375649);
                        Main.getMain.verdanas.drawCenteredStringWithShadow(playerName, x - Main.getMain.verdanas.getWidth(name) / 2, y, ColorUtil.getTeamColor(e).getRGB());
                        Main.getMain.verdanas.drawCenteredStringWithShadow(name, x + Main.getMain.verdanas.getWidth(playerName) / 2, y, new Color(R, G, B).getRGB());
                    } else {

                        String playerName = FriendManager.friends.containsKey(e.getName()) ? FriendManager.friends.get(e.getName())[0] : e.getName();
                        boolean isOverNametag = playerToRender == null && mouse(sr.getScaledWidth() / 2, sr.getScaledHeight() / 2, x - Main.getMain.verdanas.getWidth(playerName) / 2 - Main.getMain.verdanas.getWidth(name) / 2, x + Main.getMain.verdanas.getWidth(playerName) / 2 + Main.getMain.verdanas.getWidth(name) / 2, y + 2, y + 14);
                        if (!isOverNametag) {
                            GuiApi.drawBorderRectNoCorners(x - Main.getMain.verdanas.getWidth(playerName) / 2 - Main.getMain.verdanas.getWidth(name) / 2, y + 2, x + Main.getMain.verdanas.getWidth(playerName) / 2 + Main.getMain.verdanas.getWidth(name) / 2, y + 14, -870375649, -870375649);
                        } else {
                            playerToRender = (EntityPlayer) e;
                            GuiApi.drawBorderRectNoCorners(x - Main.getMain.verdanas.getWidth(playerName) / 2 - Main.getMain.verdanas.getWidth(name) / 2, y + 2, x + Main.getMain.verdanas.getWidth(playerName) / 2 + Main.getMain.verdanas.getWidth(name) / 2, y + 14, Main.getMain.clientColor.getRGB(), -870375649);
                        }

                        Main.getMain.verdanas.drawCenteredStringWithShadow(playerName, x - Main.getMain.verdanas.getWidth(name) / 2, y, isOverNametag ? Main.getMain.clientColor.getRGB() : ColorUtil.getTeamColor(e).getRGB());
                        Main.getMain.verdanas.drawCenteredStringWithShadow(name, x + Main.getMain.verdanas.getWidth(playerName) / 2, y, new Color(R, G, B).getRGB());

                    }
                }else{
                    if (!renderEntity.getValue()) {

                        String playerName = FriendManager.friends.containsKey(e.getName()) ? FriendManager.friends.get(e.getName())[0] : e.getName();
                        double yOffset = 0;

                        double minX = x - Main.getMain.verdanas.getWidth(playerName) / 2 - Main.getMain.verdanas.getWidth(name) / 2;
                        double maxX = x + Main.getMain.verdanas.getWidth(playerName) / 2 + Main.getMain.verdanas.getWidth(name) / 2;
                        double minY = y + 2;
                        double maxY = y + 14;
                        for(float[] nametags : this.nameTags) {
                            if(maxX < nametags[0]){
                        //        Main.getMain.cmdManager.sendChatMessage("MAX X SMALLER THAN LOWEST X");
                            }else{
                                if(minX > nametags[1]){
                               //     Main.getMain.cmdManager.sendChatMessage("MIN X BIGGER THAN LOWEST X");
                                }else{
                                    if(maxY < nametags[2]){
                                  //      Main.getMain.cmdManager.sendChatMessage("MAX Y SMALLER THAN LOWEST Y");
                                    }else{
                                        if(minY > nametags[3]){
                                     //       Main.getMain.cmdManager.sendChatMessage("MIN Y BIGGER THAN LOWEST Y");
                                        }else{
                                        //    Main.getMain.cmdManager.sendChatMessage("test");
                                           y = nametags[3]+13;
                                        }
                                    }
                                }
                            }
                        }

                        GuiApi.drawBorderRectNoCorners(x - Main.getMain.verdanas.getWidth(playerName) / 2 - Main.getMain.verdanas.getWidth(name) / 2, y + 2, x + Main.getMain.verdanas.getWidth(playerName) / 2 + Main.getMain.verdanas.getWidth(name) / 2, y + 14, -870375649, -870375649);
                        Main.getMain.verdanas.drawCenteredStringWithShadow(playerName, x - Main.getMain.verdanas.getWidth(name) / 2, y, ColorUtil.getTeamColor(e).getRGB());
                        Main.getMain.verdanas.drawCenteredStringWithShadow(name, x + Main.getMain.verdanas.getWidth(playerName) / 2, y, new Color(R, G, B).getRGB());
                        this.nameTags.add(new float[]{x - Main.getMain.verdanas.getWidth(playerName) / 2 - Main.getMain.verdanas.getWidth(name) / 2,x + Main.getMain.verdanas.getWidth(playerName) / 2 + Main.getMain.verdanas.getWidth(name) / 2,y+2,y+14});
                    } else {

                        String playerName = FriendManager.friends.containsKey(e.getName()) ? FriendManager.friends.get(e.getName())[0] : e.getName();
                        boolean isOverNametag = playerToRender == null && mouse(sr.getScaledWidth() / 2, sr.getScaledHeight() / 2, x - Main.getMain.verdanas.getWidth(playerName) / 2 - Main.getMain.verdanas.getWidth(name) / 2, x + Main.getMain.verdanas.getWidth(playerName) / 2 + Main.getMain.verdanas.getWidth(name) / 2, y + 2, y + 14);
                        if (!isOverNametag) {
                            GuiApi.drawBorderRectNoCorners(x - Main.getMain.verdanas.getWidth(playerName) / 2 - Main.getMain.verdanas.getWidth(name) / 2, y + 2, x + Main.getMain.verdanas.getWidth(playerName) / 2 + Main.getMain.verdanas.getWidth(name) / 2, y + 14, -870375649, -870375649);
                        } else {
                            playerToRender = (EntityPlayer) e;
                            GuiApi.drawBorderRectNoCorners(x - Main.getMain.verdanas.getWidth(playerName) / 2 - Main.getMain.verdanas.getWidth(name) / 2, y + 2, x + Main.getMain.verdanas.getWidth(playerName) / 2 + Main.getMain.verdanas.getWidth(name) / 2, y + 14, Main.getMain.clientColor.getRGB(), -870375649);
                        }

                        Main.getMain.verdanas.drawCenteredStringWithShadow(playerName, x - Main.getMain.verdanas.getWidth(name) / 2, y, isOverNametag ? Main.getMain.clientColor.getRGB() : ColorUtil.getTeamColor(e).getRGB());
                        Main.getMain.verdanas.drawCenteredStringWithShadow(name, x + Main.getMain.verdanas.getWidth(playerName) / 2, y, new Color(R, G, B).getRGB());

                    }
                }
             //   Main.getMain.cmdManager.sendChatMessage("test");
                Minecraft.getMinecraft().getTextureManager().bindTexture(new ResourceLocation("textures/gui/options_background.png"));
                for(ItemStack s : ((EntityPlayer) e).inventory.armorInventory){
                    if(s != null) {
                        xOffset -= 5;

                    }
                }
                for(ItemStack s : ((EntityPlayer) e).inventory.mainInventory){
                    if(s != null) {
                        xOffset -= 5;
                    }
                }

                for(ItemStack s : ((EntityPlayer) e).inventory.mainInventory){
                    if(s != null) {
                        drawItem(s,  x + xOffset,y - 12);
                        //Main.getMain.cmdManager.sendChatMessage(e.getName() + s);
                        xOffset += 10;
                    }
                }
                for(ItemStack s : ((EntityPlayer) e).inventory.armorInventory){
                    if(s != null) {
                        drawItem(s,  x + xOffset,y - 12);
                        xOffset += 10;
                    }
                }
            }
        }
        if(playerToRender != null){
            GL11.glColor3f(100,100,100);
        //    GL11.glRotated(mc.thePlayer.ticksExisted,0,1 ,0);
            drawEntityOnScreen(30,200,45,playerToRender.rotationPitch,playerToRender.rotationYaw,playerToRender);
           // GL11.glRotated(mc.thePlayer.ticksExisted,0,1 ,0);
        }
    }
}

minecraft_de_Client_Main_Modules_mods_Render_Xray.java

package de.Client.Main.Modules.mods.Render;


import de.Client.Main.Modules.Category;
import de.Client.Main.Modules.Module;

public class Xray extends Module {

	public Xray() {
		super("Xray", Category.RENDER,0);
	}
	@Override
	public void onToggle(){
		if(mc.theWorld != null){
		mc.renderGlobal.loadRenderers();
		}
	}
	
	
	
	
}

minecraft_de_Client_Main_Modules_mods_World_AntiBots.java

package de.Client.Main.Modules.mods.World;

import de.Client.Main.Modules.Category;
import de.Client.Main.Modules.Module;
import de.Client.Main.Values.ValueBoolean;
import net.minecraft.entity.Entity;

import java.util.ArrayList;

public class AntiBots extends Module{
	
	public AntiBots() {
		super("Antibots", Category.WORLD, 0);
		// TODO Auto-generated constructor stub
		addValue(this.invisibles);
		addValue(this.hypixel);
		displayName = "Anti Bots";
	}

	public ValueBoolean invisibles = new ValueBoolean("Invisibles",true);
	public ValueBoolean hypixel = new ValueBoolean("Hypixel",false);

	
	public boolean filterEntity(Entity e){
		if(this.invisibles.getValue()){
			if(e.isInvisible()){
				return false;
			}
		}
		if(this.hypixel.getValue()){
			if(e.hasCustomName()){
			if(e.getCustomNameTag().replace("§", "$").startsWith("$c")){
				return false;
			}
			}
		}
		return true;
	}
	
	public ArrayList<Entity> goodEntities(){
		ArrayList goodEntities = new ArrayList<Entity>();
		for(int i = 0; i < mc.theWorld.loadedEntityList.size();++i){
			Entity e = (Entity) mc.theWorld.loadedEntityList.get(i);
			if(e != mc.thePlayer){

			
			if(filterEntity(e)) {
                goodEntities.add(e);

		}
			}
		}
		return goodEntities;
	}
	


}

minecraft_de_Client_Main_Modules_mods_World_AutoFish.java

package de.Client.Main.Modules.mods.World;

import de.Client.Events.EventTarget;
import de.Client.Events.Events.PacketReceiveEvent;
import de.Client.Main.Main;
import de.Client.Main.Modules.Category;
import de.Client.Main.Modules.Module;
import de.Client.Utils.Macro;
import net.minecraft.client.entity.EntityPlayerSP;
import net.minecraft.client.network.NetworkPlayerInfo;
import net.minecraft.entity.Entity;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.ItemFishingRod;
import net.minecraft.network.play.client.C02PacketUseEntity;
import net.minecraft.network.play.client.C03PacketPlayer;
import net.minecraft.network.play.client.C08PacketPlayerBlockPlacement;
import net.minecraft.network.play.server.S0CPacketSpawnPlayer;
import net.minecraft.network.play.server.S18PacketEntityTeleport;
import org.lwjgl.Sys;
import org.lwjgl.input.Controller;
import org.lwjgl.input.Controllers;
import org.lwjgl.input.Keyboard;

import java.util.ArrayList;



public class AutoFish extends Module {

    public AutoFish() {
        super("AutoFish", Category.WORLD, Keyboard.KEY_Y);
        // TODO Auto-generated constructor stub
    }

    @Override
    public void onUpdate() {
        if (mc.thePlayer.getCurrentEquippedItem() == null) {
            return;
        }


        if (mc.thePlayer.ticksExisted % 4 == 2) {
            if (mc.thePlayer.getCurrentEquippedItem().getItem() instanceof ItemFishingRod) {
             //   mc.thePlayer.fishEntit
                if (mc.thePlayer.fishEntity != null) {
                    Main.getMain.cmdManager.sendChatMessage(mc.thePlayer.fishEntity.fishPitch +"");
                    if (mc.thePlayer.fishEntity.fishPitch  < -30) {
                        mc.thePlayer.sendQueue.addToSendQueue(new C08PacketPlayerBlockPlacement(mc.thePlayer.getCurrentEquippedItem()));
                    }
                } else {
                    mc.thePlayer.swingItem();
                    mc.thePlayer.sendQueue.addToSendQueue(new C08PacketPlayerBlockPlacement(mc.thePlayer.getCurrentEquippedItem()));
                }
            }
        }
    }

    @Override
    public boolean isModuleImportant(){
        return false;
    }


}

minecraft_de_Client_Main_Modules_mods_World_Civbreak.java

package de.Client.Main.Modules.mods.World;

import de.Client.Main.Modules.Category;
import de.Client.Main.Modules.Module;
import org.lwjgl.opengl.GL11;
import net.minecraft.client.Minecraft;
import net.minecraft.client.multiplayer.PlayerControllerMP;
import net.minecraft.client.renderer.entity.RenderManager;
import net.minecraft.init.Blocks;
import net.minecraft.network.play.client.C07PacketPlayerDigging;
import net.minecraft.util.BlockPos;
import net.minecraft.util.EnumFacing;

public class Civbreak extends Module {

    public BlockPos pos;
    public Civbreak() {
        super("CivBreak", Category.WORLD,0);

    }
    public void onEnable(){
        this.pos = null;
    }


    @Override
    public void onUpdate() {


        if(mc.gameSettings.keyBindAttack.pressed){
            pos = mc.objectMouseOver.func_178782_a();
        }


        if(!(pos == null )){
            if(!(mc.theWorld.getBlockState(pos).getBlock() == Blocks.air)){
                mc.thePlayer.swingItem();
                mc.thePlayer.sendQueue.addToSendQueue(new C07PacketPlayerDigging(
                        C07PacketPlayerDigging.Action.STOP_DESTROY_BLOCK,pos, EnumFacing.DOWN));
                mc.thePlayer.swingItem();
                mc.thePlayer.sendQueue.addToSendQueue(new C07PacketPlayerDigging(
                        C07PacketPlayerDigging.Action.STOP_DESTROY_BLOCK,pos, EnumFacing.DOWN));
                mc.thePlayer.swingItem();
                mc.thePlayer.sendQueue.addToSendQueue(new C07PacketPlayerDigging(
                        C07PacketPlayerDigging.Action.STOP_DESTROY_BLOCK,pos, EnumFacing.DOWN));
                mc.thePlayer.swingItem();
            }
        }
    }

}

minecraft_de_Client_Main_Modules_mods_World_Fucker.java

package de.Client.Main.Modules.mods.World;

import de.Client.Main.Modules.Category;
import de.Client.Main.Modules.Module;
import de.Client.Main.Values.ValueBoolean;
import de.Client.Main.Values.ValueDouble;
import de.Client.Render.ClickGui.Panels.Mini;
import de.Client.Render.ClickGui.Panels.Minitypes.MiniOneOfTwo;
import de.Client.Render.ClickGui.Panels.Minitypes.MiniValueBooleanToggleSimple;
import de.Client.Utils.TimeHelper;
import net.minecraft.block.Block;
import net.minecraft.init.Blocks;
import net.minecraft.network.play.client.C03PacketPlayer;
import net.minecraft.network.play.client.C07PacketPlayerDigging;
import net.minecraft.util.BlockPos;
import net.minecraft.util.EnumFacing;
import org.lwjgl.input.Keyboard;

import java.util.ArrayList;

public class Fucker extends Module {

    public ValueDouble range = new ValueDouble("Range",10,10,10);
    public ValueDouble id = new ValueDouble("id",26,26,26);
    public Block blockToFuck = Blocks.bed;
    public ValueBoolean AACTeleport = new  ValueBoolean("AACTeleport", true);
    public TimeHelper t = new TimeHelper();
    public Fucker() {
        super("Fucker", Category.WORLD, Keyboard.KEY_NONE);
        addValue(range);
        addValue(id);
        addValue(AACTeleport);
    }
    @Override
    public ArrayList<Mini> createArray(){
        ArrayList<Mini> minis = new ArrayList<>();
        minis.add( new MiniValueBooleanToggleSimple(this,AACTeleport));
        return minis;
    }
    public void nukeBlock(BlockPos pos){
       if(this.AACTeleport.getValue()) {
           mc.thePlayer.sendQueue.addToSendQueue(new C03PacketPlayer.C04PacketPlayerPosition(pos.x, pos.y, pos.z, true));
       }
       // mc.thePlayer.setPosition(pos.x,pos.y,pos.z);
        mc.thePlayer.swingItem();
        mc.thePlayer.sendQueue.addToSendQueue(new C07PacketPlayerDigging(C07PacketPlayerDigging.Action.START_DESTROY_BLOCK, pos, EnumFacing.UP));
        mc.thePlayer.sendQueue.addToSendQueue(new C07PacketPlayerDigging(C07PacketPlayerDigging.Action.STOP_DESTROY_BLOCK, pos, EnumFacing.UP));
    }

    public void onUpdate(){
        AACTeleport.setValue(false);
        if(t.hasReached(this.AACTeleport.getValue() ? 200 : 200)){
            t.reset();
        }else{
            return;
        }
        blockToFuck = Block.getBlockById((int) this.id.getValue());
        int range = (int) this.range.getValue();
        if(this.AACTeleport.getValue()){
            range = 5;
        }
        for(int x = (int) -(range); x < range*2;++x){
            for(int y = (int) -(range); y < range*2;++y){
                for(int z = (int) -(range); z < range*2;++z){
                    if(mc.theWorld.getBlockState(new BlockPos(mc.thePlayer.posX + x/2,mc.thePlayer.posY + y/2,mc.thePlayer.posZ + z/2)).getBlock() == this.blockToFuck){
                        nukeBlock(new BlockPos(mc.thePlayer.posX + x/2,mc.thePlayer.posY + y/2,mc.thePlayer.posZ + z/2));
                        x = (int) (this.range.getValue() *80000);
                        return;
                    }
                }
            }
        }
    }

}

minecraft_de_Client_Main_Modules_mods_World_LiquidWalk.java

package de.Client.Main.Modules.mods.World;

import de.Client.Events.EventTarget;
import de.Client.Events.Events.PacketSendEvent;
import de.Client.Main.Modules.Category;
import de.Client.Main.Modules.Module;
import de.Client.Main.Values.ValueBoolean;
import de.Client.Render.ClickGui.Panels.Mini;
import de.Client.Render.ClickGui.Panels.Minitypes.MiniOneOfTwo;
import net.minecraft.block.BlockLiquid;
import net.minecraft.client.Minecraft;
import net.minecraft.init.Blocks;
import net.minecraft.network.play.client.C03PacketPlayer;
import net.minecraft.util.AxisAlignedBB;
import net.minecraft.util.BlockPos;
import net.minecraft.util.MathHelper;
import net.minecraft.util.MovementInput;
import org.lwjgl.input.Keyboard;

import java.util.ArrayList;

public class LiquidWalk extends Module {
	public ValueBoolean NCP = new ValueBoolean("Ncp", true);
    public ValueBoolean Dolphine = new ValueBoolean("Dolphine", true);
	public ValueBoolean AAC = new ValueBoolean("Aac", true);
	public boolean nextTick;
	private int airticks;

	public LiquidWalk() {
		super("LiquidWalk", Category.WORLD, Keyboard.KEY_J);
		addValue(NCP);
		addValue(AAC);
		addValue(Dolphine);
		this.displayName = "Liquid Walk";
	}
    @Override
    public ArrayList<Mini> createArray(){
        ArrayList<Mini> minis = new ArrayList<>();
        minis.add( new MiniOneOfTwo(this,AAC,NCP));
        return minis;
    }
	public boolean isOnLiquid(AxisAlignedBB boundingBox) {
		boundingBox = boundingBox.contract(0.01, 0, 0.01).offset(0, -0.01, 0);
		boolean onLiquid = false;
		int y = (int) boundingBox.minY;

		for (int x = MathHelper.floor_double(boundingBox.minX); x < MathHelper
				.floor_double(boundingBox.maxX + 1); x++) {
			for (int z = MathHelper.floor_double(boundingBox.minZ); z < MathHelper
					.floor_double(boundingBox.maxZ + 1); z++) {
				net.minecraft.block.Block block = getBlock(new BlockPos(x, y, z));

				if (block == Blocks.air) {
					continue;
				}

				if (!(block instanceof BlockLiquid)) {
					return false;
				}

				onLiquid = true;
			}
		}

		return onLiquid;
	}
	@EventTarget(3)
	public void onSendPacket(PacketSendEvent event) {
		if(!this.NCP.getValue() || mc.thePlayer.isInWater()){
			return;
		}

	  if ((!event.isCancelled()) && 
	    ((event.getPacket() instanceof C03PacketPlayer))) {
	    C03PacketPlayer packet = (C03PacketPlayer)event.getPacket();
	    if (this.isOnLiquid(mc.thePlayer.boundingBox)) {
	    
	      this.nextTick = (!this.nextTick);
	      if (this.nextTick) {
	        packet.y-= Math.pow(10.0D, -7.0D)-0.2;

	      }else{

          }
	      packet.field_149474_g = (!this.nextTick);
	      event.setPacket(packet);
	    }
	  }
	 
	  
	}
	public boolean getdown;
    public boolean getout;
	public double currentMoveSpeed;
	@Override
	public void onUpdate(){
	    if(this.Dolphine.getValue()){
            if(mc.thePlayer.onGround){
                this.getdown = true;
            }

            if(this.isOnLiquid(mc.thePlayer.boundingBox)){
                mc.thePlayer.motionY += 0.025;

            }


            if(mc.thePlayer.motionY > 0 && getdown){
                if(mc.thePlayer.motionY <= 0.11) mc.thePlayer.motionY *= 1.2671;
                mc.thePlayer.motionY += 0.05172;
                mc.thePlayer.motionY *= 1.000001;
                getout = false;
                this.nextTick = true;

            }
            if(mc.thePlayer.motionY < 0  &&   this.getdown){

                mc.thePlayer.motionY += 0.01528;
            }

            airticks++;


            if(this.isOnLiquid(mc.thePlayer.boundingBox.expand(0,0.01, 0))){
                this.getout = (!this.getout);
                this.airticks =0;
                this.mc.thePlayer.motionY = (this.getout ? 0.05D : 0.500D);
                if(!this.getdown){


                }
                this.getdown = true;
            }
        }
		if(this.AAC.getValue()) {

            if ( mc.thePlayer.isInWater() || !mc.thePlayer.onGround && mc.theWorld.getBlockState(new BlockPos(mc.thePlayer.posX,mc.thePlayer.posY-1,mc.thePlayer.posZ)).getBlock() instanceof BlockLiquid) {

                if(mc.thePlayer.onGround) {

                    mc.thePlayer.motionY += 0.03;
                    nextTick = false;
                }
                if(!mc.gameSettings.keyBindForward.pressed && ! mc.gameSettings.keyBindBack.pressed && ! mc.gameSettings.keyBindRight.pressed && ! mc.gameSettings.keyBindLeft.pressed){


                }else{
                    airticks = (int) mc.thePlayer.rotationYaw;
                    mc.thePlayer.motionX *= 1.1715;
                    mc.thePlayer.motionZ *= 1.1715;
                    currentMoveSpeed = mc.thePlayer.getSpeed() ;
                    mc.thePlayer.setSpeed(mc.thePlayer.getSpeed());

                }
               if(this.nextTick){
                    mc.thePlayer.setSpeed(mc.thePlayer.getSpeed()/10);
                }
            }else{

            }
            if(mc.thePlayer.onGround && ! mc.thePlayer.isInWater()){
                if(!this.nextTick){
                    mc.thePlayer.setSpeed(mc.thePlayer.getSpeed()/5);
                }
                this.nextTick =true;
            }

        }
	}
	
	public static net.minecraft.block.Block getBlock(BlockPos pos) {
		return Minecraft.getMinecraft().theWorld.getBlockState(pos).getBlock();
	}

	public boolean safe() {

		try {
			return mc.thePlayer.fallDistance < 3 && NCP.getValue();
		} catch (Exception e) {
			return true;
		}

	}


}

minecraft_de_Client_Main_Modules_mods_World_PathFinder.java

package de.Client.Main.Modules.mods.World;

import de.Client.Main.Modules.Category;
import de.Client.Main.Modules.Module;
import de.Client.Utils.TimeHelper;
import net.minecraft.client.renderer.Tessellator;
import net.minecraft.client.renderer.WorldRenderer;
import net.minecraft.client.renderer.entity.RenderManager;
import net.minecraft.init.Blocks;
import net.minecraft.network.play.client.C03PacketPlayer;
import net.minecraft.network.play.client.C07PacketPlayerDigging;
import net.minecraft.util.AxisAlignedBB;
import net.minecraft.util.BlockPos;
import net.minecraft.util.EnumFacing;
import org.lwjgl.input.Keyboard;
import org.lwjgl.opengl.GL11;

import java.sql.Time;
import java.util.ArrayList;

public class PathFinder extends Module {

    public PathFinder() {
        super("PathFinder", Category.WORLD, Keyboard.KEY_NONE);
        // TODO Auto-generated constructor stub
    }

    public ArrayList<BlockPos> blockPos = new ArrayList();

    public BlockPos blockPosToGo;

    public TimeHelper timeHelper = new TimeHelper();

    public void onEnable(){
        this.scanForBeds();
    }

    public void onRender(){
        for(BlockPos pos : this.blockPos){
            double renderX = pos.x - RenderManager.renderPosX;
            double renderY = pos.y - RenderManager.renderPosY;
            double renderZ = pos.z - RenderManager.renderPosZ;
            int x = pos.x;
            int z = pos.z;
            int y = pos.y;
            GL11.glPushMatrix();
            GL11.glTranslated(renderX, renderY, renderZ);
            GL11.glPolygonOffset(1.0F, -1.0E7F);
            GL11.glDisable(GL11.GL_DEPTH_TEST);
            GL11.glEnable(GL11.GL_BLEND);
            GL11.glBlendFunc(770, 771);
            // GL11.glDisable(GL11.GL_LIGHTING);
            GL11.glDisable(GL11.GL_TEXTURE_2D);
            GL11.glEnable(GL11.GL_LINE_SMOOTH);
            GL11.glDisable(GL11.GL_DEPTH_TEST);
            GL11.glDepthMask(false);
            GL11.glColor4f(10,0,0,0.3f);
            this.chestESP(new AxisAlignedBB(0, 0, 0, 1,  1D,  1D));

            GL11.glDisable(GL11.GL_LINE_SMOOTH);
            GL11.glEnable(GL11.GL_TEXTURE_2D);
            // GL11.glEnable(GL11.GL_LIGHTING);
            GL11.glEnable(GL11.GL_DEPTH_TEST);
            GL11.glDepthMask(true);
            GL11.glPolygonOffset(1.0F, 1000000.0F);
            GL11.glEnable(GL11.GL_DEPTH_TEST);
            GL11.glTranslated(-renderX, -renderY, -renderZ);
            GL11.glPopMatrix();
        }
    }
    public void chestESP(AxisAlignedBB aa) {
        Tessellator tessellator = Tessellator.getInstance();
        WorldRenderer worldRenderer = tessellator.getWorldRenderer();
        worldRenderer.startDrawingQuads();
        worldRenderer.addVertex(aa.minX, aa.minY, aa.minZ);
        worldRenderer.addVertex(aa.minX, aa.maxY, aa.minZ);
        worldRenderer.addVertex(aa.maxX, aa.minY, aa.minZ);
        worldRenderer.addVertex(aa.maxX, aa.maxY, aa.minZ);
        worldRenderer.addVertex(aa.maxX, aa.minY, aa.maxZ);
        worldRenderer.addVertex(aa.maxX, aa.maxY, aa.maxZ);
        worldRenderer.addVertex(aa.minX, aa.minY, aa.maxZ);
        worldRenderer.addVertex(aa.minX, aa.maxY, aa.maxZ);
        tessellator.draw();
        worldRenderer.startDrawingQuads();
        worldRenderer.addVertex(aa.maxX, aa.maxY, aa.minZ);
        worldRenderer.addVertex(aa.maxX, aa.minY, aa.minZ);
        worldRenderer.addVertex(aa.minX, aa.maxY, aa.minZ);
        worldRenderer.addVertex(aa.minX, aa.minY, aa.minZ);
        worldRenderer.addVertex(aa.minX, aa.maxY, aa.maxZ);
        worldRenderer.addVertex(aa.minX, aa.minY, aa.maxZ);
        worldRenderer.addVertex(aa.maxX, aa.maxY, aa.maxZ);
        worldRenderer.addVertex(aa.maxX, aa.minY, aa.maxZ);
        tessellator.draw();
        worldRenderer.startDrawingQuads();
        worldRenderer.addVertex(aa.minX, aa.maxY, aa.minZ);
        worldRenderer.addVertex(aa.maxX, aa.maxY, aa.minZ);
        worldRenderer.addVertex(aa.maxX, aa.maxY, aa.maxZ);
        worldRenderer.addVertex(aa.minX, aa.maxY, aa.maxZ);
        worldRenderer.addVertex(aa.minX, aa.maxY, aa.minZ);
        worldRenderer.addVertex(aa.minX, aa.maxY, aa.maxZ);
        worldRenderer.addVertex(aa.maxX, aa.maxY, aa.maxZ);
        worldRenderer.addVertex(aa.maxX, aa.maxY, aa.minZ);
        tessellator.draw();
        worldRenderer.startDrawingQuads();
        worldRenderer.addVertex(aa.minX, aa.minY, aa.minZ);
        worldRenderer.addVertex(aa.maxX, aa.minY, aa.minZ);
        worldRenderer.addVertex(aa.maxX, aa.minY, aa.maxZ);
        worldRenderer.addVertex(aa.minX, aa.minY, aa.maxZ);
        worldRenderer.addVertex(aa.minX, aa.minY, aa.minZ);
        worldRenderer.addVertex(aa.minX, aa.minY, aa.maxZ);
        worldRenderer.addVertex(aa.maxX, aa.minY, aa.maxZ);
        worldRenderer.addVertex(aa.maxX, aa.minY, aa.minZ);
        tessellator.draw();
        worldRenderer.startDrawingQuads();
        worldRenderer.addVertex(aa.minX, aa.minY, aa.minZ);
        worldRenderer.addVertex(aa.minX, aa.maxY, aa.minZ);
        worldRenderer.addVertex(aa.minX, aa.minY, aa.maxZ);
        worldRenderer.addVertex(aa.minX, aa.maxY, aa.maxZ);
        worldRenderer.addVertex(aa.maxX, aa.minY, aa.maxZ);
        worldRenderer.addVertex(aa.maxX, aa.maxY, aa.maxZ);
        worldRenderer.addVertex(aa.maxX, aa.minY, aa.minZ);
        worldRenderer.addVertex(aa.maxX, aa.maxY, aa.minZ);
        tessellator.draw();
        worldRenderer.startDrawingQuads();
        worldRenderer.addVertex(aa.minX, aa.maxY, aa.maxZ);
        worldRenderer.addVertex(aa.minX, aa.minY, aa.maxZ);
        worldRenderer.addVertex(aa.minX, aa.maxY, aa.minZ);
        worldRenderer.addVertex(aa.minX, aa.minY, aa.minZ);
        worldRenderer.addVertex(aa.maxX, aa.maxY, aa.minZ);
        worldRenderer.addVertex(aa.maxX, aa.minY, aa.minZ);
        worldRenderer.addVertex(aa.maxX, aa.maxY, aa.maxZ);
        worldRenderer.addVertex(aa.maxX, aa.minY, aa.maxZ);
        tessellator.draw();
    }

    public ArrayList<BlockPos> matchingBlocks= new ArrayList();
    public int range = 200;
    public void scanForBeds(){

        this.matchingBlocks.clear();
        for (int y = this.range; y >= -this.range; y--)
        {
            for (int x = this.range; x >= -this.range; x--)
            {
                for (int z = this.range; z >= -this.range; z--)
                {
                    int posX = (int)(mc.thePlayer.posX + x);
                    int posY = (int)(mc.thePlayer.posY + y);
                    int posZ = (int)(mc.thePlayer.posZ + z);
                    BlockPos pos = new BlockPos(posX, posY, posZ);

                    if(mc.thePlayer.getDistance(pos.x,pos.y,pos.z) > 4) {

                        if (mc.theWorld.getBlockState(pos).getBlock() == Blocks.bed) {
                            matchingBlocks.add(pos);

                        }
                    }
                }
            }
        }
    }



    public void findPath(){
        if (blockPos.isEmpty()) {
            return;
        }
        int goalX = (int) mc.thePlayer.posX;
        int goalZ = (int) mc.thePlayer.posZ;

        for(int i = 0; i<100; ++i){
            BlockPos blockPos1 = this.blockPos.get(this.blockPos.size() - 1);
            if(blockPos1.x > goalX){
                if(!mc.theWorld.getBlockState(new BlockPos(blockPos1.x-1,blockPos1.y,blockPos1.z)).getBlock().isFullBlock()){
                    this.blockPos.add(new BlockPos(blockPos1.x-1,blockPos1.y,blockPos1.z));
                }else{
                    if(blockPos1.z > goalZ){
                        if(!mc.theWorld.getBlockState(new BlockPos(blockPos1.x,blockPos1.y,blockPos1.z-1)).getBlock().isFullBlock()){
                            this.blockPos.add(new BlockPos(blockPos1.x,blockPos1.y,blockPos1.z-1));
                        }
                    }else if(blockPos1.z < goalZ){
                        if(!mc.theWorld.getBlockState(new BlockPos(blockPos1.x,blockPos1.y,blockPos1.z+1)).getBlock().isFullBlock()){
                            this.blockPos.add(new BlockPos(blockPos1.x,blockPos1.y,blockPos1.z+1));
                        }
                    }
                }
            }else if(blockPos1.x < goalX){
                if(!mc.theWorld.getBlockState(new BlockPos(blockPos1.x+1,blockPos1.y,blockPos1.z)).getBlock().isFullBlock()){
                    this.blockPos.add(new BlockPos(blockPos1.x+1,blockPos1.y,blockPos1.z));
                }else{
                    if(blockPos1.z > goalZ){
                        if(!mc.theWorld.getBlockState(new BlockPos(blockPos1.x,blockPos1.y,blockPos1.z-1)).getBlock().isFullBlock()){
                            this.blockPos.add(new BlockPos(blockPos1.x,blockPos1.y,blockPos1.z-1));
                        }
                    }else if(blockPos1.z < goalZ){
                        if(!mc.theWorld.getBlockState(new BlockPos(blockPos1.x,blockPos1.y,blockPos1.z+1)).getBlock().isFullBlock()){
                            this.blockPos.add(new BlockPos(blockPos1.x,blockPos1.y,blockPos1.z+1));
                        }
                    }
                }
            }else{
                if(blockPos1.z > goalZ){
                    if(!mc.theWorld.getBlockState(new BlockPos(blockPos1.x,blockPos1.y,blockPos1.z-1)).getBlock().isFullBlock()){
                        this.blockPos.add(new BlockPos(blockPos1.x,blockPos1.y,blockPos1.z-1));
                    }
                }else if(blockPos1.z < goalZ){
                    if(!mc.theWorld.getBlockState(new BlockPos(blockPos1.x,blockPos1.y,blockPos1.z+1)).getBlock().isFullBlock()){
                        this.blockPos.add(new BlockPos(blockPos1.x,blockPos1.y,blockPos1.z+1));
                    }
                }else{

                    if(blockPos1.z == goalZ){
                        if(blockPos1.x == goalX){
                            i = 200;
                        }
                    }

                    if(!mc.theWorld.getBlockState(new BlockPos(blockPos1.x,blockPos1.y,blockPos1.z+1)).getBlock().isFullBlock()){
                        this.blockPos.add(new BlockPos(blockPos1.x,blockPos1.y,blockPos1.z+1));
                    }else{
                        if(!mc.theWorld.getBlockState(new BlockPos(blockPos1.x,blockPos1.y,blockPos1.z-1)).getBlock().isFullBlock()){
                            this.blockPos.add(new BlockPos(blockPos1.x,blockPos1.y,blockPos1.z-1));
                        }else{
                            if(!mc.theWorld.getBlockState(new BlockPos(blockPos1.x+1,blockPos1.y,blockPos1.z)).getBlock().isFullBlock()){
                                this.blockPos.add(new BlockPos(blockPos1.x+1,blockPos1.y,blockPos1.z));
                            }else {
                                if (!mc.theWorld.getBlockState(new BlockPos(blockPos1.x - 1, blockPos1.y, blockPos1.z)).getBlock().isFullBlock()) {
                                    this.blockPos.add(new BlockPos(blockPos1.x - 1, blockPos1.y, blockPos1.z - 1));
                                }
                            }
                        }
                    }
                }
            }

        }
    }

    public void teleportToPos(ArrayList<BlockPos> positions){
        int distance = 0;
        for(int i = 0; i < positions.size();++i) {
            BlockPos pos = positions.get(positions.size()-1);
            distance++;
            mc.thePlayer.sendQueue.addToSendQueue(new C03PacketPlayer.C04PacketPlayerPosition(pos.x, pos.y, pos.z, true));

            positions.remove(pos);
        }
    }

    public TimeHelper time = new TimeHelper();
    public void onUpdate() {
        if(mc.thePlayer.posY <= 0){
            time.reset();
        }
        if (!time.hasReached(10000) && mc.thePlayer.fallDistance < 2 && mc.gameSettings.keyBindAttack.pressed) {
            mc.thePlayer.fallDistance = 99;
            BlockPos sPos = new BlockPos(mc.thePlayer.posX,mc.thePlayer.posY+1,mc.thePlayer.posZ);
            for(BlockPos pos : this.matchingBlocks){
                mc.thePlayer.setPosition(sPos.x,sPos.y,sPos.z);
                this.blockPos.clear();
                this.blockPos.add(sPos);
                this.findPath();
                this.findPath();
                this.findPath();
                this.findPath();
                this.findPath();
                this.findPath();
                this.findPath();
                this.findPath();
                this.findPath();
                this.findPath();
                this.findPath();
                this.teleportToPos(this.blockPos);

                mc.thePlayer.swingItem();
                mc.thePlayer.sendQueue.addToSendQueue(new C07PacketPlayerDigging(C07PacketPlayerDigging.Action.START_DESTROY_BLOCK, pos, EnumFacing.UP));
                mc.thePlayer.sendQueue.addToSendQueue(new C07PacketPlayerDigging(C07PacketPlayerDigging.Action.STOP_DESTROY_BLOCK, pos, EnumFacing.UP));
                sPos = new BlockPos(pos.x,pos.y+1,pos.z);
            }
        }
    }
    @Override
    public boolean isModuleImportant(){
        return false;
    }
}

minecraft_de_Client_Main_Modules_mods_World_Phase.java

package de.Client.Main.Modules.mods.World;

import de.Client.Main.Main;
import de.Client.Main.Modules.Category;
import de.Client.Main.Modules.Module;
import de.Client.Main.Values.ValueBoolean;
import net.minecraft.block.Block;
import net.minecraft.block.BlockAir;
import net.minecraft.block.BlockHopper;
import net.minecraft.enchantment.Enchantment;
import net.minecraft.network.play.client.C03PacketPlayer;
import net.minecraft.network.play.client.C07PacketPlayerDigging;
import net.minecraft.util.AxisAlignedBB;
import net.minecraft.util.BlockPos;
import net.minecraft.util.EnumFacing;
import net.minecraft.util.MathHelper;
import org.lwjgl.input.Keyboard;

import java.util.Random;

public class Phase extends Module {
    public ValueBoolean skipClip = new ValueBoolean("skipClip",false);
    public ValueBoolean offset = new ValueBoolean("offset",true);
    public boolean shouldclip;
    public Phase() {
        super("Phase", Category.WORLD, Keyboard.KEY_Y);
        // TODO Auto-generated constructor stub
        addValue(skipClip);
        addValue(offset);
    }


    public boolean debugboolean1;
    public boolean debugboolean2;
    public boolean debugboolean3;
    public boolean debugboolean4;

    private boolean isInsideBlock() {
        for (int x = MathHelper.floor_double(mc.thePlayer.boundingBox.minX); x < MathHelper.floor_double(mc.thePlayer.boundingBox.maxX) + 1; x++) {
            for (int y = MathHelper.floor_double(mc.thePlayer.boundingBox.minY); y < MathHelper.floor_double(mc.thePlayer.boundingBox.maxY) + 1; y++) {
                for (int z = MathHelper.floor_double(mc.thePlayer.boundingBox.minZ); z < MathHelper.floor_double(mc.thePlayer.boundingBox.maxZ) + 1; z++)
                {
                    Block block = mc.theWorld.getBlockState(new BlockPos(x, y, z)).getBlock();
                    if ((block != null) && (!(block instanceof BlockAir)))
                    {
                        AxisAlignedBB boundingBox = block.getCollisionBoundingBox(mc.theWorld, new BlockPos(x, y, z), mc.theWorld.getBlockState(new BlockPos(x, y, z)));
                        if ((block instanceof BlockHopper)) {
                            boundingBox = new AxisAlignedBB(x, y, z, x + 1, y + 1, z + 1);
                        }
                        if ((boundingBox != null) && (mc.thePlayer.boundingBox.intersectsWith(boundingBox))) {
                            return true;
                        }
                    }
                }
            }
        }
        return false;
    }
    public void onUpdate(){
        /*/
        /*/
        /*/
        if(mc.thePlayer.isCollidedHorizontally && mc.thePlayer.onGround){
            mc.thePlayer.motionY = -0.4;
            debugboolean2 = true;
        }
        if ( debugboolean2) {
            double blocks = 0.00001;
            double blocks2 = 1;
            double x = Math.cos(Math.toRadians(mc.thePlayer.rotationYaw + 90.0F));
            double z = Math.sin(Math.toRadians(mc.thePlayer.rotationYaw + 90.0F));
            double y = mc.thePlayer.posY;
            this.debugboolean2 = false;
            // mc.theWorld.getBlockState(new BlockPos(mc.thePlayer.posX,mc.thePlayer.posY+1,mc.thePlayer.posZ)).;

                //  mc.thePlayer.swingIte  m();
               // mc.thePlayer.ticksExisted = 0;
                mc.playerController.func_178891_a(this.mc, mc.playerController, new BlockPos(mc.thePlayer.posX + (1.0D * blocks2 * x + 0.0D * blocks2 * z), mc.thePlayer.posY, mc.thePlayer.posZ + (1.0D * blocks2 * z - 0.0D * blocks2 * x)), EnumFacing.DOWN);
                // mc.thePlayer.sendQueue.addToSendQueue(new C07PacketPlayerDigging(C07PacketPlayerDigging.Action.START_DESTROY_BLOCK, new BlockPos(mc.thePlayer.posX + (1.0D * blocks2 * x + 0.0D * blocks2 * z), mc.thePlayer.posY , mc.thePlayer.posZ + (1.0D * blocks2 * z - 0.0D * blocks2 * x)), EnumFacing.DOWN));
                mc.thePlayer.sendQueue.addToSendQueue(new C07PacketPlayerDigging(C07PacketPlayerDigging.Action.STOP_DESTROY_BLOCK, new BlockPos(mc.thePlayer.posX + (1.0D * blocks2 * x + 0.0D * blocks2 * z), mc.thePlayer.posY, mc.thePlayer.posZ + (1.0D * blocks2 * z - 0.0D * blocks2 * x)), EnumFacing.DOWN));
                mc.playerController.func_178891_a(this.mc, mc.playerController, new BlockPos(mc.thePlayer.posX + (1.0D * blocks2 * x + 0.0D * blocks2 * z), mc.thePlayer.posY + 1, mc.thePlayer.posZ + (1.0D * blocks2 * z - 0.0D * blocks2 * x)), EnumFacing.DOWN);
                // mc.thePlayer.sendQueue.addToSendQueue(new C07PacketPlayerDigging(C07PacketPlayerDigging.Action.START_DESTROY_BLOCK, new BlockPos(mc.thePlayer.posX + (1.0D * blocks2 * x + 0.0D * blocks2 * z), mc.thePlayer.posY , mc.thePlayer.posZ + (1.0D * blocks2 * z - 0.0D * blocks2 * x)), EnumFacing.DOWN));
                mc.thePlayer.sendQueue.addToSendQueue(new C07PacketPlayerDigging(C07PacketPlayerDigging.Action.STOP_DESTROY_BLOCK, new BlockPos(mc.thePlayer.posX + (1.0D * blocks2 * x + 0.0D * blocks2 * z), mc.thePlayer.posY + 1, mc.thePlayer.posZ + (1.0D * blocks2 * z - 0.0D * blocks2 * x)), EnumFacing.DOWN));
                mc.thePlayer.setSpeed(0.1);

        }
        /*/
        if(mc.thePlayer.isCollidedHorizontally && mc.thePlayer.ticksExisted % 7 == 1){
            mc.thePlayer.setSpeed(0);
            double blocks = 0.00001;
            double blocks2 = 1;
            double x = Math.cos(Math.toRadians(mc.thePlayer.rotationYaw + 90.0F));
            double z = Math.sin(Math.toRadians(mc.thePlayer.rotationYaw + 90.0F));
            double y = mc.thePlayer.posY;

            mc.playerController.func_178891_a(this.mc, mc.playerController, new BlockPos(mc.thePlayer.posX + (1.0D * blocks2 * x + 0.0D * blocks2 * z), mc.thePlayer.posY, mc.thePlayer.posZ + (1.0D * blocks2 * z - 0.0D * blocks2 * x)), EnumFacing.DOWN);
            // mc.thePlayer.sendQueue.addToSendQueue(new C07PacketPlayerDigging(C07PacketPlayerDigging.Action.START_DESTROY_BLOCK, new BlockPos(mc.thePlayer.posX + (1.0D * blocks2 * x + 0.0D * blocks2 * z), mc.thePlayer.posY , mc.thePlayer.posZ + (1.0D * blocks2 * z - 0.0D * blocks2 * x)), EnumFacing.DOWN));
            mc.thePlayer.sendQueue.addToSendQueue(new C07PacketPlayerDigging(C07PacketPlayerDigging.Action.STOP_DESTROY_BLOCK, new BlockPos(mc.thePlayer.posX + (1.0D * blocks2 * x + 0.0D * blocks2 * z), mc.thePlayer.posY, mc.thePlayer.posZ + (1.0D * blocks2 * z - 0.0D * blocks2 * x)), EnumFacing.DOWN));
            mc.playerController.func_178891_a(this.mc, mc.playerController, new BlockPos(mc.thePlayer.posX + (1.0D * blocks2 * x + 0.0D * blocks2 * z), mc.thePlayer.posY + 1, mc.thePlayer.posZ + (1.0D * blocks2 * z - 0.0D * blocks2 * x)), EnumFacing.DOWN);
            // mc.thePlayer.sendQueue.addToSendQueue(new C07PacketPlayerDigging(C07PacketPlayerDigging.Action.START_DESTROY_BLOCK, new BlockPos(mc.thePlayer.posX + (1.0D * blocks2 * x + 0.0D * blocks2 * z), mc.thePlayer.posY , mc.thePlayer.posZ + (1.0D * blocks2 * z - 0.0D * blocks2 * x)), EnumFacing.DOWN));
            mc.thePlayer.sendQueue.addToSendQueue(new C07PacketPlayerDigging(C07PacketPlayerDigging.Action.STOP_DESTROY_BLOCK, new BlockPos(mc.thePlayer.posX + (1.0D * blocks2 * x + 0.0D * blocks2 * z), mc.thePlayer.posY + 1, mc.thePlayer.posZ + (1.0D * blocks2 * z - 0.0D * blocks2 * x)), EnumFacing.DOWN));
            mc.thePlayer.setPosition(mc.thePlayer.posX + (1.0D * 0.03 * x + 0.0D * 0.03 * z), mc.thePlayer.posY, mc.thePlayer.posZ + (1.0D * 0.03 * z - 0.0D * 0.03 * x));
        }else{
            double blocks = 0.00001;

            if(this.isInsideBlock()){
                mc.thePlayer.setSpeed(0.5);
            }else{
                if(mc.thePlayer.getSpeed() >0.2) {
                    mc.thePlayer.setSpeed(0.1);
                }
            }
        }

        if(false) {
            if (mc.gameSettings.keyBindSneak.pressed) {
                if (mc.thePlayer.ticksExisted % 13 == 2 && mc.thePlayer.onGround) {
                    mc.playerController.func_178891_a(this.mc, mc.playerController, new BlockPos(mc.thePlayer.posX, mc.thePlayer.posY - 1, mc.thePlayer.posZ), EnumFacing.DOWN);
                    // mc.thePlayer.sendQueue.addToSendQueue(new C07PacketPlayerDigging(C07PacketPlayerDigging.Action.START_DESTROY_BLOCK, new BlockPos(mc.thePlayer.posX + (1.0D * blocks2 * x + 0.0D * blocks2 * z), mc.thePlayer.posY , mc.thePlayer.posZ + (1.0D * blocks2 * z - 0.0D * blocks2 * x)), EnumFacing.DOWN));
                    mc.thePlayer.sendQueue.addToSendQueue(new C07PacketPlayerDigging(C07PacketPlayerDigging.Action.STOP_DESTROY_BLOCK, new BlockPos(mc.thePlayer.posX, mc.thePlayer.posY - 1, mc.thePlayer.posZ), EnumFacing.DOWN));
                }
                return;
            }
                shouldclip = false;
                if (this.isInsideBlock()) {
                    if (!mc.thePlayer.onGround) {
                        mc.thePlayer.motionY = -1;
                    }
                    mc.gameSettings.keyBindForward.pressed = false;
                    // mc.thePlayer.sendQueue.addToSendQueue(new C07PacketPlayerDigging(C07PacketPlayerDigging.Action.START_DESTROY_BLOCK, new BlockPos(mc.thePlayer.posX + (1.0D * blocks2 * x + 0.0D * blocks2 * z), mc.thePlayer.posY , mc.thePlayer.posZ + (1.0D * blocks2 * z - 0.0D * blocks2 * x)), EnumFacing.DOWN));
                    mc.thePlayer.sendQueue.addToSendQueue(new C07PacketPlayerDigging(C07PacketPlayerDigging.Action.STOP_DESTROY_BLOCK, new BlockPos(mc.thePlayer.posX, mc.thePlayer.posY + 2, mc.thePlayer.posZ), EnumFacing.DOWN));
                    if (mc.thePlayer.ticksExisted > 10) {
                        double blocks = -0.1;
                        //  double blocks2 = 2;
                        double x = Math.cos(Math.toRadians(mc.thePlayer.rotationYaw + 90.0F));
                        double z = Math.sin(Math.toRadians(mc.thePlayer.rotationYaw + 90.0F));
                        double y = mc.thePlayer.posY;
                        mc.thePlayer.sendQueue.addToSendQueue(new C03PacketPlayer.C04PacketPlayerPosition(mc.thePlayer.posX + (1.0D * blocks * x + 0.0D * blocks * z), mc.thePlayer.posY, mc.thePlayer.posZ + (1.0D * blocks * z - 0.0D * blocks * x), false));
                        mc.thePlayer.setPosition(mc.thePlayer.posX + (1.0D * blocks * x + 0.0D * blocks * z), mc.thePlayer.posY, mc.thePlayer.posZ + (1.0D * blocks * z - 0.0D * blocks * x));
                        mc.thePlayer.jump();
                        this.debugboolean2 = true;
                    }
                    //    mc.thePlayer.sendQueue.addToSendQueue(new C03PacketPlayer.C04PacketPlayerPosition(mc.thePlayer.posX + (1.0D * -blocks * x + 0.0D * -blocks * z), mc.thePlayer.posY, mc.thePlayer.posZ + (1.0D * -blocks * z - 0.0D * -blocks * x),false));
                    //    mc.thePlayer.setPosition(mc.thePlayer.posX + (1.0D * blocks2 * x + 0.0D * blocks2 * z), mc.thePlayer.posY, mc.thePlayer.posZ + (1.0D * blocks2 * z - 0.0D * blocks2 * x));
                } else {
                    if (debugboolean2) {
                        mc.thePlayer.setSpeed(0.01);
                        mc.gameSettings.keyBindForward.pressed = true;
                    }
                    double blocks = 0.00001;
                    double blocks2 = 1;
                    double x = Math.cos(Math.toRadians(mc.thePlayer.rotationYaw + 90.0F));
                    double z = Math.sin(Math.toRadians(mc.thePlayer.rotationYaw + 90.0F));
                    double y = mc.thePlayer.posY;

                    // mc.theWorld.getBlockState(new BlockPos(mc.thePlayer.posX,mc.thePlayer.posY+1,mc.thePlayer.posZ)).;
                    if (!mc.thePlayer.onGround && mc.thePlayer.motionY < -00) {
                        if (debugboolean1) {
                            debugboolean2 = false;
                            debugboolean1 = false;
                            //   this.toggleModule();
                            //  mc.thePlayer.swingItem();
                            mc.thePlayer.ticksExisted = 0;
                            mc.playerController.func_178891_a(this.mc, mc.playerController, new BlockPos(mc.thePlayer.posX + (1.0D * blocks2 * x + 0.0D * blocks2 * z), mc.thePlayer.posY, mc.thePlayer.posZ + (1.0D * blocks2 * z - 0.0D * blocks2 * x)), EnumFacing.DOWN);
                            // mc.thePlayer.sendQueue.addToSendQueue(new C07PacketPlayerDigging(C07PacketPlayerDigging.Action.START_DESTROY_BLOCK, new BlockPos(mc.thePlayer.posX + (1.0D * blocks2 * x + 0.0D * blocks2 * z), mc.thePlayer.posY , mc.thePlayer.posZ + (1.0D * blocks2 * z - 0.0D * blocks2 * x)), EnumFacing.DOWN));
                            mc.thePlayer.sendQueue.addToSendQueue(new C07PacketPlayerDigging(C07PacketPlayerDigging.Action.STOP_DESTROY_BLOCK, new BlockPos(mc.thePlayer.posX + (1.0D * blocks2 * x + 0.0D * blocks2 * z), mc.thePlayer.posY, mc.thePlayer.posZ + (1.0D * blocks2 * z - 0.0D * blocks2 * x)), EnumFacing.DOWN));
                            mc.playerController.func_178891_a(this.mc, mc.playerController, new BlockPos(mc.thePlayer.posX + (1.0D * blocks2 * x + 0.0D * blocks2 * z), mc.thePlayer.posY + 1, mc.thePlayer.posZ + (1.0D * blocks2 * z - 0.0D * blocks2 * x)), EnumFacing.DOWN);
                            // mc.thePlayer.sendQueue.addToSendQueue(new C07PacketPlayerDigging(C07PacketPlayerDigging.Action.START_DESTROY_BLOCK, new BlockPos(mc.thePlayer.posX + (1.0D * blocks2 * x + 0.0D * blocks2 * z), mc.thePlayer.posY , mc.thePlayer.posZ + (1.0D * blocks2 * z - 0.0D * blocks2 * x)), EnumFacing.DOWN));
                            mc.thePlayer.sendQueue.addToSendQueue(new C07PacketPlayerDigging(C07PacketPlayerDigging.Action.STOP_DESTROY_BLOCK, new BlockPos(mc.thePlayer.posX + (1.0D * blocks2 * x + 0.0D * blocks2 * z), mc.thePlayer.posY + 1, mc.thePlayer.posZ + (1.0D * blocks2 * z - 0.0D * blocks2 * x)), EnumFacing.DOWN));
                        }
                    } else {
                        debugboolean1 = true;
                    }
                }
            }

     //   mc.thePlayer.fallDistance = 0.0f;

/*/

        }
        /*/
           //     mc.thePlayer.posZ , false));
      //  mc.thePlayer.rotationYaw += 30;
        if(this.skipClip.getValue()){
            if(mc.thePlayer.isCollidedHorizontally){
                double blocks = 0.00001;
                double blocks2 = 2;
                double x = Math.cos(Math.toRadians(mc.thePlayer.rotationYaw + 90.0F));
                double z = Math.sin(Math.toRadians(mc.thePlayer.rotationYaw + 90.0F));
                double y = mc.thePlayer.posY;
                mc.thePlayer.sendQueue.addToSendQueue(new C03PacketPlayer.C04PacketPlayerPosition(mc.thePlayer.posX + (1.0D * blocks * x + 0.0D * blocks * z), mc.thePlayer.posY, mc.thePlayer.posZ + (1.0D * blocks * z - 0.0D * blocks * x),false));
            //    mc.thePlayer.sendQueue.addToSendQueue(new C03PacketPlayer.C04PacketPlayerPosition(mc.thePlayer.posX + (1.0D * -blocks * x + 0.0D * -blocks * z), mc.thePlayer.posY, mc.thePlayer.posZ + (1.0D * -blocks * z - 0.0D * -blocks * x),false));
                mc.thePlayer.setPosition(mc.thePlayer.posX + (1.0D * blocks2 * x + 0.0D * blocks2 * z), mc.thePlayer.posY, mc.thePlayer.posZ + (1.0D * blocks2 * z - 0.0D * blocks2 * x));
            }
        }
        if(this.offset.getValue()) {

            if (mc.thePlayer.isCollidedHorizontally) {
                double x = -MathHelper.sin(mc.thePlayer.getDirection()) * 0.5;
                double z = MathHelper.cos(mc.thePlayer.getDirection()) * 0.5;
                double y = mc.thePlayer.posY;

                 mc.thePlayer.setPosition(mc.thePlayer.posX + (1.0D * 0.2 * x + 0.0D * 0.2 * z), mc.thePlayer.posY, mc.thePlayer.posZ + (1.0D * 0.2 * z - 0.0D * 0.2 * x));
           //     for(int i = 0; i < 10; i++) {

                boolean isInsideBlock;
                    for (int x1 = MathHelper.floor_double(mc.thePlayer.boundingBox.minX); x1 < MathHelper.floor_double(mc.thePlayer.boundingBox.maxX) + 1; x1++) {
                        for (int y1 = MathHelper.floor_double(mc.thePlayer.boundingBox.minY); y1 < MathHelper.floor_double(mc.thePlayer.boundingBox.maxY) + 1; y1++) {
                            for (int z1 = MathHelper.floor_double(mc.thePlayer.boundingBox.minZ); z1 < MathHelper.floor_double(mc.thePlayer.boundingBox.maxZ) + 1; z1++)
                            {
                                Block block = mc.theWorld.getBlockState(new BlockPos(x, y, z)).getBlock();
                                if ((block != null) && (!(block instanceof BlockAir)))
                                {
                                    AxisAlignedBB boundingBox = block.getCollisionBoundingBox(mc.theWorld, new BlockPos(x, y, z), mc.theWorld.getBlockState(new BlockPos(x, y, z)));
                                    if ((block instanceof BlockHopper)) {
                                        boundingBox = new AxisAlignedBB(x, y, z, x + 1, y + 1, z + 1);
                                    }
                                    if ((boundingBox != null) && (mc.thePlayer.boundingBox.intersectsWith(boundingBox))) {
                                        isInsideBlock =  true;
                                    }
                                }
                            }
                        }
                    }
                isInsideBlock =  false;
                    if(!isInsideBlock) {
                      //  mc.thePlayer.jump();
                        mc.thePlayer.sendQueue.addToSendQueue(new C03PacketPlayer.C04PacketPlayerPosition(mc.thePlayer.posX + x, mc.thePlayer.posY,
                                mc.thePlayer.posZ + z, false));

                    }else{
                        mc.thePlayer.setPosition(mc.thePlayer.posX + x, -99,
                                mc.thePlayer.posZ + z);
                     //   mc.thePlayer.sendQueue.addToSendQueue(new C03PacketPlayer.C04PacketPlayerPosition(mc.thePlayer.posX + (1.0D * blocks * x + 0.0D * blocks * z), mc.thePlayer.posY, mc.thePlayer.posZ + (1.0D * blocks * z - 0.0D * blocks * x),false));
                    }

            }
            if(mc.gameSettings.keyBindSneak.pressed){
                mc.thePlayer.setPosition(mc.thePlayer.posX,mc.thePlayer.posY-1,mc.thePlayer.posZ);

            }

            if(mc.gameSettings.keyBindJump.pressed &&  !(mc.theWorld.getBlockState(new BlockPos(mc.thePlayer.posX,mc.thePlayer.posY+1,mc.thePlayer.posZ)).getBlock() instanceof BlockAir)){
                mc.thePlayer.setPosition(mc.thePlayer.posX,mc.thePlayer.posY+0.42,mc.thePlayer.posZ);

            }


        }
    }

}

minecraft_de_Client_Main_Modules_mods_World_ScaffoldWalk.java

package de.Client.Main.Modules.mods.World;

import de.Client.Events.EventTarget;
import de.Client.Events.Events.*;
import de.Client.Main.Main;
import de.Client.Main.Modules.Category;
import de.Client.Main.Modules.Module;
import de.Client.Main.Values.ValueBoolean;
import de.Client.Main.Values.ValueDouble;
import de.Client.Utils.TimeHelper;
import net.minecraft.block.Block;
import net.minecraft.block.BlockAir;
import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.ScaledResolution;
import net.minecraft.entity.Entity;
import net.minecraft.entity.projectile.EntitySnowball;
import net.minecraft.init.Blocks;
import net.minecraft.item.ItemBlock;
import net.minecraft.item.ItemStack;
import net.minecraft.network.play.client.*;
import net.minecraft.potion.Potion;
import net.minecraft.util.BlockPos;
import net.minecraft.util.EnumFacing;
import net.minecraft.util.MathHelper;
import net.minecraft.util.Vec3;
import org.lwjgl.opengl.GL11;

import java.math.BigDecimal;
import java.math.RoundingMode;


public class ScaffoldWalk
  extends Module
{
  public static boolean Eagle = false;
  public static boolean ScaffoldWalk = true;
  public static ValueBoolean jump = new ValueBoolean("Jump", false);
  public static long placeDelay = 5L;
  public static float[] values = { 0.0F, 0.0F };
  public static ValueBoolean Safewalk = new ValueBoolean("Safewalk", true);
  public int startposY;
  public ValueBoolean Silent = new ValueBoolean("Silent", true);
    public ValueBoolean PSave = new ValueBoolean("PSave", true);
  public ValueBoolean AAC = new ValueBoolean("AAC", true);
  public ValueBoolean TAC = new ValueBoolean("TAC", true);
  public ValueBoolean SlowMode = new ValueBoolean("SlowMode", false);
  public ValueDouble SlowModeTime = new ValueDouble("SlowModeTime", 1000.0D, 1000.0D, 1000.0D);
  public ValueDouble SlowModeBlock = new ValueDouble("SlowModeBlock", 3.0D, 10.0D, 10.0D);
  public int blockcounter;
  public boolean nextTick;
  public BlockPos postoLook;
  public int blockposy;
	public double rotation;
    public int ticktoWait;
  private float lastYaw;
  private float lastPitch;
  private BlockData blockData = null;
  private TimeHelper time = new TimeHelper();
  public ScaffoldWalk()
  {
    super("Scaffoldwalk", Category.WORLD, 0);
    addValue(TAC);
    addValue(AAC);
      addValue(Silent);
    addValue(this.PSave);
    addValue(this.SlowMode);
    addValue(this.SlowModeBlock);
    addValue(this.SlowModeTime);
    addValue(jump);
    addValue(Safewalk);
    this.displayName = "Scaffold Walk";
  }

  public static Block getBlock(BlockPos pos)
	{
    	return Minecraft.getMinecraft().theWorld.getBlockState(pos).getBlock();
	}

  @EventTarget
  public void setRotation(PacketSendEvent event)
  {
      if(this.AAC.getValue()){
          if(!Eagle){
              return;
          }
          if(mc.theWorld.getBlockState(this.blockData.position).getBlock() == Blocks.air){
              return;
          }
      }


    if ((event.getPacket() instanceof C03PacketPlayer))
    {
        if(!this.AAC.getValue()){
      C03PacketPlayer p = (C03PacketPlayer)event.getPacket();

      p.pitch = 65.0F;
      p.yaw += 180.0F;
      event.setPacket(p);

        }else{


        	//mc.thePlayer.rotationPitch = this.getFacingRotations(this.blockData.position.x,this.blockData.position.y, this.blockData.position.z, this.blockData.face)[1];

        		   C03PacketPlayer p = (C03PacketPlayer)event.getPacket();
        		p.pitch  = 83.24f;
        	//	mc.thePlayer.rotationPitch =  this.getFacingRotations(this.blockData.position.x,this.blockData.position.y, this.blockData.position.z, this.blockData.face)[1];
        		p.yaw = (float) rotation+180;
        		//mc.thePlayer.rotationYaw= (float) this.rotation;


        		p.field_149474_g = true;
        		   event.setPacket(p);

        }
    }
  }
  
  public  float[] getFacingRotations(int x, int y, int z, EnumFacing facing)
  {
	    double diffX = x - (mc.thePlayer.posX)+0.5;
        double diffZ = z -(mc.thePlayer.posZ)+0.5;
        double diffY;

        diffY = y- 0.5-(mc.thePlayer.posY);

        double dist = MathHelper.sqrt_double(diffX * diffX + diffZ * diffZ);
        float yaw = (float)(Math.atan2(diffZ, diffX) * 180.0 /    3.141592653589793) - 90.0f;
        float pitch = (float)(- Math.atan2(diffY, dist) * 180.0 / 3.141592653589793);
        return new float[]{mc.thePlayer.rotationYaw + MathHelper.wrapAngleTo180_float(yaw - mc.thePlayer.rotationYaw), mc.thePlayer.rotationPitch + MathHelper.wrapAngleTo180_float(pitch - mc.thePlayer.rotationPitch)};

	  }
  
  public  float[] getAngles(Entity e)
  {
    return new float[] { getYawChangeToEntity(e) + mc.thePlayer.rotationYaw, getPitchChangeToEntity(e) + mc.thePlayer.rotationPitch };
  }

  public  boolean isatEdge(){
	  return false;
  }
  
  public  float getYawChangeToEntity(Entity entity)
  {
    double deltaX = entity.posX - mc.thePlayer.posX;
    double deltaZ = entity.posZ - mc.thePlayer.posZ;

    double yawToEntity1 = 0.0D;
    if ((deltaZ < 0.0D) && (deltaX < 0.0D))
    {
      yawToEntity1 = 90.0D + Math.toDegrees(Math.atan(deltaZ / deltaX));
    }
    else
    {
      double yawToEntity11;
      if ((deltaZ < 0.0D) && (deltaX > 0.0D)) {
        yawToEntity11 = -90.0D + Math.toDegrees(Math.atan(deltaZ / deltaX));
      } else {
        yawToEntity11 = Math.toDegrees(-Math.atan(deltaX / deltaZ));
      }
    }
    return MathHelper.wrapAngleTo180_float(-(mc.thePlayer.rotationYaw - (float)yawToEntity1));
  }

  public float getPitchChangeToEntity(Entity entity)
  {
    double deltaX = entity.posX - mc.thePlayer.posX;
    double deltaZ = entity.posZ - mc.thePlayer.posZ;
    double deltaY = entity.posY - 1.6D + entity.getEyeHeight() - mc.thePlayer.posY;
    double distanceXZ = MathHelper.sqrt_double(deltaX * deltaX + deltaZ * deltaZ);

    double pitchToEntity = -Math.toDegrees(Math.atan(deltaY / distanceXZ));

    return -MathHelper.wrapAngleTo180_float(mc.thePlayer.rotationPitch - (float)pitchToEntity);
  }

  @EventTarget
  public void swingarm(UpdateEvent event)
  {

    if (ScaffoldWalk)
    {
      if (this.AAC.getValue() || (!mc.thePlayer.isSneaking()))
      {
    	  int y = (int) mc.thePlayer.posY;
    	  if(jump.getValue()){
    		  y = this.blockposy+1;
    	  }
        BlockPos bpos = new BlockPos(mc.thePlayer.posX, y - 1.0D,
          mc.thePlayer.posZ);

        if(mc.theWorld.getBlockState( new BlockPos(mc.thePlayer.posX, y - 1.0D,mc.thePlayer.posZ+1)).getBlock() == Blocks.air){
        	 if(mc.theWorld.getBlockState( new BlockPos(mc.thePlayer.posX, y - 1.0D,mc.thePlayer.posZ-1)).getBlock() == Blocks.air){
        		 if(mc.theWorld.getBlockState( new BlockPos(mc.thePlayer.posX+1, y - 1.0D,mc.thePlayer.posZ)).getBlock() == Blocks.air){
        			 if(mc.theWorld.getBlockState( new BlockPos(mc.thePlayer.posX-1, y - 1.0D,mc.thePlayer.posZ)).getBlock() == Blocks.air){
        			//     SunAPI.sendChatMessageWithPR("Detected Impossible blockpos - trying to find a save one");
        				 if(mc.theWorld.getBlockState( new BlockPos(mc.thePlayer.posX+1, y- 1.0D,mc.thePlayer.posZ+1)).getBlock() != Blocks.air){
        					 bpos = new BlockPos(mc.thePlayer.posX, y- 1.0D,mc.thePlayer.posZ+1);
        				 }
        				 if(mc.theWorld.getBlockState( new BlockPos(mc.thePlayer.posX-1, y - 1.0D,mc.thePlayer.posZ-1)).getBlock() != Blocks.air){
        					 bpos = new BlockPos(mc.thePlayer.posX, y - 1.0D,mc.thePlayer.posZ-1);
        				 }
        				 if(mc.theWorld.getBlockState( new BlockPos(mc.thePlayer.posX+1, y - 1.0D,mc.thePlayer.posZ-1)).getBlock() != Blocks.air){
        					 bpos = new BlockPos(mc.thePlayer.posX+1, y - 1.0D,mc.thePlayer.posZ);
        				 }
        				 if(mc.theWorld.getBlockState( new BlockPos(mc.thePlayer.posX-1, y - 1.0D,mc.thePlayer.posZ+1)).getBlock() != Blocks.air){
        					 bpos = new BlockPos(mc.thePlayer.posX-1,y - 1.0D,mc.thePlayer.posZ);
        				 }
        			 }
        		 }
        	 }



        }

        this.blockData = getBlockData(bpos);
        if (this.blockData != null) {
          values = getFacingRotations1(this.blockData.position.getX(),
            this.blockData.position.getY(), this.blockData.position.getZ(), EnumFacing.DOWN);
        }
      }
    }
  }

	public float[] getFacingRotations1(int x, int y, int z, EnumFacing facing) {
		Entity temp = new EntitySnowball(mc.theWorld);
		temp.posX = (x + 0.5D);
		temp.posY = (y + 0.5D);
		temp.posZ = (z + 0.5D);
		temp.posX += facing.getDirectionVec().getX() * 0.25D;
		temp.posY += facing.getDirectionVec().getY() * 0.25D;
		temp.posZ += facing.getDirectionVec().getZ() * 0.25D;
		return getAngles(temp);
	}

  @EventTarget
  public void onRenderHud(EventRenderScreen e){
	  ScaledResolution sr = new ScaledResolution();
	  startposY = 0;
	  for(int i = 0; i <mc.thePlayer.inventory.mainInventory.length;++i){

		  if(mc.thePlayer.inventory.mainInventory[i] != null){
				if(mc.thePlayer.inventory.mainInventory[i].getItem() instanceof ItemBlock){
					startposY +=mc.thePlayer.inventory.mainInventory[i].stackSize ;

				}
		  }
	  }
	  GL11.glPushMatrix();
	  GL11.glScaled(1.3, 1.3, 1.3);
	  //fr.drawStringWithShadow("�6" + this.startposY, ((int)((sr.getScaledWidth()/2-10-fr.getStringWidth( this.startposY+""))/1.3f)), ((int)(sr.getScaledHeight()/2-4)/1.3f), 0xffffffff);
	  GL11.glScaled(1, 1, 1);
	  GL11.glPopMatrix();
  }

  public void onRender(){
	  if(!this.getState()){
      }

  }

  @Override
  public void onEnable(){
	  if(mc.thePlayer != null){
	  blockposy = (int) (mc.thePlayer.posY-1);
	  }
	  super.onEnable();
  }

    private double getBaseMoveSpeed() {
        double baseSpeed = 0.2873D;
        if (this.mc.thePlayer.isPotionActive(Potion.moveSpeed)) {
            int amplifier = this.mc.thePlayer.getActivePotionEffect(
                    Potion.moveSpeed).getAmplifier();
            baseSpeed *= (1.0D + 0.2D * (amplifier + 1));
        }
        return baseSpeed;
    }

  @EventTarget
  public void onMove(MoveEvent e){

      if(this.AAC.getValue()){
          mc.thePlayer.setSprinting(false);
          int yaw = 0;
          double rotation2 = mc.thePlayer.rotationYaw > 0 ? -mc.thePlayer.rotationYaw : mc.thePlayer.rotationYaw;
          boolean reverse =  mc.thePlayer.rotationYaw > 0;
          double rotation = ((int)rotation2 % 360)*-1;

          if(rotation <= 45 || rotation > 315){
              yaw = 0;
          }
          if(rotation > 45 && rotation < 135){

              yaw = 90;
          }
          if(rotation >= 135 && rotation < 225){

              yaw = 180;
          }
          if(rotation >= 225 && rotation <= 315){

              yaw = 270;
          }
          if(!reverse){
              yaw *=-1;
          }

          this.rotation = yaw;
          yaw += 45;
            double speed = this.getBaseMoveSpeed()/1.67;

          e.setX(mc.thePlayer.moveForward * speed * Math.cos(Math.toRadians(yaw + 90.0f)) + mc.thePlayer.moveForward * speed * Math.sin(Math.toRadians(yaw + 90.0f)));
          e.setZ(mc.thePlayer.moveForward * speed * Math.sin(Math.toRadians(yaw + 90.0f)) - mc.thePlayer.moveForward *speed * Math.cos(Math.toRadians(yaw + 90.0f)));

          double blocks = 0.05;
          double x = Math.cos(Math.toRadians(this.rotation+ 90.0F));
          double z = Math.sin(Math.toRadians(this.rotation + 90.0F));
          double y = mc.thePlayer.posY;

          // mc.thePlayer.setPosition(Wrapper.mc.thePlayer.posX + (1.0D * blocks * x + 0.0D * blocks * z), Wrapper.mc.thePlayer.posY, Wrapper.mc.thePlayer.posZ + (1.0D * blocks * z - 0.0D * blocks * x));


          if(mc.theWorld.getBlockState(new BlockPos(mc.thePlayer.posX+ (1.0D * blocks * x + 0.0D * blocks * z),mc.thePlayer.posY-1,mc.thePlayer.posZ+ (1.0D * blocks * z - 0.0D * blocks * x))).getBlock() instanceof BlockAir){
              this.ticktoWait ++;
          }else{
              this.ticktoWait = 0;
          }
          if(ticktoWait > 0){
              this.Eagle = true;
          }else{
              this.Eagle = false;
          }

      }

  }

  public void onUpdate()
  {
      mc.timer.timerSpeed = 1;
	  try{
	 //SunAPI.sendChatMessage(""+this.Eagle);
	 if(AAC.getValue()){
	     if(!this.Eagle){
	         return;
         }
     }
     if(!this.Silent.getValue()){
	     if(mc.thePlayer.getCurrentEquippedItem() == null){
	         return;
         }
         if(!(mc.thePlayer.getCurrentEquippedItem().getItem() instanceof ItemBlock)){
             return;
         }
     }
		
	   
	  if(jump.getValue()){
		  if(mc.thePlayer.onGround){
			  blockposy =  (int) (mc.thePlayer.posY-1) ;
		  }
	
	  }else{
		  blockposy =  this.blockData.position.y ;
	  }


	  
		   
		
		      
	  boolean hasempyslot = false;
	  boolean noitemsleft = true;
	  ItemStack itemstacktouse = null;
        boolean needtoplace =  mc.theWorld.getBlockState(this.blockData.position).getBlock() == Blocks.air;

          if(this.AAC.getValue()){
              if(!Eagle){
                  return;
              }
              if(mc.theWorld.getBlockState(this.blockData.position).getBlock() == Blocks.air){
                  return;
              }
          }
		  int i2 = 8888;
	  for(int i = 0; i <mc.thePlayer.inventory.mainInventory.length;++i){
		
		  if(i < 9){
			if(mc.thePlayer.inventory.mainInventory[i] != null){
				if(mc.thePlayer.inventory.mainInventory[i].getItem() instanceof ItemBlock){
					if(((ItemBlock)mc.thePlayer.inventory.mainInventory[i].getItem()).getBlock().isFullBlock() && ((ItemBlock)mc.thePlayer.inventory.mainInventory[i].getItem()).getBlock() != Blocks.command_block ||((ItemBlock)mc.thePlayer.inventory.mainInventory[i].getItem()).getBlock() == Blocks.glass ){
					if(Eagle || !this.AAC.getValue()){
					i2 = i;
					}
					itemstacktouse = mc.thePlayer.inventory.mainInventory[i];
					noitemsleft = false;
				}
				}
			}else{
				hasempyslot = true;
				
			}
		  }else{
			  if(hasempyslot &&noitemsleft){
					if(mc.thePlayer.inventory.mainInventory[i] != null){
				  if(mc.thePlayer.inventory.mainInventory[i].getItem() instanceof ItemBlock){
					  
				  mc.playerController.windowClick(0, i, 1, 1, mc.thePlayer);
				 
				 
			
				  }
					}
			  }
		  }
	  }
	  if(i2 != 8888){
	      if(this.Silent.getValue()) {
              mc.thePlayer.sendQueue.addToSendQueue(new C09PacketHeldItemChange(i2));
          }

	  }
	  
		
	  if(itemstacktouse == null){
	  }
    if ((this.blockcounter >= this.SlowModeBlock.getValue()) && (this.SlowMode.getValue()))
    {
      this.time.reset();
      this.blockcounter = 0;
    }
   
    try
    {
      if ((!mc.thePlayer.isSneaking())) {
        this.lastPitch += 1.0F;
      }
      if(this.AAC.getValue()){
      BlockPos blockPos = new BlockPos(mc.thePlayer.posX, mc.thePlayer.posY - 1.0D, mc.thePlayer.posZ);
		if (mc.thePlayer.fallDistance <= 4.0F) {
			if ((mc.theWorld.getBlockState(blockPos).getBlock() != Blocks.air)) {
				return;
				
			}
		}
      }
      if ((this.time.hasReached((long) this.SlowModeTime.getValue())) || (!this.SlowMode.getValue()))
      {

        Vec3 vector =  new Vec3(this.blockData.position.getX(), this.blockData.position.getY(), this.blockData.position.getZ());
        float var7 = (float)(vector.xCoord - (double)this.blockData.position.getX());
        float var8 = (float)(vector.yCoord - (double)this.blockData.position.getY());
        float var9 = (float)(vector.zCoord - (double)this.blockData.position.getZ());
        
        
        
        


        if(this.PSave.getValue()){
        mc.thePlayer.sendQueue.addToSendQueue(new C08PacketPlayerBlockPlacement(this.blockData.position, this.blockData.face.getIndex(), itemstacktouse, var7, var8, var9));
        }else{
        	 
        	if(this.TAC.getValue()){
        		


        		mc.thePlayer.sendQueue.addToSendQueue(new C0BPacketEntityAction(mc.thePlayer,C0BPacketEntityAction.Action.STOP_SPRINTING));	
        				mc.thePlayer.sendQueue.addToSendQueue(new C0BPacketEntityAction(mc.thePlayer,C0BPacketEntityAction.Action.START_SPRINTING));
        			
        			
        		 
        		    
        	}
        	if(Silent.getValue()) {
                mc.playerController.func_178890_a(mc.thePlayer, mc.theWorld, itemstacktouse, this.blockData.position, this.blockData.face, new Vec3(this.blockData.position.getX(), this.blockData.position.getY(), this.blockData.position.getZ()));
            }else{
                mc.playerController.func_178890_a(mc.thePlayer, mc.theWorld, mc.thePlayer.getCurrentEquippedItem(), this.blockData.position, this.blockData.face, new Vec3(this.blockData.position.getX(), this.blockData.position.getY(), this.blockData.position.getZ()));
            }
      
          
        }

        	mc.thePlayer.sendQueue.addToSendQueue(new C0APacketAnimation() );
          this.blockcounter += 1;
 
      
      }
    }
    catch (Exception ignored) {}
    if(this.Silent.getValue()) {
        mc.thePlayer.sendQueue.addToSendQueue(new C09PacketHeldItemChange(mc.thePlayer.inventory.currentItem));
    }
	  }catch(Exception ignored){
	  
	  }
  }
  
 
  
  @EventTarget
  public void onPostMotionUpdate(PreSendMotion event)
  {
    if (ScaffoldWalk)
    {
      if (mc.theWorld == null) {
        return;
      }
      if(this.AAC.getValue()){
      }
    }
  }
  
  public BlockData getBlockData(BlockPos pos)
  {
    return 
    
      mc.theWorld.getBlockState(pos.add(0, -1, 0)).getBlock() != Blocks.air ? 
      new BlockData(pos.add(0, -1, 0), EnumFacing.UP) : mc.theWorld.getBlockState(pos.add(-1, 0, 0)).getBlock() != Blocks.air ? new BlockData(pos.add(-1, 0, 0), EnumFacing.EAST) : mc.theWorld.getBlockState(pos.add(1, 0, 0)).getBlock() != Blocks.air ? new BlockData(pos.add(1, 0, 0), EnumFacing.WEST) : mc.theWorld.getBlockState(pos.add(0, 0, -1)).getBlock() != Blocks.air ? new BlockData(pos.add(0, 0, -1), EnumFacing.SOUTH) : mc.theWorld.getBlockState(pos.add(0, 0, 1)).getBlock() != Blocks.air ? new BlockData(pos.add(0, 0, 1), EnumFacing.NORTH) : new BlockData(pos.add(0, -1, 0), EnumFacing.UP);
  }
}
class BlockData {
	public BlockPos position;
	public EnumFacing face;

	public BlockData(BlockPos position, EnumFacing face) {
		this.position = position;
		this.face = face;
	}
}

minecraft_de_Client_Main_Modules_mods_World_Speedmine.java

package de.Client.Main.Modules.mods.World;

import de.Client.Events.EventTarget;
import de.Client.Events.Events.PacketReceiveEvent;
import de.Client.Main.Main;
import de.Client.Main.Modules.Category;
import de.Client.Main.Modules.Module;
import de.Client.Main.Values.ValueBoolean;
import de.Client.Render.ClickGui.Panels.Mini;
import de.Client.Render.ClickGui.Panels.Minitypes.MiniOneOfTwo;
import de.Client.Utils.Macro;
import net.minecraft.client.entity.EntityPlayerSP;
import net.minecraft.client.network.NetworkPlayerInfo;
import net.minecraft.entity.Entity;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.ItemFishingRod;
import net.minecraft.network.play.client.*;
import net.minecraft.network.play.server.S0CPacketSpawnPlayer;
import net.minecraft.network.play.server.S18PacketEntityTeleport;
import net.minecraft.util.EnumFacing;
import org.lwjgl.Sys;
import org.lwjgl.input.Controller;
import org.lwjgl.input.Controllers;
import org.lwjgl.input.Keyboard;

import java.util.ArrayList;



public class Speedmine extends Module {

    public Speedmine() {
        super("Speedmine", Category.WORLD, Keyboard.KEY_Y);
        // TODO Auto-generated constructor stub
        addValue(AAC);
        addValue(NCP);
    }

    public ValueBoolean AAC = new ValueBoolean("AAC",true);
    public ValueBoolean NCP = new ValueBoolean("NCP",false);
    @Override
    public ArrayList<Mini> createArray(){
        ArrayList<Mini> minis = new ArrayList<>();
        minis.add( new MiniOneOfTwo(this,AAC,NCP));
        return minis;
    }
    @Override
    public void onUpdate() {
        try {
            if(this.NCP.getValue()) {
                mc.playerController.blockHitDelay = 0;
                mc.playerController.curBlockDamageMP += mc.theWorld.getBlockState(mc.objectMouseOver.func_178782_a())
                        .getBlock().getPlayerRelativeBlockHardness(this.mc.thePlayer, this.mc.thePlayer.worldObj, mc.objectMouseOver.func_178782_a()) / 10;
                if (mc.theWorld.getBlockState(mc.objectMouseOver.func_178782_a())
                        .getBlock().getPlayerRelativeBlockHardness(this.mc.thePlayer, this.mc.thePlayer.worldObj, mc.objectMouseOver.func_178782_a()) > 0.2) {
                    mc.playerController.curBlockDamageMP += 0.2;
                }
            }
            if (AAC.getValue()) {
                if(mc.playerController.curBlockDamageMP > 0.0) {
                    mc.thePlayer.sendQueue.addToSendQueue(new C0APacketAnimation());
                    mc.thePlayer.sendQueue.addToSendQueue(new C0APacketAnimation());
                    mc.playerController.curBlockDamageMP +=0.009;
                }


                if(mc.playerController.blockHitDelay > 3){
                    mc.playerController.blockHitDelay = 3;
                }
            }

        }catch (Exception e){

        }
    }



}

minecraft_de_Client_Main_Modules_mods_World_Tower.java

package de.Client.Main.Modules.mods.World;

import java.util.ArrayList;


import de.Client.Events.EventTarget;
import de.Client.Events.Events.MoveEvent;
import de.Client.Events.Events.PacketSendEvent;
import de.Client.Events.Events.PreSendMotion;
import de.Client.Main.Modules.Category;
import de.Client.Main.Modules.Module;
import de.Client.Main.Values.ValueBoolean;
import de.Client.Utils.RotationUtil;
import de.Client.Utils.TimeHelper;
import net.minecraft.block.BlockAir;
import net.minecraft.block.state.IBlockState;
import net.minecraft.client.entity.EntityPlayerSP;
import net.minecraft.init.Blocks;
import net.minecraft.item.ItemBlock;
import net.minecraft.item.ItemStack;
import net.minecraft.network.play.client.C03PacketPlayer;
import net.minecraft.network.play.client.C03PacketPlayer.C06PacketPlayerPosLook;
import net.minecraft.network.play.client.C09PacketHeldItemChange;
import net.minecraft.network.play.client.C0APacketAnimation;
import net.minecraft.util.BlockPos;
import net.minecraft.util.EnumFacing;
import net.minecraft.util.Vec3;

public class Tower extends Module {



    public static ValueBoolean motion = new ValueBoolean("motion",false);
    public static ValueBoolean teleport = new ValueBoolean("teleport",false);
    public static ValueBoolean Other = new ValueBoolean("Other",false);
    public static ValueBoolean jump = new ValueBoolean("jump",false);
    public static ValueBoolean aac = new ValueBoolean("teleport",false);
    public static ValueBoolean spartan = new ValueBoolean("lowjump",false);
    public static ValueBoolean nyra = new ValueBoolean("nyra",false);
    public Tower() {
        super("Tower", Category.WORLD,0);
        addValue(jump);
        addValue(teleport);
        addValue(motion);
        addValue(this.aac);
        addValue(this.Other);
        addValue(this.spartan);
        addValue(this.nyra);
    }

    public static boolean Eagle = false;
    public static boolean ScaffoldWalk = true;
    public static ValueBoolean nullDelay = new ValueBoolean("Null Delay", false);

    // Standart: 75L
    public static long placeDelay = 5L;

    public static float[] values = { 0.0F, 0.0F };
    private float lastYaw;
    private float lastPitch;

    private BlockData blockData = null;
    private TimeHelper time = new TimeHelper();
    private boolean dont;
    private int cooldown;
    private int delay;
    private boolean performJump;
    @Override
    public void onDisable(){
        mc.timer.timerSpeed = 1;
        super.onDisable();
    }
    @EventTarget
    public void setRotation(PacketSendEvent event) {

        if(event.getPacket() instanceof C03PacketPlayer){
            C03PacketPlayer p = (C03PacketPlayer) event.getPacket();
            p.pitch = 90;
            event.setPacket(p);
        }
    }


    @EventTarget
    public void onMove(MoveEvent e){

    }

    private ArrayList<BlockPos> getCollisionBlocks1()
    {
        ArrayList<BlockPos> collidedBlocks = new ArrayList();
        EntityPlayerSP p = mc.thePlayer;
        int var3 = (int)Math.floor(p.posX);
        while (var3 <= (int)Math.floor(p.posX))
        {
            int var4 = (int)p.posY - 1;
            while (var4 <= (int)p.posY)
            {
                int var5 = (int)Math.floor(p.posZ);
                while (var5 <= (int)Math.floor(p.posZ))
                {
                    BlockPos blockPos = new BlockPos(var3, var4, var5);
                    try
                    {
                        if ((var4 > p.posY - 2.0D) && (var4 <= p.posY - 1.0D)) {
                            collidedBlocks.add(blockPos);
                        }
                    }
                    catch (Throwable localThrowable) {}
                    var5++;
                }
                var4++;
            }
            var3++;
        }
        return collidedBlocks;
    }

    private ArrayList<BlockPos> getCollisionBlocks()
    {
        ArrayList<BlockPos> collidedBlocks = new ArrayList();
        EntityPlayerSP p = mc.thePlayer;
        for (int var3 = (int)Math.floor(p.posX); var3 <= (int)Math.floor(p.posX); var3++) {
            for (int var4 = (int)p.posY - 1; var4 <= (int)p.posY; var4++) {
                for (int var5 = (int)Math.floor(p.posZ); var5 <= (int)Math.floor(p.posZ); var5++)
                {
                    BlockPos blockPos = new BlockPos(var3, var4, var5);
                    try
                    {
                        if ((var4 > p.posY - 2.0D) && (var4 <= p.posY - 1)) {
                            collidedBlocks.add(blockPos);
                        }
                    }
                    catch (Throwable localThrowable) {}
                }
            }
        }
        return collidedBlocks;
    }
    @Override
    public void onUpdate() {
        try {
            if (this.nyra.getValue()) {
                {
                    ++this.lastPitch;

                    EntityPlayerSP p = mc.thePlayer;
                    mc.thePlayer.motionX *= 0.0D;
                    mc.thePlayer.motionZ *= 0.0D;
                    if (p.onGround) {
                        mc.thePlayer.motionX *= 0.0D;
                        mc.thePlayer.motionZ *= 0.0D;
                        p.motionY = 0.42;

                    }

                    ArrayList<BlockPos> collisionBlocks = getCollisionBlocks();
                    for (BlockPos pos : collisionBlocks) {
                        IBlockState state = p.worldObj.getBlockState(pos);
                        if ((state.getBlock() instanceof BlockAir)) {


                            mc.thePlayer.swingItem();

                            p.motionY = -5000.0D;

                        } else {
                            mc.thePlayer.motionY += 0.1;
                        }

                    }
                }
            }


            boolean hasempyslot = false;
            boolean noitemsleft = true;
            ItemStack itemstacktouse = null;
            int itemtouse = 0;

            for (int i = 0; i < mc.thePlayer.inventory.mainInventory.length; ++i) {

                if (i < 9) {
                    if (mc.thePlayer.inventory.mainInventory[i] != null) {
                        if (mc.thePlayer.inventory.mainInventory[i].getItem() instanceof ItemBlock && ((ItemBlock) mc.thePlayer.inventory.mainInventory[i].getItem()).getBlock() != Blocks.command_block) {
                            itemtouse = i;
                            itemstacktouse = mc.thePlayer.inventory.mainInventory[i];
                            noitemsleft = false;
                        }
                    } else {
                        hasempyslot = true;

                    }
                } else {
                    if (hasempyslot && noitemsleft) {
                        if (mc.thePlayer.inventory.mainInventory[i] != null) {
                            if (mc.thePlayer.inventory.mainInventory[i].getItem() instanceof ItemBlock && ((ItemBlock) mc.thePlayer.inventory.mainInventory[i].getItem()).getBlock() != Blocks.command_block) {

                                mc.playerController.windowClick(0, i, 1, 1, mc.thePlayer);
                                return;


                            }
                        }
                    }
                }
            }
            mc.thePlayer.sendQueue.addToSendQueue(new C09PacketHeldItemChange(itemtouse));
            // this.setModuleDisplayName(this.getModuleName() + "§8 " + this.mode());

            try {


                if (itemstacktouse != null) {
                    ++this.lastPitch;
                    if (this.jump.getValue()) {
                        {
                            ++this.lastPitch;
                            if (this.jump.getValue()) {
                                EntityPlayerSP p = mc.thePlayer;
                                mc.thePlayer.motionX *= 0.0D;
                                mc.thePlayer.motionZ *= 0.0D;
                                if (p.onGround) {
                                    mc.thePlayer.motionX *= 0.0D;
                                    mc.thePlayer.motionZ *= 0.0D;
                                    p.jump();
                                    p.jump();
                                    p.jump();
                                }
                                ArrayList<BlockPos> collisionBlocks = getCollisionBlocks();
                                for (BlockPos pos : collisionBlocks) {
                                    IBlockState state = p.worldObj.getBlockState(pos);
                                    if ((state.getBlock() instanceof BlockAir)) {


                                        mc.thePlayer.swingItem();

                                        p.motionY = -5.0D;
                                    }
                                }

                            }
                        }
                    }

                    if (this.spartan.getValue()) {
                        this.mc.thePlayer.swingItem();
                        if (mc.thePlayer.onGround) {
                            mc.thePlayer.motionY = 0.3682;
                        } else {

                        }
                        if (this.mc.playerController.func_178890_a(mc.thePlayer, mc.theWorld, this.mc.thePlayer.getHeldItem(), this.blockData.position, this.blockData.face, new Vec3(this.blockData.position.getX(), mc.thePlayer.posY, this.blockData.position.getZ()))) {
                            this.mc.thePlayer.swingItem();
                        }
                    }

                    if (this.aac.getValue()) {


                        EntityPlayerSP player = mc.thePlayer;
                        if (player.getHeldItem() != null && player.getHeldItem().getItem() instanceof ItemBlock && mc.gameSettings.keyBindJump.pressed) {
                            if (true) {
                                BlockPos playerPos = new BlockPos(player.posX, player.posY, player.posZ);

                                if (true) {
                                    if (player.onGround) {
                                        player.jump();
                                        player.motionX = player.motionZ = 0.0D;
                                        this.dont = true;
                                        this.dont = false;
                                    }
                                } else if (player.onGround) {
                                    player.jump();
                                    player.motionX = player.motionZ = 0.0D;
                                    this.dont = true;
                                    player.onUpdate();
                                    this.dont = false;
                                }
                            } else {

                            }

                            if (player.onGround && this.cooldown <= 0) {
                                player.sendQueue.addToSendQueue(new C06PacketPlayerPosLook(player.posX, player.posY + 0.42D, player.posZ, player.rotationYaw, Math.max(player.rotationPitch, 30.0F), false));
                                player.sendQueue.addToSendQueue(new C06PacketPlayerPosLook(player.posX, player.posY + 0.75D, player.posZ, player.rotationYaw, 90.0F, false));
                                mc.thePlayer.setPositionAndUpdate(mc.thePlayer.posX, mc.thePlayer.posY + 1, mc.thePlayer.posZ);
                                player.motionY = 0.0D;

                                this.cooldown = 2;

                            } else {
                                player.motionY = -1.0D;
                                player.motionX = 0.0D;
                                player.motionZ = 0.0D;
                                if (this.cooldown > 0) {
                                    --this.cooldown;
                                }
                            }


                        }
                    }


                    if (this.motion.getValue()) {
                        EntityPlayerSP p = mc.thePlayer;
                        mc.thePlayer.motionX *= 0.0D;
                        mc.thePlayer.motionZ *= 0.0D;
                        if (p.onGround) {
                            mc.thePlayer.motionX *= 0.0D;
                            mc.thePlayer.motionZ *= 0.0D;
                            p.jump();
                            p.jump();
                            p.jump();
                            mc.timer.timerSpeed = 1f;
                        }
                        ArrayList<BlockPos> collisionBlocks = getCollisionBlocks();
                        for (BlockPos pos : collisionBlocks) {
                            IBlockState state = p.worldObj.getBlockState(pos);
                            if ((state.getBlock() instanceof BlockAir)) {


                                mc.thePlayer.swingItem();
                                mc.timer.timerSpeed = 5f;
                                p.motionY = -5.0D;
                            }
                        }

                    }


                    if (this.mc.playerController.func_178890_a(mc.thePlayer, mc.theWorld, this.mc.thePlayer.getHeldItem(), this.blockData.position.add(0, -1, 0), this.blockData.face, new Vec3(this.blockData.position.getX(), mc.thePlayer.posY, this.blockData.position.getZ()))) {
                        this.mc.thePlayer.swingItem();
                    }

                }

                if (mc.gameSettings.keyBindJump.pressed) {
                    if (this.mc.playerController.func_178890_a(mc.thePlayer, mc.theWorld, this.mc.thePlayer.getHeldItem(), this.blockData.position, this.blockData.face, new Vec3(this.blockData.position.getX(), mc.thePlayer.posY, this.blockData.position.getZ()))) {
                        this.mc.thePlayer.swingItem();
                    }
                }
            } catch (Exception e) {
            }

            BlockPos player = new BlockPos(mc.thePlayer.posX, mc.thePlayer.posY - 1.0D,
                    mc.thePlayer.posZ);
            this.blockData = getBlockData(player);
            if (itemstacktouse.getItem() instanceof ItemBlock && blockData != null) {
                if (mc.playerController.func_178890_a(mc.thePlayer, mc.theWorld, itemstacktouse, this.blockData.position, this.blockData.face, new Vec3(this.blockData.position.getX(), this.blockData.position.getY(), this.blockData.position.getZ())))
                    ;
                mc.thePlayer.sendQueue.addToSendQueue(new C0APacketAnimation());
            }

            mc.thePlayer.sendQueue.addToSendQueue(new C09PacketHeldItemChange(mc.thePlayer.inventory.currentItem));
        }catch (Exception e){
            
        }


    }






    @EventTarget
    public void packetlook(PacketSendEvent event) {
        if (this.ScaffoldWalk) {
            if ((event.getPacket() instanceof C03PacketPlayer)) {
                C03PacketPlayer player1 = (C03PacketPlayer) event.getPacket();
                if (this.blockData == null) {
                    return;
                }

                values = RotationUtil.getFacingRotations(this.blockData.position.getX(), this.blockData.position.getY(),
                        this.blockData.position.getZ(), this.blockData.face);
                player1.yaw = values[0];
                player1.pitch = values[1];
            }
        }
    }

    @EventTarget
    public void onPostMotionUpdate(MoveEvent event) {
        if(this.Other.getValue()){
            EntityPlayerSP p = mc.thePlayer;
            if (this.delay > 2) {
                this.delay -= 1;
            }
            if ((p.onGround) && (this.delay <= 2)) {
                this.performJump = true;
            }
            if ((this.performJump) && (this.delay <= 100))
            {
                p.motionY = 0.5D;
                ArrayList<BlockPos> collisionBlocks = getCollisionBlocks1();
                for (BlockPos pos : collisionBlocks)
                {
                    IBlockState state = p.worldObj.getBlockState(pos);
                    if ((state.getBlock() instanceof BlockAir))
                    {
                        mc.thePlayer.sendQueue.netManager.sendPacket(new C03PacketPlayer.C05PacketPlayerLook(0.0F, 90.0F, true));
                        mc.playerController.func_178890_a(mc.thePlayer, mc.theWorld, mc.thePlayer.inventory.getCurrentItem(), pos.add(0, -1, 0), EnumFacing.UP, new Vec3(pos.getX(), pos.getY(), pos.getZ()));
                        mc.thePlayer.swingItem();
                        p.motionY = 0.0D;
                        this.delay = 5;
                    }
                }
                return;
            }
        }
    }


    public BlockData getBlockData(BlockPos pos) {
        return this.mc.theWorld.getBlockState(pos.add(0, 0, 1)).getBlock() != Blocks.air
                ? new BlockData(pos.add(0, 0, 1), EnumFacing.NORTH)
                : this.mc.theWorld.getBlockState(pos.add(0, 0, -1)).getBlock() != Blocks.air
                ? new BlockData(pos.add(0, 0, -1), EnumFacing.SOUTH)
                : this.mc.theWorld.getBlockState(pos.add(1, 0, 0)).getBlock() != Blocks.air
                ? new BlockData(pos.add(1, 0, 0), EnumFacing.WEST)
                : this.mc.theWorld.getBlockState(pos.add(-1, 0, 0)).getBlock() != Blocks.air
                ? new BlockData(pos.add(-1, 0, 0), EnumFacing.EAST)
                : this.mc.theWorld.getBlockState(pos.add(0, -1, 0)).getBlock() != Blocks.air
                ? new BlockData(pos.add(0, -1, 0), EnumFacing.UP) : null;
    }
}

minecraft_de_Client_Main_Modules_Module.java

package de.Client.Main.Modules;

import de.Client.Events.EventManager;
import de.Client.Main.Main;
import de.Client.Main.Values.Value;
import de.Client.Render.ClickGui.Panels.Mini;
import net.minecraft.client.Minecraft;

import java.io.IOException;
import java.util.ArrayList;

public class Module {
	
	public boolean getState;
	
	public String name;
	
	public int keyBind;
	
	public String displayName;
    
	public Category category;
	
	public Minecraft mc = Minecraft.getMinecraft();
	
	public ArrayList<Value> values = new ArrayList<Value>();
	
	public Module(String name,Category category, int keyBind){
		this.name = name;
		this.displayName = name;
		this.keyBind = keyBind;
		this.category = category;
        this.getState = false;
	}

	public ArrayList<Mini> createArray(){
	    return new ArrayList<>();
    }

	public void addValue(Value v){
		this.values.add(v);
	}
	
	public boolean isModuleImportant(){
		return true;
	}

	public boolean getState()
	{
		return getState;
	}
	public void toggleModule(){
		this.getState = ! this.getState;
		if(this.getState){
			this.onEnable();
			EventManager.register(this);
		}else{
			this.onDisable();
			EventManager.unregister(this);
		}
		try {
			Main.getMain.moduleManager.saveModule(Main.getMain.moduleSave);
		} catch (IOException e) {
			System.err.println("error occured while saving");
			e.printStackTrace();
		}
		this.onToggle();
	}
	
	public void onEnable(){}

    public void onDisable(){}

    public void onToggle(){}

    public void onUpdate(){}

    public void onRender(){}

    public void onRenderNametag(){}

}

minecraft_de_Client_Main_Modules_ModuleManager.java

package de.Client.Main.Modules;

import de.Client.Events.EventManager;
import de.Client.Main.Main;
import de.Client.Main.Modules.mods.Combat.*;
import de.Client.Main.Modules.mods.Movment.*;
import de.Client.Main.Modules.mods.Player.*;
import de.Client.Main.Modules.mods.Render.*;
import de.Client.Main.Modules.mods.World.*;
import de.Client.Main.Values.Value;
import de.Client.Main.Values.ValueBoolean;
import de.Client.Main.Values.ValueDouble;

import java.io.*;
import java.util.ArrayList;
import java.util.List;

public class ModuleManager {
	public ArrayList<Module> modules = new ArrayList<Module>();
	
	public ModuleManager(){
		this.init();
	}
	
	public void init(){
		add(new AntiBots());
		add(new NoSlowDown());
		add(new LiquidWalk());
		add(new Sprint());
		add(new ESP());
		add(new Gui());
		add(new AutoArmor());
		add(new Fucker());
		add(new Criticals());
		add(new KillAura());
		add(new Velocity());
		add(new ChestStealer());
		add(new ScaffoldWalk());
		add(new FullBright());
		add(new NameTags2());
        add(new BetterOverlay());
		add(new Xray());
		add(new Glide());
		add(new ClickTP());
		add(new ChestAura());
		add(new Speed());
		add(new InventoryMove());
		add(new ControllerApi());
        add(new SafeWalk());
        add(new Civbreak());
		add(new Phase());
		add(new NoRotate());
		add(new McdeadAimbot());
		add(new ChestESP());
		add(new Step());
		add(new NoFall());
		add(new Teams());
		add(new Fastladder());
		add(new InvCleaner());
        add(new TerrainSpeed());
        add(new Babygame());
        add(new Autotool());
        add(new Tower());
        add(new Longjump());
        add(new Regen());
        add(new AutoFish());
        add(new Speedmine());
	}

	
	public void saveModule(File file) throws IOException{
		
		Main.getMain.moduleSave.delete();
		Main.getMain.moduleSave.createNewFile();
		PrintWriter output = new PrintWriter(new FileWriter(file, true));
	

	for(Module mod : Main.getMain.moduleManager.getModules()){
		if(!mod.values.isEmpty()){
		for(Value v : mod.values){
			String save = mod.name +" : " + mod.getState + " : " + mod.keyBind + " : " + (v instanceof ValueBoolean ? (("Valueboolean : ") + v.getName() + " : " + ((ValueBoolean)v).getValue()) :( "Valuedouble : " + v.getName() +" : "+((ValueDouble)v).getValue())) ;
			output.println(save);
		}
		}else{
			String save = mod.name +" : " + mod.getState + " : " + mod.keyBind;
					output.println(save);
		}
	}
	output.close();

	}

	public String[] readFile(File file) {
		if(file.exists()) {
			try {
	            FileReader fileReader = new FileReader(file);
	            BufferedReader bufferedReader = new BufferedReader(fileReader);
	            List<String> lines = new ArrayList();
	            String line = null;
	            while ((line = bufferedReader.readLine()) != null) {
	                lines.add(line);
	            }
	            bufferedReader.close();
	            return (String[]) lines.toArray(new String[lines.size()]);
			} catch (Exception ignored) {
			}
		} else {
			System.out.println("[SkyRise] - Bind-Datei existiert nicht!");
		}
		return null;
	}
	
	public void loadModules(File file) {
		if(file.exists()) {
			try {
				for(Module modules : this.getModules()) {
					for(String bind : readFile(file)) {
						String[] splitted = bind.split(" : ");
						if(modules.name.equalsIgnoreCase(splitted[0])) {
							if(Boolean.parseBoolean(splitted[1])){
								EventManager.unregister(modules);
								EventManager.register(modules);
								modules.getState = true;
								
							}
							modules.keyBind = Integer.parseInt(splitted[2]);
							for(Value v : modules.values){
								
								if(splitted[3].equalsIgnoreCase("Valueboolean") && v instanceof ValueBoolean){
									ValueBoolean vboolean = (ValueBoolean) v;
									
									if(vboolean.getName().equalsIgnoreCase(splitted[4])){
										vboolean.setValue(Boolean.parseBoolean(splitted[5]));
									}
								}else if(splitted[3].equalsIgnoreCase("Valuedouble")&& v instanceof ValueDouble){
									try{
									ValueDouble vdouble = (ValueDouble) v;
									if(vdouble.getName().equalsIgnoreCase(splitted[4])){
										System.err.println("Found Value c:"+Double.parseDouble(splitted[5]));
										vdouble.setValue(Double.parseDouble(splitted[5]));
									}
									}catch(Exception e){
										System.err.println("Found BADDDDD value" + splitted[4]);
										e.printStackTrace();
									}
								}
							}
						}
					}
				}
			} catch (Exception e) {
				System.out.println("FEHLER)"); 
			}
		} else {
			System.out.println("[SkyRise] - Bind-Datei existiert nicht!");
		}
	}
	
	public void add(Module mod){
		this.modules.add(mod);
	}
	
	public ArrayList<Module> getModulesForCategory(Category category){
		ArrayList<Module> returnArray = new ArrayList();
		for(Module mod : this.modules){
			if(mod.category == category){
				returnArray.add(mod);
			}
		}
		return returnArray;
	}
	
	public Module getModule(Class clazz){
		for(Module mod : this.modules){
			if(mod.getClass() == clazz){
				return mod;
			}
		}
		return null;
	}
	public List<Module> getActiveModules(){
	    List mods = new ArrayList<Module>();


	    for(Module m : this.getModules()){
	        if(m.getState){
	            mods.add(m);
            }
        }

	    return mods;
    }
	public ArrayList<Module> getModules(){
		return this.modules;
	}

}

minecraft_de_Client_Main_Screens_AddAlt.java

package de.Client.Main.Screens;

import de.Client.Main.Main;
import de.Client.Utils.Alt;
import de.Client.Utils.DarkPasswordField;
import de.Client.Utils.DarkTextField;
import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.GuiButton;
import net.minecraft.client.gui.GuiScreen;
import net.minecraft.client.gui.ScaledResolution;
import org.lwjgl.input.Keyboard;
import org.lwjgl.input.Mouse;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;


public final class AddAlt extends GuiScreen {
	
	static DarkPasswordField password;
	static GuiScreen previousScreen;
	public static int id;
	static DarkTextField username;

	
	public AddAlt(GuiScreen previousScreen) {
		this.previousScreen = previousScreen;
	}

	public void drawScreen(int x, int y, float z) {
		this.drawDefaultBackground();
		ScaledResolution sr = new ScaledResolution(Minecraft.getMinecraft(), Minecraft.getMinecraft().displayWidth, Minecraft.getMinecraft().displayHeight);

		
		
		drawCenteredString(this.mc.fontRendererObj, "Add Alt", this.width / 2 - 10, 20, -1);
	
	
		this.username.drawTextBox();
		this.password.drawTextBox();
		if (this.username.getText().isEmpty()) {
			drawString(this.mc.fontRendererObj, "  < Username / E-Mail >", this.width / 2 - 96, 66, -7829368);
		}
		if (this.password.getText().isEmpty()) {
			drawString(this.mc.fontRendererObj, "  < Password >", this.width / 2 - 96, 106, -7829368);
		}
		
		// Anzeige
	
		if(Mouse.isButtonDown(0) && Mouse.isButtonDown(1) && Keyboard.isKeyDown(Keyboard.KEY_LSHIFT)){
	//		mc.displayGuiScreen(new GuiComboListGenerator(this));
		}
		super.drawScreen(x, y, z);
	}

	public void initGui() {
		int var3 = this.height / 4 + 24;
		
		this.buttonList.add(new GuiButton(1002, this.width / 2 - 100, var3 + 72 + 48, "Add Alt"));
		this.buttonList.add(new GuiButton(1003, this.width / 2 - 100, var3 + 72 + 72, "Back"));
		this.username = new DarkTextField(Integer.MAX_VALUE,this.mc.fontRendererObj, this.width / 2 - 100, 60, 200, 20);
		this.password = new DarkPasswordField(this.mc.fontRendererObj, this.width / 2 - 100, 100, 200, 20);
		this.username.setFocused(true);
		Keyboard.enableRepeatEvents(true);
	}

	protected void actionPerformed(GuiButton button) throws IOException {
		
		
		
		
		if(button.id == 1000) {
			// Laden aus Datenbank
		
		}
		if(button.id == 1001) {
	//	mc.displayGuiScreen(new McLeaksGui(this));
		
		}
		if(button.id == 1002) {
			id = 0;
			for(int i = 0; i < AltManager.AltListArray.size();++i){
			id ++;
			}
			AltManager.AltListArray.add(new Alt(this.username.getText(), this.password.getText(),id));
			
			File file = Main.getMain.altList;
			
			if(file.exists()) {
				file.delete();
			}
		
				file.createNewFile();
	
					
					PrintWriter output = null;
					try {
						output = new PrintWriter(new FileWriter(file, true));
					} catch (IOException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					for(Alt alts : AltManager.AltListArray) {
						output.println(alts.getEmail() + ":" + alts.getPassword());
					}
					output.close();
					
			
			this.mc.displayGuiScreen(this.previousScreen);
        }
		if(button.id == 1003) {
			this.mc.displayGuiScreen(this.previousScreen);

		}
	}
	
	protected void keyTyped(char character, int key) throws IOException {
		try {
			super.keyTyped(character, key);
		} catch (IOException e) {
			e.printStackTrace();
		}
		if (character == '\t') {
			if ((!this.username.isFocused()) && (!this.password.isFocused())) {
				this.username.setFocused(true);
			} else {
				this.username.setFocused(this.password.isFocused());
				this.password.setFocused(!this.username.isFocused());
			}
		}
		if (character == '\r') {
			actionPerformed((GuiButton) this.buttonList.get(0));
		}
		this.username.textboxKeyTyped(character, key);
		this.password.textboxKeyTyped(character, key);
	}

	protected void mouseClicked(int x, int y, int button) {
		try {
			super.mouseClicked(x, y, button);
		} catch (IOException e) {
			e.printStackTrace();
		}
		this.username.mouseClicked(x, y, button);
		this.password.mouseClicked(x, y, button);
	}

	public void onGuiClosed() {
		Keyboard.enableRepeatEvents(false);
	}

	public void updateScreen() {
		username.updateCursorCounter();
		password.updateCursorCounter();
	}
}

minecraft_de_Client_Main_Screens_AltManager.java

package de.Client.Main.Screens;

import de.Client.Main.Main;
import de.Client.Utils.*;
import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.*;
import net.minecraft.client.renderer.GlStateManager;
import net.minecraft.client.renderer.Tessellator;
import net.minecraft.client.renderer.WorldRenderer;
import net.minecraft.util.ResourceLocation;
import org.lwjgl.input.Controller;
import org.lwjgl.input.Keyboard;
import org.lwjgl.input.Mouse;

import java.awt.*;
import java.io.*;
import java.util.ArrayList;
import java.util.List;

public class AltManager extends GuiScreen {
	public static ArrayList<Alt> AltListArray = new ArrayList<Alt>();
	public static AccountLoginThread thread;
	private String status;
	private Alt alttoremove;	
	public int mousediffrent;
	public static TimeHelper time = new TimeHelper();
	public boolean animationSwitch;
	public double animationTicks;
    public Minecraft mc = Minecraft.getMinecraft();
    public FontRenderer fr = Minecraft.getMinecraft().fontRendererObj;
    public TimeHelper timeHelper = new TimeHelper();
	public AltManager(GuiScreen prevScreen) {
	}
	private void setStatus(String status) {
		status = thread.getStatus();
	}
	@Override
	protected void mouseClicked(int mouseX, int mouseY, int mouseButton) throws IOException {
		for(Alt alts : AltListArray){
			alts.onMouse(mouseX,mouseY);
		}
		super.mouseClicked(mouseX, mouseY, mouseButton);
	}


	@Override
	protected void actionPerformed(GuiButton button) throws IOException {
		if(button.id == 2){
			mc.displayGuiScreen(new GuiMainMenu());
		}
		if(button.id == 3){
			for(Alt alts: this.AltListArray){
				if(alts.selected){
					alts.login();
				}
			}
		}
		if(button.id == 4){
			mc.displayGuiScreen(new AddAlt(this));
		}
		if(button.id == 5){
			for(int i = 0; i < this.AltListArray.size(); i++){
			    Alt alts = this.AltListArray.get(i);
				if(alts.selected){
					this.AltListArray.remove(alts);
					this.saveAlts();
					mc.displayGuiScreen(new AltManager(null));
				}
			}
		}
		if(button.id == 6){
			mc.displayGuiScreen(new DirectLogin(this));
		}
	}
	  protected void overlayBackground(int p_148136_1_, int p_148136_2_, int p_148136_3_, int p_148136_4_)
	    {
	        Tessellator var5 = Tessellator.getInstance();
	        WorldRenderer var6 = var5.getWorldRenderer();
	        this.mc.getTextureManager().bindTexture(Gui.optionsBackground);
	        GlStateManager.color(1.0F, 1.0F, 1.0F, 1.0F);
	        float var7 = 32.0F;
	        var6.startDrawingQuads();
	        var6.func_178974_a(4210752, p_148136_4_);
	        var6.addVertexWithUV((double)0, (double)p_148136_2_, 0.0D, 0.0D, (double)((float)p_148136_2_ / var7));
	        var6.addVertexWithUV((double)(this.width), (double)p_148136_2_, 0.0D, (double)((float)this.width / var7), (double)((float)p_148136_2_ / var7));
	        var6.func_178974_a(4210752, p_148136_3_);
	        var6.addVertexWithUV((double)(this.width), (double)p_148136_1_, 0.0D, (double)((float)this.width / var7), (double)((float)p_148136_1_ / var7));
	        var6.addVertexWithUV((double)0, (double)p_148136_1_, 0.0D, 0.0D, (double)((float)p_148136_1_ / var7));
	        var5.draw();
	    }
	public static String[] readFile(File file) {
		if (file.exists()) {
			try {
				FileReader fileReader = new FileReader(file);
				BufferedReader bufferedReader = new BufferedReader(fileReader);
				List<String> lines = new ArrayList();
				String line = null;
				while ((line = bufferedReader.readLine()) != null) {
					lines.add(line);
				}
				bufferedReader.close();
				return (String[]) lines.toArray(new String[lines.size()]);
			} catch (Exception ignored) {
			}
		} else {
			System.out.println("[SkyRise] - Bind-Datei existiert nicht!");
		}
		return null;
	}

	public void saveAlts() throws IOException {

        File file = Main.getMain.altList;

        if(file.exists()) {
            file.delete();
        }

        file.createNewFile();


        PrintWriter output = null;
        try {
            output = new PrintWriter(new FileWriter(file, true));
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        for(Alt alts : AltManager.AltListArray) {
            output.println(alts.getEmail() + ":" + alts.getPassword() + ":"+alts.name);
        }
        output.close();

    }

    public void saveAltsAndReplace(Alt altToReplace) throws IOException {

        File file = Main.getMain.altList;

        if(file.exists()) {
            file.delete();
        }

        file.createNewFile();


        PrintWriter output = null;
        try {
            output = new PrintWriter(new FileWriter(file, true));
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        for(Alt alts : AltManager.AltListArray) {
            if(alts.getPassword() == altToReplace.getPassword() && alts.getEmail() == altToReplace.getEmail()){
                output.println(altToReplace.getEmail() + ":" + altToReplace.getPassword() + ":" + altToReplace.name);
                System.out.println("replacing account to apply name");
            }else {
                output.println(alts.getEmail() + ":" + alts.getPassword() + ":" + alts.name);
            }
        }
        output.close();

    }

    public AltManager returnAndInit(){
	    this.initGui();
	    return this;
    }

	@Override
	public void initGui() {
        city.clear();
        Rect startRect = new Rect(this.width);
        this.city.add(startRect);
        int size = width-1;
        while (size > 0 ) {

            Rect firstRect = new Rect(Integer.MAX_VALUE);
            for (Rect r : this.city) {
                if (r.abstand + r.x < firstRect.abstand + firstRect.x) {
                    firstRect = r;
                }
            }
            if (firstRect.xPos() > -50) {
                Rect newRect = new Rect(firstRect.xPos());
                newRect.x = -newRect.widht;
                this.city.add(newRect);
                size -= newRect.widht;
            }
        }
            animationTicks = this.width;
        Alt.scrollpos = -20;
		try{
			int width = this.width / 2-100;
			
		this.buttonList.add(new DarkButton(2, width - 101, this.height -22, 200, 20, "Zurück"));
		this.buttonList.add(new DarkButton(3, width + 101, this.height -22, 200, 20, "Login"));
		this.buttonList.add(new DarkButton(4, width - 101, this.height -44, 150, 20, "AddAlt"));
		this.buttonList.add(new DarkButton(6, width+50 , this.height -44, 100, 20, "Direct login"));
		this.buttonList.add(new DarkButton(5,width + 151, this.height -44, 150, 20, "RemoveAlt"));
		Alt.scrollpos = 0;
		
		
		this.AltListArray.clear();
		int id = 0;
			for(String string : this.readFile(Main.getMain.altList)){
				String[] splitString = string.split(":");
				if(splitString.length > 2) {
                    this.AltListArray.add(new Alt(splitString[0], splitString[1], splitString[2], id));
                }else{
                    this.AltListArray.add(new Alt(splitString[0], splitString[1], id));
                }
				++id;

			}
		
		super.initGui();
	}catch(Exception ignored){
	}
	}
    public ArrayList<Rect> city = new ArrayList<>();
	@Override
	public void drawScreen(int mouseX, int mouseY, float partialTicks) {

        if(Keyboard.isKeyDown(Keyboard.KEY_RETURN)){
            mc.displayGuiScreen(new GuiAltChecker(this));
        }
        Gui.drawRect(0,0,width,height,new Color(0xDCE2F6).getRGB());

//        GuiApi.drawBorderedCircle(30,10,200,new Color(0xFFEF34).getRGB(),new Color(0xFFFC77).getRGB());
        boolean markdirty = false;
        for(int i = 0; i < this.city.size(); ++i){
            Rect r = this.city.get(i);
            r.draw();
            if(r.dirty){
                markdirty = true;
            }
        }
        if(markdirty) {
            for (int i = 0; i < this.city.size(); ++i) {
                Rect r = this.city.get(i);
                if (r.dirty) {
                    this.city.remove(i);
                }
            }
        }
        Rect firstRect = new Rect(Integer.MAX_VALUE);
        for(Rect r : this.city){
            if(r.abstand + r.x < firstRect.abstand + firstRect.x){
                firstRect = r;
            }
        }
        if(firstRect.xPos() > -50){
            Rect newRect = new Rect(firstRect.xPos());
            newRect.x = - newRect.widht;
            this.city.add(newRect);
        }
        if (Mouse.isButtonDown(0)) {
            Alt.scrollpos += mouseY - mousediffrent;
            mousediffrent = mouseY;
        } else {
            mousediffrent = mouseY;
        }
        Alt.scrollpos += Mouse.getDWheel() / (Keyboard.isKeyDown(Keyboard.KEY_LCONTROL) ? 1 : 10);
        for (Alt alts : AltListArray) {
            alts.drawAltEntry(mouseX, mouseY);
        }
        //this.overlayBackground(this.height - 45, this.height, 255, 255);
        Gui.drawRect(this.width / 2 - 210,this.height-50,this.width / 2 +210, this.height, new Color(0x191B29).getRGB());
        drawCenteredString(this.mc.fontRendererObj, this.thread == null ? "" : (this.thread).getStatus(), this.width / 2 - 9, 5, -1);
        if(time.hasReached(500)){
            time.reset();
            try {
                this.saveAlts();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        super.drawScreen(mouseX, mouseY, partialTicks);
    }
	
}

minecraft_de_Client_Main_Screens_ColorButton.java

package de.Client.Main.Screens;

/**
 * Created by Daniel on 12.08.2017.
 */
public class ColorButton {
}

minecraft_de_Client_Main_Screens_DesktopMainMenu.java

package de.Client.Main.Screens;
import de.Client.Main.Main;
import de.Client.Main.Screens.UIApps.UIAltManager;
import de.Client.Utils.ColorUtil;
import de.Client.Utils.TimeHelper;
import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.Gui;
import net.minecraft.client.gui.GuiButton;
import net.minecraft.client.gui.GuiScreen;

import net.minecraft.util.ResourceLocation;
import java.awt.*;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.*;

public class DesktopMainMenu extends GuiScreen
{
    public void initGui()
    {
        if(this.uis.isEmpty()){
            uis.add(appAlt);
        }
        for(UIApp p : this.uis){
            p.initGui();
        }
        this.buttonList.clear();
        this.buttonList.add(new UIAppButton(1,22,this.height - 22,"Altmanager.png",this.appAlt));

    }
    public static ArrayList<UIApp> uis= new ArrayList();
    public UIApp appAlt = new UIAltManager(this);
    protected void actionPerformed(GuiButton button) throws IOException
    {
        if(button instanceof UIAppButton){
            UIAppButton btn = (UIAppButton) button;
            btn.uiApp.isOpen = ! btn.uiApp.isOpen;
            if( btn.uiApp.isOpen) {
                btn.uiApp.initGui();
            }
        }
    }
    public TimeHelper t = new TimeHelper();
    public int time = 0;
    public static void drawImage(int x, int y, int width, int height, String resLocation) {
        Minecraft.getMinecraft().getTextureManager().bindTexture(new ResourceLocation("Sunrise/Backgrounds/" + resLocation));
        Gui.drawModalRectWithCustomSizedTexture(x, y, 0.0F, 0.0F, width, height, width, height);
    }
    public void drawScreen(int mouseX, int mouseY, float partialTicks) {
        Gui.drawRect(0,0,width,height,new Color(0x1D1D1E).getRGB());
        for(UIApp p : this.uis){
            p.drawScreen(mouseX,  mouseY,  partialTicks);
        }
        double x = this.width / 2d;
        double y = this.height / 2d;
        Gui.drawRect(0,this.height - 22.5,this.width,this.height - 22,Main.getMain.getClientColor().getRGB());
        Gui.drawRect(0,this.height - 22,this.width,this.height ,new  Color(0x2B2B2C).getRGB());
        SimpleDateFormat format = new SimpleDateFormat("HH:mm");
        String uhr = format.format(new Date());
        Main.getMain.mainmenu.drawCenteredStringWithShadow( uhr ,width  -50,this.height-22,0xffffffff);
        Calendar cal = Calendar.getInstance ();
        SimpleDateFormat dateFormat = new SimpleDateFormat("dd.MM.yyyy");
        Main.getMain.mainmenu.drawCenteredStringWithShadow( dateFormat.format(new Date(System.currentTimeMillis())) ,width  -50,this.height-11,0xffffffff);
        ColorUtil.setColor(Color.BLACK);
        this.drawImage(this.width-24,this.height-20,20,20,"Shutdown.png");
        if(mouse(mouseX,mouseY,this.width-25,this.width,this.height-21,height) && mouseY < height){
            ColorUtil.setColor(Main.getMain.getClientColor());
        }else{
            ColorUtil.setColor(Color.WHITE);
        }
        this.drawImage(this.width-25,this.height-21,20,20,"Shutdown.png");
        super.drawScreen(mouseX,mouseY,partialTicks);
    }

    public boolean mouse(int mouseX, int mouseY, float minX, float maxX, float minY, float maxY) {
        return (mouseX >= minX && mouseX <= maxX) && (mouseY >= minY && mouseY <= maxY);
    }
    @Override
    protected void mouseReleased(int mouseX, int mouseY, int mouseButton){

        for(UIApp ui : this.uis){
            ui.mouseReleased(mouseX,mouseY,mouseButton);
        }
        super.mouseReleased(mouseX,mouseY,mouseButton);

    }
    protected void mouseClicked(int mouseX, int mouseY, int mouseButton) throws IOException
    {
        // mc.displayGuiScreen(new GuiMultiplayer(null));

        for(UIApp ui : this.uis){
            ui.mouseClicked( mouseX,  mouseY,  mouseButton);
        }
        if(mouse(mouseX,mouseY,this.width-25,this.width-1,this.height-21,height-1)){
            System.exit(-1);
        }
        super.mouseClicked(mouseX, mouseY, mouseButton);

    }
}

minecraft_de_Client_Main_Screens_DirectLogin.java

package de.Client.Main.Screens;

import de.Client.Utils.AccountLoginThread;
import de.Client.Utils.DarkPasswordField;
import de.Client.Utils.DarkTextField;
import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.GuiButton;
import net.minecraft.client.gui.GuiScreen;
import net.minecraft.client.gui.ScaledResolution;
import org.lwjgl.input.Keyboard;
import org.lwjgl.input.Mouse;

import java.io.IOException;


public final class DirectLogin extends GuiScreen {
	
	static DarkPasswordField password;
	static GuiScreen previousScreen;
	public static int id;
	static DarkTextField username;

	
	public DirectLogin(GuiScreen previousScreen) {
		this.previousScreen = previousScreen;
	}

	public void drawScreen(int x, int y, float z) {
		this.drawDefaultBackground();
		ScaledResolution sr = new ScaledResolution(Minecraft.getMinecraft(), Minecraft.getMinecraft().displayWidth, Minecraft.getMinecraft().displayHeight);

		
		
		drawCenteredString(this.mc.fontRendererObj, "Direct Login", this.width / 2 - 10, 20, -1);
	
	
		this.username.drawTextBox();
		this.password.drawTextBox();
		if (this.username.getText().isEmpty()) {
			drawString(this.mc.fontRendererObj, "  < Username / E-Mail >", this.width / 2 - 96, 66, -7829368);
		}
		if (this.password.getText().isEmpty()) {
			drawString(this.mc.fontRendererObj, "  < Password >", this.width / 2 - 96, 106, -7829368);
		}
		
		// Anzeige
	
		if(Mouse.isButtonDown(0) && Mouse.isButtonDown(1) && Keyboard.isKeyDown(Keyboard.KEY_LSHIFT)){
	//		mc.displayGuiScreen(new GuiComboListGenerator(this));
		}
		super.drawScreen(x, y, z);
	}

	public void initGui() {
		int var3 = this.height / 4 + 24;
		
		this.buttonList.add(new GuiButton(1002, this.width / 2 - 100, var3 + 72 + 48, "Login"));
		this.buttonList.add(new GuiButton(1003, this.width / 2 - 100, var3 + 72 + 72, "Back"));
		this.username = new DarkTextField(Integer.MAX_VALUE,this.mc.fontRendererObj, this.width / 2 - 100, 60, 200, 20);
		this.password = new DarkPasswordField(this.mc.fontRendererObj, this.width / 2 - 100, 100, 200, 20);
		this.username.setFocused(true);
		Keyboard.enableRepeatEvents(true);
	}

	protected void actionPerformed(GuiButton button) throws IOException {
		
		
		
		
		if(button.id == 1000) {
			// Laden aus Datenbank
		
		}
		if(button.id == 1001) {
	//	mc.displayGuiScreen(new McLeaksGui(this));
		
		}
		if(button.id == 1002) {
			((de.Client.Main.Screens.AltManager) this.previousScreen).thread = new AccountLoginThread(this.username.getText(),this.password.getText());
			((de.Client.Main.Screens.AltManager) this.previousScreen).thread.start();
			this.mc.displayGuiScreen(this.previousScreen);
		}
		if(button.id == 1003) {
			this.mc.displayGuiScreen(this.previousScreen);

		}
	}
	
	protected void keyTyped(char character, int key) throws IOException {
		try {
			super.keyTyped(character, key);
		} catch (IOException e) {
			e.printStackTrace();
		}
		if (character == '\t') {
			if ((!this.username.isFocused()) && (!this.password.isFocused())) {
				this.username.setFocused(true);
			} else {
				this.username.setFocused(this.password.isFocused());
				this.password.setFocused(!this.username.isFocused());
			}
		}
		if (character == '\r') {
			actionPerformed((GuiButton) this.buttonList.get(0));
		}
		this.username.textboxKeyTyped(character, key);
		this.password.textboxKeyTyped(character, key);
	}

	protected void mouseClicked(int x, int y, int button) {
		try {
			super.mouseClicked(x, y, button);
		} catch (IOException e) {
			e.printStackTrace();
		}
		this.username.mouseClicked(x, y, button);
		this.password.mouseClicked(x, y, button);
	}

	public void onGuiClosed() {
		Keyboard.enableRepeatEvents(false);
	}

	public void updateScreen() {
		username.updateCursorCounter();
		password.updateCursorCounter();
	}
}

minecraft_de_Client_Main_Screens_GuiAltChecker.java

package de.Client.Main.Screens;

import de.Client.Main.Main;
import de.Client.Utils.*;
import de.Client.Utils.ArrayList;
import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.GuiButton;
import net.minecraft.client.gui.GuiScreen;
import net.minecraft.client.gui.ScaledResolution;
import net.minecraft.client.multiplayer.ServerData;
import org.lwjgl.input.Keyboard;
import org.lwjgl.input.Mouse;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.util.*;


public class GuiAltChecker extends GuiScreen {
    public static java.util.ArrayList<Alt> AltListArray = new java.util.ArrayList<Alt>();
  //  static Dark//Field //;
    static GuiScreen previousScreen;
    public static int id = -1;
    public static int failedacc = 0;
    public boolean started;
    static DarkTextField username = new DarkTextField(Integer.MAX_VALUE,Minecraft.getMinecraft().fontRendererObj,  100, 20, 200, 20);
    public static TimeHelper time = new TimeHelper();
    public boolean isStarted;
    public int offset;
    public GuiAltChecker(GuiScreen previousScreen) {
        this.previousScreen = new AltManager(this);
    }

    public static String[] readFile(File file) {
        if (file.exists()) {
            try {
                FileReader fileReader = new FileReader(file);
                BufferedReader bufferedReader = new BufferedReader(fileReader);
                List<String> lines = new java.util.ArrayList();
                String line = null;
                while ((line = bufferedReader.readLine()) != null) {
                    lines.add(line);
                }
                bufferedReader.close();
                return (String[]) lines.toArray(new String[lines.size()]);
            } catch (Exception ignored) {
            }
        } else {
            System.out.println("[SkyRise] - Bind-Datei existiert nicht!");
        }
        return null;
    }

    public void initGui() {
        id ++;
        started = true;
        this.buttonList.add(new DarkButton(0, 100, 50, 200, 20,"Start"));
        this.AltListArray.clear();
        int id = 0;
        for(String string : this.readFile(Main.getMain.altList)){
            String[] splitString = string.split(":");
            if(splitString.length > 2) {
                this.AltListArray.add(new Alt(splitString[0], splitString[1], splitString[2], id));
            }else{
                this.AltListArray.add(new Alt(splitString[0], splitString[1], id));
            }
            ++id;

        }

    }

    protected void actionPerformed(GuiButton button) throws IOException {
        if(button.id == 0){
            isStarted = true;
        }

    }

    protected void keyTyped(char character, int key) throws IOException {
        try {
            super.keyTyped(character, key);
        } catch (IOException e) {
            e.printStackTrace();
        }
        this.username.textboxKeyTyped(character,key);
    }
    @Override
    public void drawScreen(int mouseX, int mouseY, float partialTicks){
        this.drawBackground(1);
        username.drawTextBox();
        if(username.getText().contains(".") && isStarted){

        }else{
            time.reset();
            super.drawScreen(mouseX,mouseY,partialTicks);
            return;
        }
        if(started){
            Alt alt = GuiAltChecker.AltListArray.get(id);
            ((de.Client.Main.Screens.AltManager) this.previousScreen).thread = new AccountLoginThread(alt.getEmail(), alt.getPassword());
            ((de.Client.Main.Screens.AltManager) this.previousScreen).thread.start();
            time.reset();
            started = false;

        }else{
        }
        if(((de.Client.Main.Screens.AltManager) this.previousScreen).thread.getStatus().contains("Fehlgeschlagen")){
            mc.displayGuiScreen(new GuiAltChecker(this.previousScreen));
            this.failedacc ++;
            if(failedacc > 7){
                System.exit(-1);
            }
        }
        if(time.hasReached(5000)) {
            if (!((de.Client.Main.Screens.AltManager) this.previousScreen).thread.isAlive()) {
                mc.displayGuiScreen(new GuiAltConnecting(this, Minecraft.getMinecraft(), new ServerData("none", this.username.getText())));
            }else{
                Minecraft.getMinecraft().fontRendererObj.drawStringWithShadow("§cWAITING FOR LOGIN!",200,50,0xff);
            }
        }
        Alt alt = GuiAltChecker.AltListArray.get(id);
        alt.drawAltEntry(mouseX,mouseY);
        Alt.scrollpos =  - alt.id * 42 + 50;
        super.drawScreen(mouseX,mouseY,partialTicks);
    }

    protected void mouseClicked(int x, int y, int button) {
        try {
            super.mouseClicked(x, y, button);
        } catch (IOException e) {
            e.printStackTrace();
        }
        this.username.mouseClicked(x, y, button);
    }

    public void onGuiClosed() {
        Keyboard.enableRepeatEvents(false);
    }

    public void updateScreen() {
        username.updateCursorCounter();
    }
}

minecraft_de_Client_Main_Screens_GuiAltConnecting.java

package de.Client.Main.Screens;

import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.GuiButton;
import net.minecraft.client.gui.GuiDisconnected;
import net.minecraft.client.gui.GuiScreen;
import net.minecraft.client.multiplayer.ServerAddress;
import net.minecraft.client.multiplayer.ServerData;
import net.minecraft.client.multiplayer.WorldClient;
import net.minecraft.client.network.NetHandlerLoginClient;
import net.minecraft.client.resources.I18n;
import net.minecraft.network.EnumConnectionState;
import net.minecraft.network.NetworkManager;
import net.minecraft.network.handshake.client.C00Handshake;
import net.minecraft.network.login.client.C00PacketLoginStart;
import net.minecraft.util.ChatComponentText;
import net.minecraft.util.ChatComponentTranslation;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

import java.io.IOException;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.concurrent.atomic.AtomicInteger;

public class GuiAltConnecting extends GuiScreen
{
    private static final AtomicInteger CONNECTION_ID = new AtomicInteger(0);
    private static final Logger logger = LogManager.getLogger();
    private NetworkManager networkManager;
    private boolean cancel;
    public final GuiScreen previousGuiScreen;
    private static final String __OBFID = "CL_00000685";

    public GuiAltConnecting(GuiScreen p_i1181_1_, Minecraft mcIn, ServerData p_i1181_3_)
    {
        this.mc = mcIn;
        this.previousGuiScreen = p_i1181_1_;
        ServerAddress var4 = ServerAddress.func_78860_a(p_i1181_3_.serverIP);
     //   mcIn.loadWorld((WorldClient)null);
        mcIn.setServerData(p_i1181_3_);
        this.connect(var4.getIP(), var4.getPort());
    }


    private void connect(final String ip, final int port)
    {
        logger.info("Connecting to " + ip + ", " + port);
        (new Thread("Server Connector #" + CONNECTION_ID.incrementAndGet())
        {
            private static final String __OBFID = "CL_00000686";
            public void run()
            {
                InetAddress var1 = null;

                try
                {
                    if (GuiAltConnecting.this.cancel)
                    {
                        return;
                    }

                    var1 = InetAddress.getByName(ip);
                    GuiAltConnecting.this.networkManager = NetworkManager.provideLanClient(var1, port);
                    GuiAltConnecting.this.networkManager.setNetHandler(new NetHandlerLoginClient(GuiAltConnecting.this.networkManager, GuiAltConnecting.this.mc, GuiAltConnecting.this.previousGuiScreen));
                    GuiAltConnecting.this.networkManager.sendPacket(new C00Handshake(47, ip, port, EnumConnectionState.LOGIN));
                    GuiAltConnecting.this.networkManager.sendPacket(new C00PacketLoginStart(GuiAltConnecting.this.mc.getSession().getProfile()));
                }
                catch (UnknownHostException var5)
                {
                    if (GuiAltConnecting.this.cancel)
                    {
                        return;
                    }

                    GuiAltConnecting.logger.error("Couldn\'t connect to server", var5);
                    GuiAltConnecting.this.mc.displayGuiScreen(GuiAltConnecting.this.previousGuiScreen);
                }
                catch (Exception var6)
                {
                    if (GuiAltConnecting.this.cancel)
                    {
                        return;
                    }

                    GuiAltConnecting.logger.error("Couldn\'t connect to server", var6);
                    String var3 = var6.toString();

                    if (var1 != null)
                    {
                        String var4 = var1.toString() + ":" + port;
                        var3 = var3.replaceAll(var4, "");
                    }

                    GuiAltConnecting.this.mc.displayGuiScreen(GuiAltConnecting.this.previousGuiScreen);
                }
            }
        }).start();
    }

    /**
     * Called from the main game loop to update the screen.
     */
    public void updateScreen()
    {
        if (this.networkManager != null)
        {
            if (this.networkManager.isChannelOpen())
            {
                this.networkManager.processReceivedPackets();
            }
            else
            {
                this.networkManager.checkDisconnected();
            }
        }
    }

    /**
     * Fired when a key is typed (except F11 who toggle full screen). This is the equivalent of
     * KeyListener.keyTyped(KeyEvent e). Args : character (character on the key), keyCode (lwjgl Keyboard key code)
     */
    protected void keyTyped(char typedChar, int keyCode) throws IOException {}

    /**
     * Adds the buttons (and other controls) to the screen in question.
     */
    public void initGui()
    {
        this.buttonList.clear();
        this.buttonList.add(new GuiButton(0, this.width / 2 - 100, this.height / 4 + 120 + 12, I18n.format("gui.cancel", new Object[0])));
    }

    protected void actionPerformed(GuiButton button) throws IOException
    {
        if (button.id == 0)
        {
            this.cancel = true;

            if (this.networkManager != null)
            {
                this.networkManager.closeChannel(new ChatComponentText("Aborted"));
            }

            this.mc.displayGuiScreen(this.previousGuiScreen);
        }
    }

    /**
     * Draws the screen and all the components in it. Args : mouseX, mouseY, renderPartialTicks
     */
    public void drawScreen(int mouseX, int mouseY, float partialTicks)
    {

    }
}

minecraft_de_Client_Main_Screens_GuiEditColorSign.java

package de.Client.Main.Screens;

import de.Client.Main.Main;
import de.Client.Render.ArrayLists.ArrayListD;
import de.Client.Utils.ArrayList;
import net.minecraft.block.Block;
import net.minecraft.client.gui.GuiButton;
import net.minecraft.client.gui.GuiScreen;
import net.minecraft.client.gui.GuiTextField;
import net.minecraft.client.gui.inventory.GuiEditSign;
import net.minecraft.client.network.NetHandlerPlayClient;
import net.minecraft.client.renderer.GlStateManager;
import net.minecraft.client.renderer.tileentity.TileEntityRendererDispatcher;
import net.minecraft.client.resources.I18n;
import net.minecraft.init.Blocks;
import net.minecraft.network.play.client.C12PacketUpdateSign;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.tileentity.TileEntitySign;
import net.minecraft.util.ChatComponentText;
import net.minecraft.util.ChatStyle;
import net.minecraft.util.IChatComponent;
import org.lwjgl.input.Keyboard;

import java.awt.*;
import java.io.IOException;

/**
 * Created by Daniel on 12.08.2017.
 */
public class GuiEditColorSign extends GuiScreen{
    TileEntitySign entitySign;
    public GuiEditColorSign(TileEntitySign sign){
        entitySign = sign;
    }

    public GuiTextField line1;
    public GuiTextField line2;
    public GuiTextField line3;
    public GuiTextField line4;
    public java.util.ArrayList<GuiTextField> lines = new java.util.ArrayList<>();
    @Override
    public void initGui(){
        Keyboard.enableRepeatEvents(true);
        double x = this.width/2-60;
        double y = this.height / 2-40;
        lines.clear();
        lines.add(line1 = new GuiTextField(0,mc.fontRendererObj,(int) x,(int) y+7,(int) 120,14));
        y += 20;
        lines.add(line2 = new GuiTextField(1,mc.fontRendererObj,(int) x,(int) y+7,(int) 120,14));
        y += 20;
        lines.add(line3 = new GuiTextField(1,mc.fontRendererObj,(int) x,(int) y+7,(int) 120,14));
        y += 20;
        lines.add(line4 = new GuiTextField(1,mc.fontRendererObj,(int) x,(int) y+7,(int) 120,14));
        y += 20;
        this.buttonList.add(new GuiButton(1,(int) x,(int) y+7,(int) 120,(int) 14,"sign"));
    }
    @Override
    public void onGuiClosed()
    {
        Keyboard.enableRepeatEvents(false);
        NetHandlerPlayClient var1 = this.mc.getNetHandler();
        if (var1 != null)
        {
            //       signText[0] =
            entitySign.signText[0] = new ChatComponentText(this.line1.getText());
            entitySign.signText[1] = new ChatComponentText(this.line2.getText());
            entitySign.signText[2] = new ChatComponentText(this.line3.getText());
            entitySign.signText[3] = new ChatComponentText(this.line4.getText());
            System.out.println(entitySign.signText[0]);
            var1.addToSendQueue(new C12PacketUpdateSign(this.entitySign.getPos(), this.entitySign.signText));

        }
    }
    @Override
    public void drawScreen(int mouseX, int mouseY, float partialTicks)
    {
        TileEntityRendererDispatcher.instance.renderTileEntityAt(this.entitySign, -Integer.MAX_VALUE, -0.75D, -0.5D, 0.0F);
        for(GuiTextField l : this.lines){
            l.drawTextBox();
        }
        this.drawDefaultBackground();
        line1.drawTextBox();
        line2.drawTextBox();
        line3.drawTextBox();
        line4.drawTextBox();
        System.out.println(this.line1.getText());
        super.drawScreen( mouseX,  mouseY,  partialTicks);

    }

    @Override
    protected void keyTyped(char typedChar, int keyCode) throws IOException
    {
        for(GuiTextField l : this.lines){
            l.textboxKeyTyped(typedChar,keyCode);
            l.setText(l.getText().replace("&","§r§"));
        }
        super.keyTyped(typedChar,keyCode);
    }

    @Override
    protected void mouseClicked(int mouseX, int mouseY, int mouseButton) throws IOException
    {
        for(GuiTextField l : this.lines){
            l.mouseClicked(mouseX,mouseY,mouseButton);
        }
      //  line1.mouseClicked(mouseX,mouseY,mouseButton);
      //  line2.mouseClicked(mouseX,mouseY,mouseButton);
     //   line3.mouseClicked(mouseX,mouseY,mouseButton);
      //  line4.mouseClicked(mouseX,mouseY,mouseButton);
        super.mouseClicked(mouseX,mouseY,mouseButton);
    }

}

minecraft_de_Client_Main_Screens_GuiProxy.java

/*
 * Copyright 2014 - 2017 | Wurst-Imperium | All rights reserved.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */
package de.Client.Main.Screens;

import java.io.IOException;

import org.lwjgl.input.Keyboard;

import net.minecraft.client.gui.GuiButton;
import net.minecraft.client.gui.GuiMultiplayer;
import net.minecraft.client.gui.GuiScreen;
import net.minecraft.client.gui.GuiTextField;


public class GuiProxy extends GuiScreen
{
    private GuiScreen prevMenu;
    private GuiTextField proxyBox;
    private String error = "";

    public GuiProxy(GuiScreen prevMultiplayerMenu)
    {
        prevMenu = prevMultiplayerMenu;
    }

    /**
     * Called from the main game loop to update the screen.
     */
    @Override
    public void updateScreen()
    {
        proxyBox.updateCursorCounter();
    }

    /**
     * Adds the buttons (and other controls) to the screen in question.
     */
    @Override
    public void initGui()
    {
        Keyboard.enableRepeatEvents(true);
        buttonList.clear();
        buttonList.add(
                new GuiButton(0, width / 2 - 100, height / 4 + 120 + 12, "Cancel"));
        buttonList.add(
                new GuiButton(1, width / 2 - 100, height / 4 + 72 + 12, "Connect"));
        buttonList.add(
                new GuiButton(2, width / 2 - 100, height / 4 + 96 + 12, "Reset"));
        proxyBox =
                new GuiTextField(0, fontRendererObj, width / 2 - 100, 60, 200, 20);
        proxyBox.setFocused(true);

    }

    /**
     * "Called when the screen is unloaded. Used to disable keyboard repeat
     * events."
     */
    @Override
    public void onGuiClosed()
    {
        Keyboard.enableRepeatEvents(false);
    }

    public static boolean isInteger(String s)
    {
        try
        {
            Integer.parseInt(s);
        }catch(NumberFormatException e)
        {
            return false;
        }
        return true;
    }
    @Override
    protected void actionPerformed(GuiButton clickedButton)
    {
        if(clickedButton.enabled)
            if(clickedButton.id == 0)
            {// Cancel

                mc.displayGuiScreen(prevMenu);
            }else if(clickedButton.id == 1)
            {// Connect


                // must contain ':' once
                if(!proxyBox.getText().contains(":")
                        || proxyBox.getText().split(":").length != 2)
                {

                    error = "Not a proxy!";
                    return;
                }

                String[] parts = proxyBox.getText().split(":");

                // validate port
                if(!this.isInteger(parts[1])
                        || Integer.parseInt(parts[1]) > 65536
                        || Integer.parseInt(parts[1]) < 0)
                {

                    error = "Invalid port!";
                    return;
                }

                try
                {
                    System.setProperty("socksProxyHost", parts[0]);
                    System.setProperty("socksProxyPort", parts[1]);
                }catch(Exception e)
                {

                    error = e.toString();
                    return;
                }

                if(error.isEmpty())
                {

                    mc.displayGuiScreen(prevMenu);
                }else{}

            }else if(clickedButton.id == 2)
            {// Reset


                System.setProperty("socksProxyHost", "");
                System.setProperty("socksProxyPort", "");

                mc.displayGuiScreen(prevMenu);
            }
    }

    /**
     * Fired when a key is typed. This is the equivalent of
     * KeyListener.keyTyped(KeyEvent e).
     */
    @Override
    protected void keyTyped(char par1, int par2)
    {
        proxyBox.textboxKeyTyped(par1, par2);

        if(par2 == 28 || par2 == 156)
            actionPerformed((GuiButton) buttonList.get(1));
    }

    /**
     * Called when the mouse is clicked.
     *
     * @throws IOException
     */
    @Override
    protected void mouseClicked(int par1, int par2, int par3) throws IOException
    {
        super.mouseClicked(par1, par2, par3);
        proxyBox.mouseClicked(par1, par2, par3);
        if(proxyBox.isFocused())
            error = "";
    }

    /**
     * Draws the screen and all the components in it.
     */
    @Override
    public void drawScreen(int par1, int par2, float par3)
    {
        drawDefaultBackground();
        drawCenteredString(fontRendererObj, "Use Proxy", width / 2, 20,
                0xFFFFFF);
        drawString(fontRendererObj, "IP:Port (must be a SOCKS proxy)",
                width / 2 - 100, 47, 0xA0A0A0);
        drawCenteredString(fontRendererObj, error, width / 2, 87, 0xFF0000);
        String currentProxy = System.getProperty("socksProxyHost") + ":"
                + System.getProperty("socksProxyPort");
        if(currentProxy.equals(":") || currentProxy.equals("null:null"))
            currentProxy = "none";
        drawString(fontRendererObj, "Current proxy: " + currentProxy,
                width / 2 - 100, 97, 0xA0A0A0);
        proxyBox.drawTextBox();
        super.drawScreen(par1, par2, par3);
    }
}

minecraft_de_Client_Main_Screens_GuiTheme.java

package de.Client.Main.Screens;

import de.Client.Render.GuiIngameHook;
import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.GuiIngame;
import net.minecraft.client.gui.GuiScreen;

/**
 * Created by Daniel on 04.07.2017.
 */
public class GuiTheme extends GuiScreen{
    GuiIngame ingame = new GuiIngame(Minecraft.getMinecraft());
    public void drawScreen(int mouseX, int mouseY, float partialTicks)
    {
        ingame.func_175180_a(1);
    }
}

minecraft_de_Client_Main_Screens_UIApp.java

package de.Client.Main.Screens;

import com.google.common.collect.Lists;
import de.Client.Events.EventTarget;
import de.Client.Main.Main;
import de.Client.Main.Screens.UIApps.UIButton;
import de.Client.Render.GuiApi;
import de.Client.Render.TTFManager;
import de.Client.Utils.ColorUtil;
import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.*;
import net.minecraft.util.MathHelper;
import org.lwjgl.Sys;
import org.lwjgl.input.Mouse;
import org.lwjgl.opengl.GL11;
import org.omg.Messaging.SYNC_WITH_TRANSPORT;

import java.awt.*;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

/**
 * Created by Daniel on 19.08.2017.
 */
public class UIApp {
    public boolean isOpen;
    public double x;
    public double y;
    public double dragX;
    public double dragY;
    public double scale = 0.5;
    public boolean isDragging;
    public boolean isFullscreen;
    public double height;
    public double width;
    public String name;
    public ScaledResolution sr = new ScaledResolution();
    public java.util.ArrayList<UIButton> buttonArrayList = new ArrayList();
    public double getScale(){
        return isFullscreen ? 1 : scale;
    }

    public double minScale = 0;
    public double maxScale = 0.9;
    public UIApp(String name,double minScale){
        this.name = name;
        this.minScale =minScale;
    }
    public UIApp(String name){
        this.name = name;
    }
    public void initGui(){
        buttonArrayList.clear();
        sr = new ScaledResolution();
        height = sr.getScaledHeight() *scale;
        width = sr.getScaledWidth()   *scale;
    }

    public void updateScale(){
        double lastscale = scale;
        scale += Mouse.getDWheel() / 10000.0d;
        if(scale < minScale){
         //   scale = minScale;
        }
        if(scale > maxScale){
         //   scale = maxScale;
        }
    }

    public double getHeight(){
        return sr.getScaledHeight() /scale;
    }
    public double getWith(){
        return sr.getScaledWidth() /scale;
    }

    public void uiClick(double mouseX, double mouseY, float partialTicks){

    }
    public void drawUI(double mouseX, double mouseY, float partialTicks){
        scale += Mouse.getDWheel() / 10000f;
    }
    public float getDistance(double x,double y,double x1,double y1){
       return MathHelper.sqrt_float((float) ((x-x1) * (x-x1)+ (y-y1) * (y-y1)));
    }
    public TTFManager X = new TTFManager("Verdana",0,30);
    public void drawScreen(int mouseX, int mouseY, float partialTicks) {
        if(this.isDragging) {
            this.x = mouseX - this.dragX;
            this.y = mouseY - this.dragY;
            if(x < 0){
                x = 0;
            }
            if(x + width > sr.getScaledWidth()){
                x = sr.getScaledWidth()-width;
            }
            if(y < 0){
                y = 0;
            }
            if(y + height > sr.getScaledHeight()-23){
                y = sr.getScaledHeight()-height-23;
            }
        }

        if(isOpen) {

         //   System.out.println(this.width);

            GL11.glTranslated(x, y, 0);
            GL11.glScaled(getScale(),1,1);
            Gui.drawRect(0, 0,sr.getScaledWidth(), 16, Main.getMain.getClientColor().getRGB());
         //   Gui.drawRect(sr.getScaledWidth()-1-14/scale, 1,sr.getScaledWidth()-1, 15, new Color(0xB9000C).getRGB());
            GL11.glScaled(1,getScale(),1);
            Gui.drawRect(0, 16/ scale,sr.getScaledWidth(), sr.getScaledHeight(), new Color(0x502B2B2B).getRGB());
            GL11.glTranslated(0,16/scale,0);
            drawUI(mouseX,mouseY,partialTicks);
            for(UIButton b : this.buttonArrayList){
                b.drawButton((float) ((float) ((mouseX-x)/getScale())), (float) ((float) ((mouseY-y)/scale)));
            }
            height = sr.getScaledHeight() + 16/scale;
            GL11.glTranslated(0,-16/scale,0);
            GL11.glScaled(1,1/getScale(),1);
            GL11.glScaled(1 / getScale(),1,1);
            System.out.println(getDistance(mouseX,mouseY,(sr.getScaledWidth()*scale)-8+x,8*scale+y));
            if(getDistance(mouseX,mouseY,(sr.getScaledWidth()*scale)-8+x,9*scale+y) < 8) {

                GuiApi.drawBorderedCircle((sr.getScaledWidth() * scale) - 8, 8, (float) (7), new Color(0xFF1C0E).getRGB(), new Color(0xFF1C0E).getRGB());
            }else{
     //           GuiApi.drawBorderedCircle((sr.getScaledWidth() * scale) - 8, 8, (float) (7), Main.getMain.getClientColor(),);
            }
            Main.getMain.verdanas.drawStringWithShadow(name,4,0,0xffffffff);
            X.drawCenteredString("x", (float) ((sr.getScaledWidth() * scale)-8.4f),-3.5f,0xffffffff);
            GL11.glTranslated(-x, -y, 0);
        }
        updateScale();
        height = sr.getScaledHeight() *scale;
        width = sr.getScaledWidth()   *scale;
    }

    public void actionPerformed(GuiButton guiButton){

    }
    public double realscale = 0.5;

    public void actionPerformed(int id){

    }

    public void mouseClicked(int mouseX, int mouseY, int mouseButton) throws IOException
    {
        for(UIButton b : this.buttonArrayList){
            b.mouseClicked(mouseX,mouseY,mouseButton);
        }
        if(!isOpen){
            return;
        }
        if(getDistance(mouseX,mouseY,(sr.getScaledWidth()*scale)-8+x,9*scale+y) < 8) {
            isOpen = false;
        }
        if((mouseX >= this.x) && (mouseX <= this.x + this.width ) && (mouseY >= this.y) && (mouseY <= this.y +16) && mouseButton == 0) {
            this.isDragging = true;
            this.dragX = mouseX - this.x;
            this.dragY = mouseY - this.y;
        }
    }
    public void mouseReleased(int mouseX, int mouseY, int mouseButton){
        if(  mouseButton == 0) {
            isDragging = false;
        }
    }

}

minecraft_de_Client_Main_Screens_UIAppButton.java

package de.Client.Main.Screens;

import de.Client.Main.Main;
import de.Client.Main.Screens.UIApp;
import de.Client.Render.GuiApi;
import de.Client.Utils.ColorUtil;
import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.Gui;
import net.minecraft.client.gui.GuiButton;
import net.minecraft.client.gui.ScaledResolution;
import net.minecraft.util.ResourceLocation;
import org.lwjgl.opengl.GL11;

import java.awt.*;

public class UIAppButton
        extends GuiButton
{
    private int x;
    private int y;
    private int x1;
    private int y1;
    private String text;
    double alphaInc = 0;
    int alpha = 0;
    float size = 0;
    public UIApp uiApp;


    public UIAppButton(int buttondid, int x, int y, String resourcelocation,UIApp app)
    {
        super(buttondid, x, y, x+24, y+24, resourcelocation);
        this.x = x;
        this.y = y;
        this.x1 = x+20;
        this.y1 = y+20;
        uiApp = app;
        this.text = resourcelocation;
    }
    public void startScissors(int x, int y, int width, int height) {
        GL11.glPushMatrix();
        GL11.glEnable(GL11.GL_SCISSOR_TEST);
        ScaledResolution sr1 = new ScaledResolution();
        int factor = sr1.getScaleFactor();

        GL11.glScissor(x * factor, (sr1.getScaledHeight() - height) * factor, Math.abs((width - x) * factor), Math.abs((height - y) * factor));
    }
    public static void drawImage(int x, int y, int width, int height, String resLocation) {
            Minecraft.getMinecraft().getTextureManager().bindTexture(new ResourceLocation("Sunrise/Backgrounds/" + resLocation));
            Gui.drawModalRectWithCustomSizedTexture(x, y, 0.0F, 0.0F, width, height, width, height);
    }
    public void stopScissor() {
        GL11.glDisable(GL11.GL_SCISSOR_TEST);
        GL11.glPopMatrix();
    }

    public int animation;

    public void drawButton(Minecraft mc, int mouseX, int mouseY)
    {
        Gui.drawRect(x-2,this.height-24,x1+2,y1+20,ColorUtil.transparency(Color.BLACK,0.2));
        boolean isOverButton = (mouseX >= this.x) && (mouseX <= this.x1) && (mouseY >= this.y) && (mouseY <=  this.y1);
        ColorUtil.setColor(Color.BLACK);
        drawImage(x,y,20,20,text);
        if(isOverButton){
            Gui.drawRect(x-2,this.height-24,x1+2,y1,ColorUtil.transparency(Color.BLACK,0.1));
            ColorUtil.setColor(Main.getMain.getClientColor());
        }else{
            ColorUtil.setColor(Color.WHITE);
        }
        drawImage(x,y,20,20,text);
        Gui.drawRect((x+x1)/2f+animation,y1+1,(x+x1)/2f-animation,y1,Main.getMain.getClientColor().getRGB());
        if(uiApp.isOpen){
            if(animation < (x+x1)/4-5){
                animation ++;
            }
        }else{
            if(animation > 0){
                animation --;
            }
        }
            if(isOverButton) {
                GL11.glTranslated(0,0,1000);
                double x = mouseX - Main.getMain.verdanas.getWidth(uiApp.name)/2 + 4 < 8 ? Main.getMain.verdanas.getWidth(uiApp.name)/2 + 4  : mouseX;

                GuiApi.drawBorderRectNoCorners(x - Main.getMain.verdanas.getWidth(uiApp.name)/2 - 2,   this.height-25.5, x + Main.getMain.verdanas.getWidth(uiApp.name)/2 + 2, this.height-25.5 - 15, Main.getMain.getClientColor().getRGB(), new Color(0x3B3C3F).getRGB());
                Main.getMain.verdanas.drawCenteredStringWithShadow(uiApp.name, (float) (x),this.height-40f,0xffffffff);
                GL11.glTranslated(0,0,-1000);
            }
    }
}

minecraft_de_Client_Main_Screens_UIApps_UIAltManager.java

package de.Client.Main.Screens.UIApps;

import com.mojang.authlib.GameProfile;
import de.Client.Main.Main;
import de.Client.Main.Screens.*;
import de.Client.Render.GuiApi;
import de.Client.Utils.*;
import net.minecraft.client.Minecraft;
import net.minecraft.client.entity.EntityOtherPlayerMP;
import net.minecraft.client.gui.*;
import net.minecraft.client.renderer.GlStateManager;
import net.minecraft.client.renderer.Tessellator;
import net.minecraft.client.renderer.WorldRenderer;
import net.minecraft.util.ResourceLocation;
import org.lwjgl.input.Controller;
import org.lwjgl.input.Keyboard;
import org.lwjgl.input.Mouse;

import java.awt.*;
import java.io.*;
import java.util.ArrayList;
import java.util.List;

public class UIAltManager extends UIApp {
    public static ArrayList<Alt> AltListArray = new ArrayList<Alt>();
    public static AccountLoginThread thread;
    private String status;
    private Alt alttoremove;
    public int mousediffrent;
    public static TimeHelper time = new TimeHelper();
    public boolean animationSwitch;
    public double animationTicks;
    public Minecraft mc = Minecraft.getMinecraft();
    public FontRenderer fr = Minecraft.getMinecraft().fontRendererObj;
    public TimeHelper timeHelper = new TimeHelper();
    public UIAltManager(GuiScreen prevScreen) {
        super("AltManager",0.35);
    }
    private void setStatus(String status) {
        status = thread.getStatus();
    }
    @Override
    public void mouseClicked(int mouseX, int mouseY, int mouseButton) throws IOException {
        super.mouseClicked(mouseX, mouseY, mouseButton);
    }
    @Override
    public void initGui(){
        super.initGui();
        this.buttonArrayList.add(new UIButton(this,1,"Login",(float)((float) sr.getScaledWidth() / 1.48f), (float) (sr.getScaledHeight() -47),(float)((float) sr.getScaledWidth() / 1.02-sr.getScaledWidth() / 1.5),30,new Color(0x31C211)));
        this.buttonArrayList.add(new UIButton(this,1,"Delete",(float)((float) sr.getScaledWidth() / 1.48f), (float) (sr.getScaledHeight() -83),(float)((float) sr.getScaledWidth() / 1.02-sr.getScaledWidth() / 1.5)/2f-2,30,new Color(0xAD1312)));
        this.buttonArrayList.add(new UIButton(this,1,"Add",((float) sr.getScaledWidth() / 1.48f)+(float)((float) sr.getScaledWidth() / 1.02-sr.getScaledWidth() / 1.5)/2f+1, (float) (sr.getScaledHeight() -83),(float)((float) sr.getScaledWidth() / 1.02-sr.getScaledWidth() / 1.5)/2-1,30,new Color(0xDED700)));
    }

    @Override
    public void actionPerformed(int id) {

    }
    protected void overlayBackground(int p_148136_1_, int p_148136_2_, int p_148136_3_, int p_148136_4_)
    {
        Tessellator var5 = Tessellator.getInstance();
        WorldRenderer var6 = var5.getWorldRenderer();
        this.mc.getTextureManager().bindTexture(Gui.optionsBackground);
        GlStateManager.color(1.0F, 1.0F, 1.0F, 1.0F);
        float var7 = 32.0F;
        var6.startDrawingQuads();
        var6.func_178974_a(4210752, p_148136_4_);
        var6.addVertexWithUV((double)0, (double)p_148136_2_, 0.0D, 0.0D, (double)((float)p_148136_2_ / var7));
        var6.addVertexWithUV((double)(this.width), (double)p_148136_2_, 0.0D, (double)((float)this.width / var7), (double)((float)p_148136_2_ / var7));
        var6.func_178974_a(4210752, p_148136_3_);
        var6.addVertexWithUV((double)(this.width), (double)p_148136_1_, 0.0D, (double)((float)this.width / var7), (double)((float)p_148136_1_ / var7));
        var6.addVertexWithUV((double)0, (double)p_148136_1_, 0.0D, 0.0D, (double)((float)p_148136_1_ / var7));
        var5.draw();
    }
    public static String[] readFile(File file) {
        if (file.exists()) {
            try {
                FileReader fileReader = new FileReader(file);
                BufferedReader bufferedReader = new BufferedReader(fileReader);
                List<String> lines = new ArrayList();
                String line = null;
                while ((line = bufferedReader.readLine()) != null) {
                    lines.add(line);
                }
                bufferedReader.close();
                return (String[]) lines.toArray(new String[lines.size()]);
            } catch (Exception ignored) {
            }
        } else {
            System.out.println("[SkyRise] - Bind-Datei existiert nicht!");
        }
        return null;
    }

    public void saveAlts() throws IOException {

        File file = Main.getMain.altList;

        if(file.exists()) {
            file.delete();
        }

        file.createNewFile();


        PrintWriter output = null;
        try {
            output = new PrintWriter(new FileWriter(file, true));
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        for(Alt alts : UIAltManager.AltListArray) {
            output.println(alts.getEmail() + ":" + alts.getPassword() + ":"+alts.name);
        }
        output.close();

    }
    @Override
    public void drawUI(double mouseX, double mouseY, float partialTicks){
//0x595959
     //   boolean isOverButton = (mouseX >= this.x) && (mouseX <= x+width) && (mouseY >= this.y) && (mouseY <=  17);
        GuiApi.drawBorderedCircle(15,20, (float) (7),new Color(0x404040).getRGB(),new Color(0x404040).getRGB());
        Gui.drawRect(22.02,20,7.98,sr.getScaledHeight() - 16 / scale-20,new Color(0x404040).getRGB());
        GuiApi.drawBorderedCircle(15,sr.getScaledHeight() - 16 / scale-20, (float) (7),new Color(0x404040).getRGB(),new Color(0x404040).getRGB());
        Gui.drawRect(22.02,10,22.5,sr.getScaledHeight() - 16 / scale-10,new Color(0x502B2B2B).getRGB());//0x502B2B2B
        Gui.drawRect(7.98,10,7.5,sr.getScaledHeight() - 16 / scale-10,new Color(0x502B2B2B).getRGB());
        Gui.drawRect(22.02,17,sr.getScaledWidth() / 1.5,sr.getScaledHeight() - 16 / scale-17,new Color(0x1C1C1C).getRGB());
    }


    public ArrayList<Rect> city = new ArrayList<>();


}

minecraft_de_Client_Main_Screens_UIApps_UIButton.java

package de.Client.Main.Screens.UIApps;


import de.Client.Main.Main;
import de.Client.Main.Screens.UIApp;
import de.Client.Render.GuiApi;
import de.Client.Render.TTFManager;
import net.minecraft.client.gui.Gui;
import net.minecraft.client.gui.ScaledResolution;
import org.newdawn.slick.*;

import java.awt.*;
import java.awt.Color;
import java.awt.Font;

public class UIButton {
    public String name;
    public int id;
    public float x;
    public float y;
    public float width;
    public float height;
    public Color c;
    public boolean isMouseOver;
    public UIApp owner;
    public TTFManager verdanab =new TTFManager("Verdana", Font.PLAIN,52);
    public UIButton(UIApp owner, int id ,String name, float x,float y,float width,float height,Color c){
        this.c = c;
        this.id = id;
        this.x = x;
        this.y = y;
        this.width = width;
        this.height = height;
        this.owner = owner;
        this.name = name;
       // verdanab =new TTFManager("Verdana", Font.PLAIN,52);
    }

    public void drawButton(float mouseX,float mouseY) {
        if ((mouseX >= this.x) && (mouseX <= this.x + this.width) && (mouseY >= this.y) && (mouseY <= this.y + height)) {
            isMouseOver = true;
            Gui.drawRect(x, ((y )) - 16/ owner.scale-1, x + width, ((y + height))- 16 / owner.scale, c.getRGB());
        }else{
            Gui.drawRect(x, ((y )) - 16 / owner.scale, x + width, ((y + height))- 16 / owner.scale,c.darker().getRGB());
            isMouseOver = false;
        }
        verdanab.drawCenteredString(name,x+width / 2+1.3f, (float) (((y + height/2-19))- 16 / owner.scale)+1.3f, 0xff000000);
        verdanab.drawCenteredString(name,x+width / 2, (float) (((y + height/2-19))- 16 / owner.scale), 0xffffffff);
      //  Main.getMain.verdanas.drawCenteredString(name,x,y+height/2-5,0xffffffff);
    }

    public void mouseClicked(float mouseX,float mouseY,int mousebutton){
        if(mousebutton == 1 && isMouseOver) {
            owner.actionPerformed(id);
        }

    }

}

minecraft_de_Client_Main_Values_Value.java

package de.Client.Main.Values;

public class Value {

	private String name;

	public Value(String name) {
		this.name = name;
	}

	public String getName() {
		return this.name;
	}

	public void setName(String name) {
		this.name = name;
	}
}

minecraft_de_Client_Main_Values_ValueBoolean.java

package de.Client.Main.Values;

public class ValueBoolean extends Value {

	private boolean value;
	
	public ValueBoolean(String name, boolean value) {
		super(name);
		this.value = value;
	}
	
	public boolean getValue() {
		return this.value;
	}

	public void setValue(boolean value) {
		this.value = value;
	}
}

minecraft_de_Client_Main_Values_ValueDouble.java

package de.Client.Main.Values;

public class ValueDouble extends Value {

	private String name;
	private double value;
	private double min;
	private double max;
	private int round;
	
	public ValueDouble(String name, double value, double min, double max, int round) {
		super(name);
		this.value = value;
		this.min = min;
		this.max = max;
		this.round = round;
	}
	
	public ValueDouble(String name, double value, double min, double max) {
		super(name);
		this.value = value;
		this.min = min;
		this.max = max;
		this.round = 1;
	}
	
	public double getValue() {
		return this.value;
	}
	
	public void setValue(double value) {
		this.value = value;
	}
	
	public int getRound() {
		return this.round;
	}
	
	public double getMin() {
		return this.min;
	}
	
	public double getMax() {
		return this.max;
	}
}

minecraft_de_Client_Render_ArrayLists_ArrayListC.java

package de.Client.Render.ArrayLists;

import de.Client.Main.Main;
import de.Client.Main.Modules.Category;
import de.Client.Main.Modules.Module;
import de.Client.Utils.ArrayList;
import de.Client.Utils.ColorUtil;
import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.Gui;
import net.minecraft.client.renderer.GlStateManager;
import net.minecraft.client.renderer.tileentity.TileEntityRendererDispatcher;
import net.minecraft.tileentity.TileEntitySign;
import net.minecraft.util.ResourceLocation;
import org.lwjgl.opengl.GL11;

import java.awt.*;
import java.sql.Wrapper;
import java.util.*;

/**
 * Created by Daniel on 15.07.2017.
 */
public class ArrayListC extends ArrayList{
    public HashMap<Module,Color> getColorForModule = new HashMap();
    public ArrayListC(){
        getColorForModule.clear();
        for(Module m : Main.getMain.moduleManager.modules){
            Color c = new Color(new Random().nextInt(Integer.MAX_VALUE));
            getColorForModule.put(m,new Color( ColorUtil.transparency(c,1)));
        }
    }
    private static java.util.List<Module> getSortedModuleArray() {
        java.util.ArrayList<Module> list = new java.util.ArrayList<Module>();
        for (Module mod : Main.getMain.moduleManager.modules) {
            if(mod.isModuleImportant()){
                if ((!(mod.category == (Category.None)) || mod.name.equals("88"))
                        && (!(mod.category == (Category.Gui))) ) {
                    if (mod.getState()) {
                        list.add(mod);
                    }
                }
            }
        }
        list.sort((m1, m2) -> {
            String s1 = String.valueOf(m1.displayName);
            String s2 = String.valueOf(m2.displayName);
            float cmp = 0;
            cmp = ((Minecraft.getMinecraft().fontRendererObj.getStringWidth(s2) * 999) - (Minecraft.getMinecraft().fontRendererObj.getStringWidth(s1) * 999));


            return (int) (cmp != 0 ? cmp : s1.compareTo(s2) * 2);
        });
        return list;
    }
    public void draw(double scaledX, double scaledY){
        int y = 0;
       // TileEntityRendererDispatcher.instance.renderTileEntityAt(new TileEntitySign(), -0.5D, -0.75D, -0.5D, 0.0F);
 //       TileEntityRendererDispatcher.instance.renderTileEntityAt(new TileEntitySign(), -0.5D, -0.75D, -0.5D, 0.0F);
        Minecraft.getMinecraft().getTextureManager().bindTexture(new ResourceLocation("textures/gui/title/minecraft.png"));
        for(Module mod : getSortedModuleArray()){
            if(mod.getState){
                //	    this.drawGradientRect(sr.getScaledWidth()-1, y,sr.getScaledWidth()-Main.getMain.verdana.getWidth(mod.displayName)-1, y+1,);

                Minecraft.getMinecraft().fontRendererObj.drawStringWithShadow  (mod.displayName, (float) scaledX-Minecraft.getMinecraft().fontRendererObj.getStringWidth(mod.displayName), y+2,this.getColorForModule.get(mod).getRGB());
                y += 9;
            }
        }
    }
}

minecraft_de_Client_Render_ArrayLists_ArrayListD.java

package de.Client.Render.ArrayLists;

import de.Client.Main.Main;
import de.Client.Main.Modules.Category;
import de.Client.Main.Modules.Module;
import de.Client.Utils.ArrayList;

import java.util.List;

public class ArrayListD extends ArrayList{
    public void draw(double scaledX, double scaledY){
        int y = 0;
        for(Module mod : getSortedModuleArray()){
            if(mod.getState){
                //	    this.drawGradientRect(sr.getScaledWidth()-1, y,sr.getScaledWidth()-Main.getMain.verdana.getWidth(mod.displayName)-1, y+1,);
                Main.getMain.verdana.drawfixedStringWithShadow(mod.displayName, (float) scaledX-Main.getMain.verdana.getWidth(mod.displayName)-1, -2+y, Main.getMain.getPurple(y*4,10000000).getRGB());
                y += 13;
            }
        }
    }
    private static List<Module> getSortedModuleArray() {
        java.util.ArrayList<Module> list = new java.util.ArrayList<Module>();
        for (Module mod : Main.getMain.moduleManager.modules) {
            if(mod.isModuleImportant()){
                if ((!(mod.category == (Category.None)) || mod.name.equals("88"))
                        && (!(mod.category == (Category.Gui))) ) {
                    if (mod.getState()) {
                        list.add(mod);
                    }
                }
            }
        }
        list.sort((m1, m2) -> {
            String s1 = String.valueOf(m1.displayName);
            String s2 = String.valueOf(m2.displayName);
            float cmp = 0;
            cmp = ((Main.getMain.verdana.getWidth(s2) * 999) - (Main.getMain.verdana.getWidth(s1) * 999));


            return (int) (cmp != 0 ? cmp : s1.compareTo(s2) * 2);
        });
        return list;
    }

}

minecraft_de_Client_Render_ArrayLists_ArrayListD2.java

package de.Client.Render.ArrayLists;

import de.Client.Main.Main;
import de.Client.Main.Modules.Category;
import de.Client.Main.Modules.Module;
import de.Client.Utils.ArrayList;
import net.minecraft.client.gui.Gui;
import org.newdawn.slick.Color;

import java.util.List;

public class ArrayListD2 extends ArrayList{
    public void draw(double scaledX, double scaledY){
        int y = -1;
        for(Module mod : getSortedModuleArray()){
            if(mod.getState){
                Gui.drawRect((float) scaledX-Main.getMain.verdanas.getWidth(mod.displayName)-3,+y+1,scaledX,13+y, Main.getMain.getPurple(y*4,10000000).getRGB());
                Gui.drawRect((float) scaledX-Main.getMain.verdanas.getWidth(mod.displayName)-2,+y+1,scaledX,12+y, 0xff2b2b2b);
                //	    this.drawGradientRect(sr.getScaledWidth()-1, y,sr.getScaledWidth()-Main.getMain.verdana.getWidth(mod.displayName)-1, y+1,);
                Main.getMain.verdanas.drawfixedStringWithShadow(mod.displayName, (float) scaledX-Main.getMain.verdanas.getWidth(mod.displayName)-1, -2+y, Main.getMain.getPurple(y*4,10000000).getRGB());

                y += 11;
            }
        }
    }
    private static List<Module> getSortedModuleArray() {
        java.util.ArrayList<Module> list = new java.util.ArrayList<Module>();
        for (Module mod : Main.getMain.moduleManager.modules) {
            if(mod.isModuleImportant()){
                if ((!(mod.category == (Category.None)) || mod.name.equals("88"))
                        && (!(mod.category == (Category.Gui))) ) {
                    if (mod.getState()) {
                        list.add(mod);
                    }
                }
            }
        }
        list.sort((m1, m2) -> {
            String s1 = String.valueOf(m1.displayName);
            String s2 = String.valueOf(m2.displayName);
            float cmp = 0;
            cmp = ((Main.getMain.verdanas.getWidth(s2) * 999) - (Main.getMain.verdanas.getWidth(s1) * 999));


            return (int) (cmp != 0 ? cmp : s1.compareTo(s2) * 2);
        });
        return list;
    }

}

minecraft_de_Client_Render_ArrayLists_ArrayListS.java

package de.Client.Render.ArrayLists;

import de.Client.Main.Main;
import de.Client.Main.Modules.Module;
import de.Client.Render.TTFManager;
import de.Client.Utils.ArrayList;
import de.Client.Utils.ColorUtil;
import net.minecraft.client.gui.Gui;
import net.minecraft.client.gui.ScaledResolution;

import java.awt.*;
import java.util.*;
import java.util.List;

/**
 * Created by Daniel on 08.08.2017.
 */
public class ArrayListS extends ArrayList{
    public HashMap<Module,Color> getColorForModule = new HashMap();

    public ArrayListS(){
        getColorForModule.clear();
        for(Module m : Main.getMain.moduleManager.modules){
            Color c = new Color(new Random().nextInt(Integer.MAX_VALUE));
            getColorForModule.put(m,new Color( ColorUtil.transparency(c,1)));
        }
    }
     TTFManager Mayeka = new TTFManager("Mayeka Regular Demo", Font.PLAIN,18);
    public void draw(double scaledX, double scaledY){

        ScaledResolution sr = new ScaledResolution();
        List<Module> modules = Main.getMain.moduleManager.getActiveModules();
        Collections.sort(modules, new Comparator<Module>() {
            @Override
            public int compare(Module m1, Module m2) {
                return Integer.valueOf((int) Mayeka.getWidth(m2.name)).compareTo(Integer.valueOf((int) Mayeka.getWidth(m1.name)));
            }
        });
        int y = 0;
        for(Module module : modules) {
            if(module.getState) {


                Gui.drawRect(sr.getScaledWidth() - Mayeka.getWidth(module.name) - 7, y, sr.getScaledWidth(), y + 11, 0x90000000);
                Gui.drawRect(sr.getScaledWidth() - 2, y, sr.getScaledWidth(), y + 11, getColorForModule.get(module).getRGB());
                Mayeka.drawStringWithShadow(module.name, sr.getScaledWidth() - Mayeka.getWidth(module.name) - 5, y , getColorForModule.get(module).getRGB());
                y += 11;
            }
        }
    }
}

minecraft_de_Client_Render_CircleGui_CircleGui.java

package de.Client.Render.CircleGui;

/**
 * Created by Daniel on 12.11.2017.
 */
public class CircleGui {

    public CircleGui getGui = new CircleGui();


}

minecraft_de_Client_Render_CircleGui_CircleUtils.java

package de.Client.Render.CircleGui;

import de.Client.Main.Main;
import de.Client.Main.Modules.mods.Render.Gui;
import de.Client.Render.GuiApi;

import java.awt.*;

/**
 * Created by Daniel on 12.11.2017.
 */
public class CircleUtils {
    public static float getAngleForPeaces(int mouseX, int mouseY, int i, float peaces){
        return 360 / peaces;
    }
    public static double getMouseAngelForPoint(float mouseX, float mouseY, float pointX,float pointY) {
        // Math.asin(2);

        //  Main.getMain.cmdManager.sendChatMessage();
        double relativeMouseX = mouseX - pointX;
        double relativeMouseY = mouseY - pointY;
        double hypothenuse = Math.sqrt(relativeMouseX * relativeMouseX + relativeMouseY * relativeMouseY);
        double angle = relativeMouseY / relativeMouseX;
        angle = Math.toDegrees(Math.atan(angle));
        if(relativeMouseX < 0){
            angle = 180+angle;
        }else{
            if(relativeMouseY < 0){
                angle +=360;
            }
        }
        angle += 90;
        return angle % 360;

    }
}

minecraft_de_Client_Render_ClickGui_ClickGui.java

package de.Client.Render.ClickGui;

import de.Client.Main.Main;
import de.Client.Main.Modules.Category;
import de.Client.Render.ClickGui.Panels.Panel;
import net.minecraft.client.gui.GuiScreen;
import net.minecraft.util.ResourceLocation;

import java.io.IOException;
import java.util.ArrayList;

public class ClickGui extends GuiScreen {

	public ClickGui() {
		panels.add(this.panelCombat);
		panels.add(this.panaelMovement);
		panels.add(this.panelPlayer);
		panels.add(this.panelRender);
		panels.add(this.panelWorld);


	}

	

	public ArrayList<Panel> panels = new ArrayList<Panel>();

	public Panel panelCombat = new Panel(Category.COMBAT, 65, 20,
			new ResourceLocation("Sunrise/Backgrounds/Combat.png"), this);
	public Panel panaelMovement = new Panel(Category.MOVEMENT, 195, 20,
			new ResourceLocation("Sunrise/Backgrounds/Movement.png"), this);
	public Panel panelPlayer = new Panel(Category.PLAYER, 65, 50,
			new ResourceLocation("Sunrise/Backgrounds/Player.png"), this);
	public Panel panelRender = new Panel(Category.RENDER, 195, 50,
			new ResourceLocation("Sunrise/Backgrounds/Render.png"), this);
	public Panel panelWorld = new Panel(Category.WORLD, 65, 80, new ResourceLocation("Sunrise/Backgrounds/World.png"),
			this);

	@Override
	protected void mouseReleased(int mouseX, int mouseY, int state) {
		super.mouseReleased(mouseX, mouseY, state);
				for(int i= 0; i < this.panels.size(); ++i){
					Panel p = this.panels.get(i);
			p.mouseReleased(mouseX, mouseY, state);
		}
	}

	public void updateAnimation(){
	    for(Panel p : this.panels){
	        p.updateAnimation();
        }
    }

	public Panel setPanelToFont(Panel p,boolean open) {
			int panelIndex = panels.indexOf(p);
            for(Panel p1 : this.panels) {
                p1.front = false;
            }
			p.front = true;
			panels.remove(panelIndex);
			panels.add(p);
			return p;
	}

	@Override
	public void drawScreen(int mouseX, int mouseY, float partialTicks) {

		for(int i= 0; i < this.panels.size(); ++i){
			Panel p = this.panels.get(i);
			p.drawPanel();
		}

	}

	@Override
	public void initGui() {
        for(int i= 0; i < this.panels.size(); ++i) {
            Panel p = this.panels.get(i);
            p.init();
        }
	}
	@Override
        public void keyTyped(char typedChar, int keyCode) throws IOException
        {
        for (int i = 0; i < this.panels.size();++i) {
            Panel p = this.panels.get(i);
            p.keyTyped(typedChar,keyCode);
        }
        super.keyTyped(typedChar,  keyCode);
    }
	@Override
	protected void mouseClicked(int mouseX, int mouseY, int mouseButton) throws IOException {
		for (int i = 0; i < this.panels.size();++i) {
			Panel p = this.panels.get(i);
			p.mouseClick(mouseX, mouseY, mouseButton);
		}
	}

}

minecraft_de_Client_Render_ClickGui_Panels_Button.java

package de.Client.Render.ClickGui.Panels;

import de.Client.Main.Main;
import de.Client.Main.Modules.Module;
import de.Client.Main.Values.Value;
import de.Client.Main.Values.ValueBoolean;
import de.Client.Render.ClickGui.Panels.Minitypes.MiniKeyBind;
import de.Client.Render.GuiApi;
import de.Client.Render.TTFManager;
import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.Gui;
import org.lwjgl.opengl.GL11;

import java.awt.*;
import java.io.IOException;
import java.util.ArrayList;

public class Button {
	
	public int height;
	
	public int x;
	public int y;
	
	public Panel ownerPanel;
	
	public boolean isOpen;
	public ArrayList<Mini> valueButtons= new ArrayList<Mini>();
	public Module module;
	
	public Button(Module mod,Panel p){
		module = mod;
		ownerPanel = p;

		if(!mod.createArray().isEmpty()){
		    for(Mini m : mod.createArray()){
		        valueButtons.add(m);
            }
            valueButtons.add(new MiniKeyBind(mod));
        }else{
            for(Mini m : this.autoGenerateArray()){
                valueButtons.add(m);
            }
        }
	}
	public ArrayList<Mini> autoGenerateArray(){
        ArrayList<Mini> list = new ArrayList<>();
        list.add(new MiniKeyBind(this.module));
        return list;
    }

	public static TTFManager verdana =new TTFManager("Verdana",Font.PLAIN,22);
	public boolean mouse(float mouseX, float mouseY, float minX, float maxX, float minY, float maxY) {
        return (mouseX >= minX && mouseX <= maxX) && (mouseY >= minY && mouseY <= maxY);
    }
    public void keyTyped(char typedChar, int keyCode) throws IOException
    {
        if(this.isOpen) {
            for (Mini m : this.valueButtons) {
                m.keyTyped(typedChar, keyCode);
            }
        }
    }
	public void mouseClick(int mouseX,int mouseY,int mouseType){
	    System.out.println("test");
	    if(this.isOpen) {
            for (Mini m : this.valueButtons) {
                m.mouseClick(x, y);
            }
        }
		boolean isMouseOver = this.mouse(mouseX, mouseY, x-60, x+60, y-9, y+8);
		if(isMouseOver){
			
			if(mouseType == 0){
                if(!module.getState){
                    Minecraft.getMinecraft().theWorld.playSound(Minecraft.getMinecraft().thePlayer.posX,Minecraft.getMinecraft().thePlayer.posY,Minecraft.getMinecraft().thePlayer.posZ,"random.click",10000, 1,false);
                }else{
                    Minecraft.getMinecraft().theWorld.playSound(Minecraft.getMinecraft().thePlayer.posX,Minecraft.getMinecraft().thePlayer.posY,Minecraft.getMinecraft().thePlayer.posZ,"random.click",10000, -1,false);
                }
				this.module.toggleModule();


			}else if(mouseType == 1){
				this.isOpen = !this.isOpen;
				if(!this.isOpen){
                    for(Mini m : this.valueButtons){
                        m.closeMini();
                    }
                    Minecraft.getMinecraft().theWorld.playSound(Minecraft.getMinecraft().thePlayer.posX,Minecraft.getMinecraft().thePlayer.posY,Minecraft.getMinecraft().thePlayer.posZ,"tile.piston.in",10000, 0.7f,false);
                }else{
                    Minecraft.getMinecraft().theWorld.playSound(Minecraft.getMinecraft().thePlayer.posX,Minecraft.getMinecraft().thePlayer.posY,Minecraft.getMinecraft().thePlayer.posZ,"tile.piston.out",10000, 0.8f,false);
                }
			}
		
		}else{
		}
	}

	
	public void drawButton(float x,float y, float x2, float y2){

		this.x = (int) x;
		this.y = (int) y;
		boolean isMouseOver = this.mouse(x2, y2, x-45.5f, x+44.5f, y-9, y+8);
		GL11.glTranslated(0.5, 0, 0);

		Gui.drawRect(x-60, y-9, x+60, y+this.height -8, 0xff202020);
        if(this.isOpen){
            Gui.drawRect(x-58, y-8, x+58, y+height-8,new Color(0x262626).getRGB());
        }
		Gui.drawRect(x-58, y-8, x+58, y+8,(!this.module.getState) ? ( isMouseOver ? 0xff272727:  0xff2f2f2f ) : Main.getMain.getClientColor().getRGB());
      //  GuiApi.drawGradientRect(x-58, y-8, x+58, y+8, -2130706433, 16777215);
        GuiApi.drawGradientRect(x-58, y-12, x+58, y+8, 0, Integer.MIN_VALUE);
		verdana.drawStringWithShadow(this.module.name, x-56, y-7.5f, 0xffffffff);
		GL11.glTranslated(-0.5, 0, 0);


        if(!this.isOpen){
            this.height = 18;
        }else{
            int height = 18;
            for(Mini v : this.valueButtons){
                height += v.getHeight();
                v.drawMini(x,y+height-17,x2,y2);
            }
            this.height = height;
        }
		
	}


}

minecraft_de_Client_Render_ClickGui_Panels_Mini.java

package de.Client.Render.ClickGui.Panels;


import de.Client.Main.Modules.Module;
import de.Client.Main.Values.Value;
import org.lwjgl.input.Keyboard;

import java.io.IOException;

public class Mini {
    public Mini(Module m){
        module = m;
    }

    public Module module;

    public float getHeight() {
        return height;
    }

    private float height = 16;
    public void mouseClick(float x,float y){

    }

    public void closeMini(){

    }

    public void drawMini(float x,float y,float mouseX,float mouseY){
        this.mouseX = mouseX;
        this.mouseY = mouseY;
        this.x = x;
        this.y = y;
    }
    public float mouseX;
    public float mouseY;
    public float x;
    public float y;
    public boolean isMouseOverModule(){
        boolean isOver = false;
        if(mouse(mouseX,mouseY,x-57.5f,x+57.5f,y - getHeight() / 2, y + getHeight() / 2 )) isOver = true;
        return isOver;
    }
    public boolean mouse(float mouseX, float mouseY, float minX, float maxX, float minY, float maxY) {
        return (mouseX >= minX && mouseX <= maxX) && (mouseY >= minY && mouseY <= maxY);
    }



    public void keyTyped(char typedChar, int keyCode) throws IOException
    {

    }
}

minecraft_de_Client_Render_ClickGui_Panels_Minitypes_MiniExtendedValueArray.java

package de.Client.Render.ClickGui.Panels.Minitypes;


import de.Client.Main.Main;
import de.Client.Main.Modules.Module;
import de.Client.Main.Values.Value;
import de.Client.Main.Values.ValueBoolean;
import de.Client.Render.ClickGui.Panels.Mini;
import de.Client.Render.GuiApi;
import de.Client.Render.TTFManager;
import de.Client.Utils.MiniValueBooleanArray;
import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.Gui;
import net.minecraft.nbt.NBTTagCompound;

import java.awt.*;
import java.io.IOException;
import java.util.ArrayList;

public class MiniExtendedValueArray extends Mini{

    public MiniExtendedValueArray(Module m,  ArrayList<MiniValueBooleanArray> aav) {
        super(m);
        valueArrayArray = aav;
    }

    public ValueBoolean value1;
    public ValueBoolean value2;
    public ValueBoolean value3;

    public ArrayList<MiniValueBooleanArray> valueArrayArray;

    public MiniValueBooleanArray arrayOver;


    public static TTFManager verdana =new TTFManager("Verdana",Font.PLAIN,22);

    public boolean setNewKeyBind;

    @Override
    public void keyTyped(char typedChar, int keyCode) throws IOException
    {
        super.keyTyped(typedChar,keyCode);
    }



    @Override
    public void mouseClick(float x,float y){
        super.mouseClick(x,y);
        if(arrayOver != null){
            arrayOver.isExtended = ! arrayOver.isExtended;
        }
    }

    public float height;

    @Override
    public void drawMini(float x,float y,float mouseX,float mouseY){
        
       // Gui.drawRect(x-57.5, y-height/2, x+57.5, y+height/2-1,!this.isMouseOverModule() ?  new Color(0x303030).getRGB() : new Color(0x242424).getRGB());
        height = -getHeight()/2;
        arrayOver = null;

        double y2 = y - getHeight()/2+7;
            for (MiniValueBooleanArray m : this.valueArrayArray) {
                GuiApi.drawBorderRectNoCorners(x - 57.5, y2 + height, x + 57.5, y2 + height + 15, new Color(0x1D1D1D).getRGB(), !mouse(mouseX,mouseY,x - 57.5f,x + 57.5f,(float) y2 + height,(float)y2 + height + 15) ? new Color(0x292929).getRGB() : new Color(0x222222).getRGB());
                Main.getMain.verdanas.drawCenteredStringWithShadow(m.name,(float)x ,(float) y2 + height-0.5f,0xffffffff);
                Main.getMain.cmdManager.sendChatMessage(m.name + " " + y2);

                if(mouse(mouseX,mouseY,x - 57.5f,x + 57.5f,(float) y2 + height,(float)y2 + height + 15)){
                    arrayOver = m;
                }
                height += 16;
                if (m.isExtended) {
                    for (ValueBoolean valueBoolean : m.valueBooleanArrayList) {
                        height += 20;
                        m.drawMini(x,y);
                    }
                }

            }
        super.drawMini(x, y, mouseX, mouseY);
    }

    @Override
    public float getHeight(){
        float height = 0;
        for (MiniValueBooleanArray m : this.valueArrayArray) {
            height += 16;
            if (m.isExtended) {
                for (ValueBoolean valueBoolean : m.valueBooleanArrayList) {
                    height += 20;
                }
            }
        }
        return height;
    }


}

minecraft_de_Client_Render_ClickGui_Panels_Minitypes_MiniKeyBind.java

package de.Client.Render.ClickGui.Panels.Minitypes;


import de.Client.Main.Main;
import de.Client.Main.Modules.Module;
import de.Client.Render.ClickGui.Panels.Mini;
import de.Client.Render.GuiApi;
import de.Client.Render.TTFManager;
import net.minecraft.client.gui.Gui;
import org.lwjgl.input.Keyboard;

import java.awt.*;
import java.io.IOException;

public class MiniKeyBind extends Mini{

    public MiniKeyBind(Module m) {
        super(m);
    }
    public static TTFManager verdana =new TTFManager("Verdana",Font.PLAIN,22);

    public boolean setNewKeyBind;

    @Override
    public void keyTyped(char typedChar, int keyCode) throws IOException
    {

        if(this.setNewKeyBind){
            if(keyCode == Keyboard.KEY_ESCAPE){
                this.setNewKeyBind = false;
                return;
            }
            module.keyBind = keyCode;
            this.setNewKeyBind = false;
        }
        super.keyTyped(typedChar,keyCode);
    }



    @Override
    public void mouseClick(float x,float y){
        if(this.isMouseOverModule()){
            this.setNewKeyBind =! setNewKeyBind;
        }
        super.mouseClick(x,y);
    }
    @Override
    public void drawMini(float x,float y,float mouseX,float mouseY){
        Gui.drawRect(x-57.5, y-this.getHeight()/2, x+57.5, y+this.getHeight()/2-1,!this.isMouseOverModule() ?  new Color(0x303030).getRGB() : new Color(0x242424).getRGB());
        GuiApi.drawGradientRect(x-58, y-12, x+58, y+8, 0,0x242424);

        if(!this.setNewKeyBind) {
            verdana.drawStringWithShadow("KeyBind " + Keyboard.getKeyName(module.keyBind), x-56 , y - 9, 0xffffffff);
        }else{
            verdana.drawCenteredStringWithShadow("Press new key" , x , y - 9, 0xffffffff);
        }
        super.drawMini(x, y, mouseX, mouseY);
    }
}

minecraft_de_Client_Render_ClickGui_Panels_Minitypes_MiniOneofThree.java

package de.Client.Render.ClickGui.Panels.Minitypes;


import de.Client.Main.Modules.Module;
import de.Client.Main.Values.Value;
import de.Client.Main.Values.ValueBoolean;
import de.Client.Render.ClickGui.Panels.Mini;
import de.Client.Render.GuiApi;
import de.Client.Render.TTFManager;
import net.minecraft.client.gui.Gui;

import java.awt.*;
import java.io.IOException;
import java.util.ArrayList;

public class MiniOneofThree extends Mini{

    public MiniOneofThree(Module m,ValueBoolean vb1, ValueBoolean vb2, ValueBoolean vb3) {
        super(m);
        value1 = vb1;
        value2 = vb2;
        value3 = vb3;
    }

    public ValueBoolean value1;
    public ValueBoolean value2;
    public ValueBoolean value3;


    public static TTFManager verdana =new TTFManager("Verdana",Font.PLAIN,22);

    public boolean setNewKeyBind;

    @Override
    public void keyTyped(char typedChar, int keyCode) throws IOException
    {
        super.keyTyped(typedChar,keyCode);
    }



    @Override
    public void mouseClick(float x,float y){
        super.mouseClick(x,y);
    }
    @Override
    public void drawMini(float x,float y,float mouseX,float mouseY){
        Gui.drawRect(x-57.5, y-this.getHeight()/2, x+57.5, y+this.getHeight()/2-1,!this.isMouseOverModule() ?  new Color(0x303030).getRGB() : new Color(0x242424).getRGB());
        GuiApi.drawGradientRect(x-58, y-12, x+58, y+8, 0,0x242424);

        super.drawMini(x, y, mouseX, mouseY);
    }
}

minecraft_de_Client_Render_ClickGui_Panels_Minitypes_MiniOneOfTwo.java

package de.Client.Render.ClickGui.Panels.Minitypes;


import de.Client.Main.Main;
import de.Client.Main.Modules.Module;
import de.Client.Main.Values.Value;
import de.Client.Main.Values.ValueBoolean;
import de.Client.Render.ClickGui.Panels.Mini;
import de.Client.Render.GuiApi;
import de.Client.Render.TTFManager;
import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.Gui;

import java.awt.*;
import java.io.IOException;
import java.util.ArrayList;

public class MiniOneOfTwo extends Mini{

    public MiniOneOfTwo(Module m,ValueBoolean vb1, ValueBoolean vb2) {
        super(m);
        value1 = vb1;
        value2 = vb2;
    }

    public ValueBoolean value1;
    public ValueBoolean value2;


    public static TTFManager verdana =new TTFManager("Verdana",Font.PLAIN,20);

    public boolean setNewKeyBind;

    @Override
    public void keyTyped(char typedChar, int keyCode) throws IOException
    {
        super.keyTyped(typedChar,keyCode);
    }



    @Override
    public void mouseClick(float x,float y){
        if(this.isMouseOverModule()){
            if(mouseX < this.x ){
                value1.setValue(true);
                value2.setValue(false);

            }

            if(mouseX > this.x ) {
                value2.setValue(true);
                value1.setValue(false);
            }

        }
        super.mouseClick(x,y);
    }
    @Override
    public void drawMini(float x,float y,float mouseX,float mouseY){
        Gui.drawRect(x-57.5, y-this.getHeight()/2, x+57.5, y+this.getHeight()/2-1,!this.isMouseOverModule() ?  new Color(0x303030).getRGB() : new Color(0x242424).getRGB());
        GuiApi.drawGradientRect(x-58, y-12, x+58, y+8, 0,0x242424);
        GuiApi.drawBorderRectNoCorners(x-56,y-this.getHeight()/2+1,x,y+this.getHeight()/2-2, new Color(0x3D3D3D).getRGB(),this.value1.getValue() ? Main.getMain.getClientColor().getRGB() : new Color(0x1E1E1E).getRGB());
        GuiApi.drawBorderRectNoCorners(x+56,y-this.getHeight()/2+1,x,y+this.getHeight()/2-2, new Color(0x3D3D3D).getRGB(),this.value2.getValue() ? Main.getMain.getClientColor().getRGB() : new Color(0x1E1E1E).getRGB());
        verdana.drawCenteredStringWithShadow(value1.getName(),x-28,y-7.3f,value1.getValue() ? 0xffffffff : new Color(0x858585).getRGB() );
        verdana.drawCenteredStringWithShadow(value2.getName(),x+28,y-7.3f,value2.getValue() ? 0xffffffff : new Color(0x858585).getRGB() );
        super.drawMini(x, y, mouseX, mouseY);
    }
}

minecraft_de_Client_Render_ClickGui_Panels_Minitypes_MiniValueBooleanToggleSimple.java

package de.Client.Render.ClickGui.Panels.Minitypes;


import de.Client.Main.Main;
import de.Client.Main.Modules.Module;
import de.Client.Main.Values.Value;
import de.Client.Main.Values.ValueBoolean;
import de.Client.Render.ClickGui.Panels.Mini;
import de.Client.Render.GuiApi;
import de.Client.Render.TTFManager;
import net.minecraft.client.gui.Gui;

import java.awt.*;
import java.io.IOException;
import java.util.ArrayList;

public class MiniValueBooleanToggleSimple extends Mini{

    public MiniValueBooleanToggleSimple(Module m, ValueBoolean values) {
        super(m);
        this.values = values;
    }

    public ValueBoolean values;

    public static TTFManager verdana =new TTFManager("Verdana",Font.PLAIN,22);




    @Override
    public void mouseClick(float x,float y){
        super.mouseClick(x,y);
        if(this.isMouseOverModule()){
            values.setValue(!values.getValue());
        }
    }
    @Override
    public void drawMini(float x,float y,float mouseX,float mouseY){
        Gui.drawRect(x-57.5, y-this.getHeight()/2, x+57.5, y+this.getHeight()/2,this.isMouseOverModule() ?  new Color(0xff272727).getRGB() : new Color(0xff2f2f2f).getRGB());

        System.out.println(this.isMouseOverModule() + "  "+ y +"  " +x);
        GuiApi.drawRect(x-(57.5 - 0.5f / 2),y-this.getHeight() / 2+0.5f,x-(57.5 - 0.5f / 2)+this.getHeight()-2*0.5f,y+this.getHeight() / 2-0.5f,!values.getValue() ?  new Color(0x565656).getRGB() :Main.getMain.getClientColor().getRGB());
        GuiApi.drawGradientRect(x-(57.5 - 0.5f / 2),y-this.getHeight() / 2+0.5f-4,x-(57.5 - 0.5f / 2)+this.getHeight()-2*0.5f,y+this.getHeight() / 2-0.5f, 0, Integer.MIN_VALUE);
        Main.getMain.verdanas.drawStringWithShadow(this.values.getName(), (float) (x-(57.5 - 0.5f / 2)+this.getHeight()-2*0.5f)+1, y-this.getHeight()/2,values.getValue() ? 0xffffffff : new Color(0x807E7F).getRGB());
        super.drawMini(x, y, mouseX, mouseY);
    }
}

minecraft_de_Client_Render_ClickGui_Panels_Minitypes_MiniValueSwitcher.java

package de.Client.Render.ClickGui.Panels.Minitypes;


import de.Client.Main.Modules.Module;
import de.Client.Main.Values.Value;
import de.Client.Main.Values.ValueBoolean;
import de.Client.Render.ClickGui.Panels.Mini;
import de.Client.Render.GuiApi;
import de.Client.Render.TTFManager;
import net.minecraft.client.gui.Gui;

import java.awt.*;
import java.io.IOException;
import java.util.ArrayList;

public class MiniValueSwitcher extends Mini{

    public MiniValueSwitcher(Module m, ArrayList<ValueBoolean> values) {
        super(m);
        this.values = values;
    }

    public ArrayList<ValueBoolean> values= new ArrayList();

    public static TTFManager verdana =new TTFManager("Verdana",Font.PLAIN,22);

    public boolean setNewKeyBind;

    @Override
    public void keyTyped(char typedChar, int keyCode) throws IOException
    {
        super.keyTyped(typedChar,keyCode);
    }



    @Override
    public void mouseClick(float x,float y){
        super.mouseClick(x,y);
    }
    @Override
    public void drawMini(float x,float y,float mouseX,float mouseY){
        Gui.drawRect(x-57.5, y-this.getHeight()/2, x+57.5, y+this.getHeight()/2-1,!this.isMouseOverModule() ?  new Color(0x303030).getRGB() : new Color(0x242424).getRGB());
        GuiApi.drawGradientRect(x-58, y-12, x+58, y+8, 0,0x242424);
        super.drawMini(x, y, mouseX, mouseY);
    }
}

minecraft_de_Client_Render_ClickGui_Panels_Panel.java

package de.Client.Render.ClickGui.Panels;

import de.Client.Main.Main;
import de.Client.Main.Modules.Category;
import de.Client.Main.Modules.Module;
import de.Client.Render.ClickGui.ClickGui;
import de.Client.Render.GuiApi;
import de.Client.Utils.RenderAPI2d;
import de.Client.Utils.TimeHelper;
import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.Gui;
import net.minecraft.client.gui.GuiScreen;
import net.minecraft.client.gui.ScaledResolution;
import net.minecraft.client.renderer.GlStateManager;
import net.minecraft.client.renderer.entity.Render;
import net.minecraft.util.ResourceLocation;
import org.lwjgl.input.Mouse;
import org.lwjgl.opengl.GL11;

import java.awt.*;
import java.io.IOException;
import java.sql.Time;
import java.util.ArrayList;

public class Panel {
	
	public Category category;
	
	public float x;
	
	public float y;
	
	public ResourceLocation locationToRender;
	
	public ArrayList<Button> buttons = new ArrayList();
	public Minecraft mc = Minecraft.getMinecraft();
	
	public float lastmouseX;
	public float lastmouseY;
	public ClickGui clickgui;
	public boolean isDragging;
	
	public boolean isOpen;

	
	public Panel(Category category,int startX,int startY,ResourceLocation l,ClickGui gui){
		this.category = category;
		this.x = startX;
		this.y = startY;
		this.locationToRender =l;
		this.clickgui = gui;
		
		
	}
    public void keyTyped(char typedChar, int keyCode) throws IOException
    {
        for(Button btn : this.buttons){
            if(this.isOpen) {
                btn.keyTyped(typedChar, keyCode);
            }
        }
    }
	public boolean mouse(int mouseX, int mouseY, float minX, float maxX, float minY, float maxY) {
        return (mouseX >= minX && mouseX <= maxX) && (mouseY >= minY && mouseY <= maxY);
    }
	
	public void init() {
        if (buttons.isEmpty()) {
            for (Module mod : Main.getMain.moduleManager.getModulesForCategory(this.category)) {
                this.buttons.add(new Button(mod, this));
            }
        }
        this.openPanelHeight = buttons.size() * 18;
	}
	 public void setColor(int colorHex,float  alpha)
	  {
	 
	    float red = (colorHex >> 16 & 0xFF) / 255.0F;
	    float green = (colorHex >> 8 & 0xFF) / 255.0F;
	    float blue = (colorHex & 0xFF) / 255.0F;
	    GL11.glColor4f(red, green, blue, alpha == 0.0F ? 1.0F : alpha);
	  }
	public void mouseClick(int mouseX,int mouseY,int mouseType) {
        if (this.mouse(mouseX, mouseY, x - 60, x + 60, y - 9, (float) (y + 9 + this.openPanelHeight))) {
            if (!this.front) {
                this.clickgui.setPanelToFont(this, this.isOpen).mouseClick(mouseX, mouseY, mouseType);
            }
        }
        if(this.front) {
            if (this.mouse(mouseX, mouseY, x - 60, x + 60, y - 9, y + 9)) {


                isDragging = true;
                for (Panel p : this.clickgui.panels) {
                    if (p != this) {
                        p.isDragging = false;
                    }
                }
                if (mouseType == 1) {
                    isOpen = !isOpen;
                    mc.theWorld.playSound(mc.thePlayer.posX,mc.thePlayer.posY,mc.thePlayer.posZ,"random.pop",10000,isOpen ? 1 : -1,false);
                }

            }
            if (this.isOpen) {
                for (Button btn : this.buttons) {
                    btn.mouseClick(mouseX, mouseY, mouseType);
                }
            }
        }
    }

	
	public void mouseReleased(int mouseX,int mouseY,int mouseType){
		isDragging = false;

	}
    public static void startScissors(int x, int y, int width, int height) {
        GL11.glPushMatrix();
        GL11.glEnable(GL11.GL_SCISSOR_TEST);
        ScaledResolution sr1 = new ScaledResolution();
        int factor = sr1.getScaleFactor();
        GL11.glScissor(x * factor, (sr1.getScaledHeight() - height) * factor, Math.abs((width - x) * factor), Math.abs((height - y) * factor));
    }

    public static void stopScissor() {
        GL11.glDisable(GL11.GL_SCISSOR_TEST);
        GL11.glPopMatrix();
    }
	public double anInt;
	public double openPanelHeight;
    public float getDiffrent(double f1, double f2){
        return (float)  Math.sqrt((f1-f2)*(f1-f2));
    }
	public void updateAnimation(){
 //       System.out.println("test");
        double height = 0;

        for (Button b : this.buttons) {
            height += 18;
            if(b.isOpen && !this.isOpen){
                for(Mini m : b.valueButtons){
                    height += m.getHeight();
                }
            }
        }
        if(this.isOpen){



                openPanelHeight = height + 10;

            if(-this.openPanelHeight -11+anInt <= 0) {
                anInt += this.getDiffrent(-this.openPanelHeight -11+anInt,1)/10;


            }
        }else{
            anInt = -10;
        }
    }
    public TimeHelper t = new TimeHelper();
	public int frames;
	public boolean scissorfix;
	public boolean front;
	public void drawPanel() {
        // System.out.println(this.front);
        ScaledResolution sr = new ScaledResolution();
        double x1 = Mouse.getEventX() * clickgui.width / this.mc.displayWidth;
        double y1 = clickgui.height - Mouse.getEventY() * clickgui.height / this.mc.displayHeight;
        if (isDragging) {

            if (Mouse.isButtonDown(0)) {
                this.x += (x1 * 200 - this.lastmouseX) / 200.00f;
                this.y += (y1 * 200 - this.lastmouseY) / 200.00f;
            }
        }
        this.lastmouseX = (float) (x1 * 200);
        this.lastmouseY = (float) (y1 * 200);


        if (this.isOpen) {
            int y2 = 0;

            if (-this.openPanelHeight - 11 + anInt < 0) {
                startScissors(0, (int) y - 5, (int) ((int) sr.getScaledWidth()), (int) ((int) y + this.openPanelHeight));
                scissorfix = true;
                GL11.glTranslated(0, -this.openPanelHeight - 11 + anInt, 0);
                // System.out.println(-this.openPanelHeight -11+anInt );
            }
            for (Button btn : this.buttons) {
                btn.drawButton(x, y + 18 + y2, (float) x1, (float) y1);
                y2 += btn.height;
            }
            if (-this.openPanelHeight - 11 + anInt < 0) {
                GL11.glTranslated(0, -(-this.openPanelHeight - 11 + anInt), 1);

            }
            if (scissorfix) {
                stopScissor();
                scissorfix = false;
            }


        } else {
            anInt = 0;
        }
        GuiApi.drawFineBorderedRect(x - 60, y + 9, x + 60, (int) (y - 10), new Color(0xff202020).darker().getRGB(), 0xff202020);
        String s = String.valueOf(String.valueOf(category.toString().substring(0, 1)))
                + category.toString().substring(1, category.toString().length()).toLowerCase();
        Main.getMain.verdana.drawCenteredStringWithShadow(this.isOpen ? "V" : "...", x - 54, y - 9, Main.getMain.getClientColor().getRGB());
        Main.getMain.verdana.drawCenteredStringWithShadow(s, x, y - 9, Color.white.getRGB());
        GlStateManager.color(1, 1, 1);
        mc.getTextureManager().bindTexture(this.locationToRender);

        setColor(Main.getMain.getClientColor().getRGB(), 1);
     //   if (this.category == Category.PLAYER) {
     //       GL11.glScaled(0.03125d,0.03125d,0.03125d);
     //       RenderAPI2d.drawTexture(RenderAPI2d.getTextureForCategory.get(this.category), (x + 60 - 18)/32F, (y - 9)/32F,512, 512);
     //       GL11.glScaled(32,32,32);
     //   }

        Gui.drawModalRectWithCustomSizedTexture(x+60-18,y-9,1800,1800,18,18,18,18);
	}
	
}

minecraft_de_Client_Render_GuiAnimation.java

package de.Client.Render;

import net.minecraft.client.gui.GuiScreen;

import java.awt.image.BufferedImage;
import java.awt.image.Raster;

public class GuiAnimation extends GuiScreen{
	
	public GuiScreen screen;
	public BufferedImage imageToRender; 
	public GuiAnimation(BufferedImage image, GuiScreen guiScreenToGo){
		imageToRender = image;
		screen = guiScreenToGo;
	}
	
	@Override
	public void initGui(){
		for(int x = 0;x < this.imageToRender.getWidth();++x){
			for(int y = 0; y < this.imageToRender.getHeight();++y){
				Raster r = this.imageToRender.getTile(x, y);
				
			}
		}
	}
	
	@Override
	public void drawScreen(int mouseX, int mouseY, float partialTicks)
    {
		
    }

}

minecraft_de_Client_Render_GuiApi.java

package de.Client.Render;

import de.Client.Main.Main;
import de.Client.Utils.ColorUtil;
import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.FontRenderer;
import net.minecraft.client.gui.Gui;
import net.minecraft.client.renderer.GlStateManager;
import net.minecraft.client.renderer.Tessellator;
import net.minecraft.client.renderer.WorldRenderer;
import org.lwjgl.opengl.GL11;

public class GuiApi {
	
    private static FontRenderer fr = Minecraft.getMinecraft().fontRendererObj;

    public static void drawCentredStringWithShadow(String s, int x, int y, int colour) {
        fr.drawString(s, x -= fr.getStringWidth(s) / 2, y, colour);
    }
    public static void drawScaledRect(double x, double y, double x2, double y2, int color,double scale) {
        x *= scale;
        y *= scale;
        x2 *= scale;
        y2 *= scale;
        Gui.drawRect(x, y, x2, y2, color);

    }
    public static void drawRect(double x, double y, double x2, double y2, int color) {
        Gui.drawRect(x, y, x2, y2, color);
       
    }  
    public static void drawRectColor(double d, double e, double f2, double f3, float alpha, float red, float green, float blue)
    {
    	GlStateManager.enableBlend();
    	GlStateManager.func_179090_x();
        GlStateManager.tryBlendFuncSeparate(770, 771, 1, 0);
        GL11.glPushMatrix();
        GL11.glColor4f(red, green, blue, alpha);
        GL11.glBegin(7);
        GL11.glVertex2d(f2, e);
        GL11.glVertex2d(d, e);
        GL11.glVertex2d(d, f3);
        GL11.glVertex2d(f2, f3);
        GL11.glEnd();
        GlStateManager.func_179098_w();
        GlStateManager.disableBlend();
        GL11.glPopMatrix();
      }
    public static void drawOutlineRect(float drawX, float drawY, float drawWidth, float drawHeight, int color) {
        drawRect(drawX, drawY, drawWidth, drawY + 0.5F, color);
        drawRect(drawX, drawY + 0.5F, drawX + 0.5F, drawHeight, color);
        drawRect(drawWidth - 0.5F, drawY + 0.5F, drawWidth, drawHeight - 0.5F, color);
        drawRect(drawX + 0.5F, drawHeight - 0.5F, drawWidth, drawHeight, color);
    }

    public static void drawOutlinedRect(float drawX, float drawY, float drawWidth, float drawHeight, float alpha, float red, float green, float blue)
    {
        drawRectColor(drawX, drawY, drawWidth, drawY + 0.5F, alpha, red, green, blue);
        drawRectColor(drawX, drawY + 0.5F, drawX + 0.5F, drawHeight, alpha, red, green, blue);
        drawRectColor(drawWidth - 0.5F, drawY + 0.5F, drawWidth, drawHeight - 0.5F, alpha, red, green, blue);
        drawRectColor(drawX + 0.5F, drawHeight - 0.5F, drawWidth, drawHeight, alpha, red, green, blue);
    }

    public static void drawRGBRect(float paramXStart, float paramYStart, float paramXEnd, float paramYEnd, int r , int g , int b) {
        GL11.glEnable((int)3042);
        GL11.glDisable((int)3553);
        GL11.glBlendFunc((int)770, (int)771);
        GL11.glEnable((int)2848);
        GL11.glPushMatrix();
        GL11.glColor3f((float) (float) r, (float) (float) g, (float) (float) b);
        GL11.glBegin((int)7);
        GL11.glVertex2d((double)paramXEnd, (double)paramYStart);
        GL11.glVertex2d((double)paramXStart, (double)paramYStart);
        GL11.glVertex2d((double)paramXStart, (double)paramYEnd);
        GL11.glVertex2d((double)paramXEnd, (double)paramYEnd);
        GL11.glEnd();
        GL11.glPopMatrix();
        GL11.glEnable((int)3553);
        GL11.glDisable((int)3042);
        GL11.glDisable((int)2848);
    }
    public static void drawRect(float paramXStart, float paramYStart, float paramXEnd, float paramYEnd, int paramColor) {
        float alpha = (float)(paramColor >> 24 & 255) / 255.0f;
        float red = (float)(paramColor >> 16 & 255) / 255.0f;
        float green = (float)(paramColor >> 8 & 255) / 255.0f;
        float blue = (float)(paramColor & 255) / 255.0f;
        GL11.glEnable((int)3042);
        GL11.glDisable((int)3553);
        GL11.glBlendFunc((int)770, (int)771);
        GL11.glEnable((int)2848);
        GL11.glPushMatrix();
        GL11.glColor4f((float)red, (float)green, (float)blue, (float)alpha);
        GL11.glBegin((int)7);
        GL11.glVertex2d((double)paramXEnd, (double)paramYStart);
        GL11.glVertex2d((double)paramXStart, (double)paramYStart);
        GL11.glVertex2d((double)paramXStart, (double)paramYEnd);
        GL11.glVertex2d((double)paramXEnd, (double)paramYEnd);
        GL11.glEnd();
        GL11.glPopMatrix();
        GL11.glEnable((int)3553);
        GL11.glDisable((int)3042);
        GL11.glDisable((int)2848);
    }

    public static void drawPoint(int x, int y, int color) {
        GuiApi.drawRect(x, y, x + 1, y + 1, color);
    }

    public static void drawVerticalLine(double x, double y, double height, int color) {
        GuiApi.drawRect(x, y, x + 1, height, color);
    }

    public static void drawHorizontalLine(double x, double y, double width, int color) {
        GuiApi.drawRect(x, y, width, y + 1, color);
    }

    public static void drawBorderedRect(double f, double y, double g, double d, int bord, int color) {
        GuiApi.drawRect(f + 1, y + 1, g, d, color);
        GuiApi.drawVerticalLine(f, y, d, bord);
        GuiApi.drawVerticalLine(g, y, d, bord);
        GuiApi.drawHorizontalLine(f + 1, y, g, bord);
        GuiApi.drawHorizontalLine(f, d, g + 1, bord);
    }

    public static void drawFineBorderedRect(double x, double y, double x1, double y1, int bord, int color) {
        GL11.glScaled((double)0.5, (double)0.5, (double)0.5);
        GuiApi.drawRect((x *= 2) + 1, (y *= 2) + 1, x1 *= 2, y1 *= 2, color);
        GuiApi.drawVerticalLine(x, y, y1, bord);
        GuiApi.drawVerticalLine(x1, y, y1, bord);
        GuiApi.drawHorizontalLine(x + 1, y, x1, bord);
        GuiApi.drawHorizontalLine(x, y1, x1 + 1, bord);
        GL11.glScaled((double)2.0, (double)2.0, (double)2.0);
    }


    public static void drawBorderRectNoCorners(double d, double e, double x2, double y2, int bord, int color) {
        GL11.glScaled((double)0.5, (double)0.5, (double)0.5);
        GuiApi.drawRect((d *= 2) + 1, (e *= 2) + 1, x2 *= 2, y2 *= 2, color);
        GuiApi.drawVerticalLine(d, e + 1, y2, bord);
        GuiApi.drawVerticalLine(x2, e + 1, y2, bord);
        GuiApi.drawHorizontalLine(d + 1, e, x2, bord);
        GuiApi.drawHorizontalLine(d + 1, y2, x2, bord);
        GL11.glScaled((double)2.0, (double)2.0, (double)2.0);
    }

    public static void drawBorderedGradient(int x, int y, int x1, int y1, int bord, int gradTop, int gradBot) {
        GL11.glScaled((double)0.5, (double)0.5, (double)0.5);
        float f = (float)(gradTop >> 24 & 255) / 255.0f;
        float f1 = (float)(gradTop >> 16 & 255) / 255.0f;
        float f2 = (float)(gradTop >> 8 & 255) / 255.0f;
        float f3 = (float)(gradTop & 255) / 255.0f;
        float f4 = (float)(gradBot >> 24 & 255) / 255.0f;
        float f5 = (float)(gradBot >> 16 & 255) / 255.0f;
        float f6 = (float)(gradBot >> 8 & 255) / 255.0f;
        float f7 = (float)(gradBot & 255) / 255.0f;
        GL11.glEnable((int)3042);
        GL11.glDisable((int)3553);
        GL11.glBlendFunc((int)770, (int)771);
        GL11.glEnable((int)2848);
        GL11.glShadeModel((int)7425);
        GL11.glPushMatrix();
        GL11.glBegin((int)7);
        GL11.glColor4f((float)f1, (float)f2, (float)f3, (float)f);
        GL11.glVertex2d((double)(x1 *= 2), (double)((y *= 2) + 1));
        GL11.glVertex2d((double)((x *= 2) + 1), (double)(y + 1));
        GL11.glColor4f((float)f5, (float)f6, (float)f7, (float)f4);
        GL11.glVertex2d((double)(x + 1), (double)(y1 *= 2));
        GL11.glVertex2d((double)x1, (double)y1);
        GL11.glEnd();
        GL11.glPopMatrix();
        GL11.glEnable((int)3553);
        GL11.glDisable((int)3042);
        GL11.glDisable((int)2848);
        GL11.glShadeModel((int)7424);
        GuiApi.drawVLine(x, y, y1 - 1, bord);
        GuiApi.drawVLine(x1 - 1, y, y1 - 1, bord);
        GuiApi.drawHLine(x, x1 - 1, y, bord);
        GuiApi.drawHLine(x, x1 - 1, y1 - 1, bord);
        GL11.glScaled((double)2.0, (double)2.0, (double)2.0);
    }

    public static void drawHLine(float par1, float par2, float par3, int par4) {
        if (par2 < par1) {
            float var5 = par1;
            par1 = par2;
            par2 = var5;
        }
        GuiApi.drawRect(par1, par3, par2 + 1.0f, par3 + 1.0f, par4);
    }


    private static void enableDefaults() {
        GL11.glPushMatrix();
        GL11.glEnable(GL11.GL_BLEND);
        GL11.glEnable(GL11.GL_LINE_SMOOTH);
        GL11.glDisable(GL11.GL_DEPTH_TEST);
        GL11.glDisable(GL11.GL_TEXTURE_2D);
        GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
    }

    private static void setColor(int color) {
        GL11.glColor4f((color >> 16 & 0xFF) / 255.0F, (color >> 8 & 0xFF) / 255.0F, (color & 0xFF) / 255.0F, (color >> 24 & 0xFF) / 255.0F);
    }

    private static void disableDefaults() {
        GL11.glDisable(GL11.GL_BLEND);
        GL11.glDisable(GL11.GL_LINE_SMOOTH);
        GL11.glEnable(GL11.GL_DEPTH_TEST);
        GL11.glEnable(GL11.GL_TEXTURE_2D);
        GL11.glEnable(GL11.GL_BLEND);
        GL11.glPopMatrix();
    }

    public static void drawCircle(float x, float y, float radius, int color) {
        GL11.glPushMatrix();

        enableDefaults();
        setColor(color);
        GL11.glBegin(GL11.GL_POLYGON);
        double i = 0;
        while(i <= 360.0D) {
            GL11.glVertex2d(x + Math.sin(i * Math.PI / 180.0F) * radius, y + Math.cos(i * Math.PI / 180.0F) * radius);
            i += 1.0D;
        }
        GL11.glEnd();
        disableDefaults();
        GL11.glPopMatrix();
    }
    public static void preRender(float[] rgba) {
        GlStateManager.alphaFunc(516, 0.001F);
        GlStateManager.color(rgba[0], rgba[1], rgba[2], rgba[3]);
        GlStateManager.enableAlpha();
        GlStateManager.enableBlend();
        GlStateManager.func_179090_x();
        GlStateManager.tryBlendFuncSeparate(770, 771, 1, 0);
    }

    public static void postRender() {
        GlStateManager.alphaFunc(516, 0.1F);
        GlStateManager.color(1f, 1f, 1f, 1f);
        GlStateManager.disableBlend();
        GlStateManager.func_179098_w();
        GL11.glLineWidth(1);
    }
    public static void drawDonut(float x, float y, float radius,float thickness, int color) {

        float[] rgba = ColorUtil.getRGBA(color);
        preRender(rgba);

        Tessellator tess = Tessellator.getInstance();
        WorldRenderer render = tess.getWorldRenderer();

        for(double i = 0; i < 360; i++) {
            double cs = i*Math.PI/180D;
            double ps = (i-1)*Math.PI/180D;
            double[] outer = new double[] { Math.cos(cs) * radius, -Math.sin(cs) * radius, Math.cos(ps) * radius, -Math.sin(ps) * radius };
            double[] inner = new double[] { Math.cos(cs) * thickness, -Math.sin(cs) * thickness, Math.cos(ps) * thickness, -Math.sin(ps) * thickness };

            render.startDrawing(7);
            render.addVertex(x + inner[0], y + inner[1], 0);
            render.addVertex(x + inner[2], y + inner[3], 0);
            render.addVertex(x + outer[2], y + outer[3], 0);
            render.addVertex(x + outer[0], y + outer[1], 0);
            tess.draw();
        }

        postRender();

    }
    public static void drawDonutPart(float x, float y, float radius,float thickness, int color,float offset, int width) {

        float[] rgba = ColorUtil.getRGBA(color);
        preRender(rgba);

        Tessellator tess = Tessellator.getInstance();
        WorldRenderer render = tess.getWorldRenderer();

        for(double i = offset; i < width+offset; i+=1) {
            double cs = i*Math.PI/180D;
            double ps = (i-1)*Math.PI/180D;
            double[] outer = new double[] { Math.cos(cs) * radius, -Math.sin(cs) * radius, Math.cos(ps) * radius, -Math.sin(ps) * radius };
            double[] inner = new double[] { Math.cos(cs) * thickness, -Math.sin(cs) * thickness, Math.cos(ps) * thickness, -Math.sin(ps) * thickness };

            render.startDrawing(7);
            render.addVertex(x + inner[0], y + inner[1], 0);
            render.addVertex(x + inner[2], y + inner[3], 0);
            render.addVertex(x + outer[2], y + outer[3], 0);
            render.addVertex(x + outer[0], y + outer[1], 0);
            tess.draw();
        }

        postRender();

    }


    public static void drawVLine(float par1, float par2, float par3, int par4) {
        if (par3 < par2) {
            float var5 = par2;
            par2 = par3;
            par3 = var5;
        }
        GuiApi.drawRect(par1, par2 + 1.0f, par1 + 1.0f, par3, par4);
    }

    public static void drawGradientBorderedRect(double x, double y, double x2, double y2, float l1, int col1, int col2, int col3) {
        float f = (float)(col1 >> 24 & 255) / 255.0f;
        float f1 = (float)(col1 >> 16 & 255) / 255.0f;
        float f2 = (float)(col1 >> 8 & 255) / 255.0f;
        float f3 = (float)(col1 & 255) / 255.0f;
        GL11.glDisable((int)3553);
        GL11.glBlendFunc((int)770, (int)771);
        GL11.glEnable((int)2848);
        GL11.glDisable((int)3042);
        GL11.glPushMatrix();
        GL11.glColor4f((float)f1, (float)f2, (float)f3, (float)f);
        GL11.glLineWidth((float)1.0f);
        GL11.glBegin((int)1);
        GL11.glVertex2d((double)x, (double)y);
        GL11.glVertex2d((double)x, (double)y2);
        GL11.glVertex2d((double)x2, (double)y2);
        GL11.glVertex2d((double)x2, (double)y);
        GL11.glVertex2d((double)x, (double)y);
        GL11.glVertex2d((double)x2, (double)y);
        GL11.glVertex2d((double)x, (double)y2);
        GL11.glVertex2d((double)x2, (double)y2);
        GL11.glEnd();
        GL11.glPopMatrix();
        GuiApi.drawGradientRect(x, y, x2, y2, col2, col3);
        GL11.glEnable((int)3042);
        GL11.glEnable((int)3553);
        GL11.glDisable((int)2848);
    }

    public static void drawGradientRect(double x, double y, double x2, double y2, int col1, int col2) {
        float f =  (float)(col1 >> 24 & 255) / 255.0f;
        float f1 = (float)(col1 >> 16 & 255) / 255.0f;
        float f2 = (float)(col1 >> 8 & 255) / 255.0f;
        float f3 = (float)(col1 & 255) / 255.0f;
        float f4 = (float)(col2 >> 24 & 255) / 255.0f;
        float f5 = (float)(col2 >> 16 & 255) / 255.0f;
        float f6 = (float)(col2 >> 8 & 255) / 255.0f;
        float f7 = (float)(col2 & 255) / 255.0f;
        GL11.glEnable((int)3042);
        GL11.glDisable((int)3553);
        GL11.glBlendFunc((int)770, (int)771);
        GL11.glEnable((int)2848);
        GL11.glShadeModel((int)7425);
        GL11.glPushMatrix();
        GL11.glBegin((int)7);
        GL11.glColor4f((float)f1, (float)f2, (float)f3, (float)f);
        GL11.glVertex2d((double)x2, (double)y);
        GL11.glVertex2d((double)x, (double)y);
        GL11.glColor4f((float)f5, (float)f6, (float)f7, (float)f4);
        GL11.glVertex2d((double)x, (double)y2);
        GL11.glVertex2d((double)x2, (double)y2);
        GL11.glEnd();
        GL11.glPopMatrix();
        GL11.glEnable((int)3553);
        GL11.glDisable((int)3042);
        GL11.glDisable((int)2848);
        GL11.glShadeModel((int)7424);
    }

    public static void drawSidewaysGradientRect(double x, double y, double x2, double y2, int col1, int col2) {
        float f = (float)(col1 >> 24 & 255) / 255.0f;
        float f1 = (float)(col1 >> 16 & 255) / 255.0f;
        float f2 = (float)(col1 >> 8 & 255) / 255.0f;
        float f3 = (float)(col1 & 255) / 255.0f;
        float f4 = (float)(col2 >> 24 & 255) / 255.0f;
        float f5 = (float)(col2 >> 16 & 255) / 255.0f;
        float f6 = (float)(col2 >> 8 & 255) / 255.0f;
        float f7 = (float)(col2 & 255) / 255.0f;
        GL11.glEnable((int)3042);
        GL11.glDisable((int)3553);
        GL11.glBlendFunc((int)770, (int)771);
        GL11.glEnable((int)2848);
        GL11.glShadeModel((int)7425);
        GL11.glPushMatrix();
        GL11.glBegin((int)7);
        GL11.glColor4f((float)f1, (float)f2, (float)f3, (float)f);
        GL11.glVertex2d((double)x, (double)y);
        GL11.glVertex2d((double)x, (double)y2);
        GL11.glColor4f((float)f5, (float)f6, (float)f7, (float)f4);
        GL11.glVertex2d((double)x2, (double)y2);
        GL11.glVertex2d((double)x2, (double)y);
        GL11.glEnd();
        GL11.glPopMatrix();
        GL11.glEnable((int)3553);
        GL11.glDisable((int)3042);
        GL11.glDisable((int)2848);
        GL11.glShadeModel((int)7424);
    }

    public static void drawBorderedCircle(double x, double y, float radius, int outsideC, int insideC) {
        GL11.glEnable((int)3042);
        GL11.glDisable((int)3553);
        GL11.glBlendFunc((int)770, (int)771);
        GL11.glEnable((int)2848);
        GL11.glPushMatrix();
        float scale = 0.1f;
        GL11.glScalef((float)scale, (float)scale, (float)scale);
        x = ((float)x * (1.0f / scale));
        y = ((float)y * (1.0f / scale));
        GuiApi.drawCircle(x, y, radius *= 1.0f / scale, insideC);
        GuiApi.drawUnfilledCircle(x, y, radius, 1.0f, outsideC);
        GL11.glScalef((float)(1.0f / scale), (float)(1.0f / scale), (float)(1.0f / scale));
        GL11.glPopMatrix();
        GL11.glEnable((int)3553);
        GL11.glDisable((int)3042);
        GL11.glDisable((int)2848);
    }

    public static void drawrainbowcircle(double x, double y, float radius, int insideC){
        GL11.glEnable((int)3042);
        GL11.glDisable((int)3553);
        GL11.glBlendFunc((int)770, (int)771);
        GL11.glEnable((int)2848);
        GL11.glPushMatrix();
        float scale = 0.1f;
        GL11.glScalef((float)scale, (float)scale, (float)scale);
        x = (int)((float)x * (1.0f / scale));
        y = (int)((float)y * (1.0f / scale));
        GuiApi.drawCircle(x, y, radius *= 1.0f / scale, insideC);
        GuiApi.drawUnfilledCircler(x, y, radius, 5.0f);
        GL11.glScalef((float)(1.0f / scale), (float)(1.0f / scale), (float)(1.0f / scale));
        GL11.glPopMatrix();
        GL11.glEnable((int)3553);
        GL11.glDisable((int)3042);
        GL11.glDisable((int)2848);
    }

    public static void drawUnfilledCircler(double x, double y, float radius, float lineWidth) {

        GL11.glLineWidth((float)lineWidth);
        GL11.glEnable((int)2848);
        GL11.glBegin((int)2);
        int i = 0;
        while (i <= 360) {
            int color = Main.getMain.getPurple((int) (i*800/360.0d),4500000).getRGB();

            float red = (float)(color >> 16 & 255) / 255.0f;
            float alpha = (float)(color >> 24 & 255) / 255.0f;
            float green = (float)(color >> 8 & 255) / 255.0f;
            float blue = (float)(color & 255) / 255.0f;
            GL11.glColor4f((float)red, (float)green, (float)blue, (float)alpha);
            GL11.glVertex2d((double)((double)x + Math.sin((double)i * 3.141526 / 180.0) * (double)radius), (double)((double)y + Math.cos((double)i * 3.141526 / 180.0) * (double)radius));
            ++i;
        }
        GL11.glEnd();
        GL11.glDisable((int)2848);
    }

    public static void drawUnfilledCircle(double x, double y, float radius, float lineWidth, int color) {
        float alpha = (float)(color >> 24 & 255) / 255.0f;
        float red = (float)(color >> 16 & 255) / 255.0f;
        float green = (float)(color >> 8 & 255) / 255.0f;
        float blue = (float)(color & 255) / 255.0f;
        GL11.glColor4f((float)red, (float)green, (float)blue, (float)alpha);
        GL11.glLineWidth((float)lineWidth);
        GL11.glEnable((int)2848);
        GL11.glBegin((int)2);
        int i = 0;
        while (i <= 360) {
            GL11.glVertex2d((double)((double)x + Math.sin((double)i * 3.141526 / 180.0) * (double)radius), (double)((double)y + Math.cos((double)i * 3.141526 / 180.0) * (double)radius));
            ++i;
        }
        GL11.glEnd();
        GL11.glDisable((int)2848);
    }

    public static void drawCircle(double x, double y, float radius, int color) {
        float alpha = (float)(color >> 24 & 255) / 255.0f;
        float red = (float)(color >> 16 & 255) / 255.0f;
        float green = (float)(color >> 8 & 255) / 255.0f;
        float blue = (float)(color & 255) / 255.0f;
        GL11.glColor4f((float)red, (float)green, (float)blue, (float)alpha);
        GL11.glBegin((int)9);
        int i = 0;
        while (i <= 360) {
            GL11.glVertex2d((double)((double)x + Math.sin((double)i * 3.141526 / 180.0) * (double)radius), (double)((double)y + Math.cos((double)i * 3.141526 / 180.0) * (double)radius));
            ++i;
        }
        GL11.glEnd();
    }

    public static double getAlphaFromHex(int color) {
        return (float)(color >> 24 & 255) / 255.0f;
    }

    public static double getRedFromHex(int color) {
        return (float)(color >> 16 & 255) / 255.0f;
    }

    public static double getGreenFromHex(int color) {
        return (float)(color >> 8 & 255) / 255.0f;
    }

    public static double getBlueFromHex(int color) {
        return (float)(color & 255) / 255.0f;
    }
}

minecraft_de_Client_Render_GuiIngameHook.java

package de.Client.Render;

import de.Client.Events.EventTarget;
import de.Client.Events.Events.UpdateEvent;
import de.Client.Events.IEvent.State;
import de.Client.Main.Main;
import de.Client.Main.Modules.Category;
import de.Client.Main.Modules.Module;
import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.GuiChat;
import net.minecraft.client.gui.GuiIngame;
import net.minecraft.client.gui.ScaledResolution;
import net.minecraft.client.renderer.GlStateManager;
import org.lwjgl.opengl.GL11;

import java.awt.*;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;

public class GuiIngameHook extends GuiIngame {

	private int animations;

	public GuiIngameHook(Minecraft mcIn) {
		super(mcIn);
		// TODO Auto-generated constructor stub
	}
	


	@Override
	public void func_175180_a(float p_175180_1_) {

		try{
		super.func_175180_a(p_175180_1_);
		if(mc.gameSettings.showDebugInfo){
			return;
		}

            GL11.glPushMatrix();
            ScaledResolution sr = new ScaledResolution(this.mc, this.mc.displayWidth, this.mc.displayHeight);
            int x = (int) (mc.thePlayer.posX * 2);
            int y = (int) (mc.thePlayer.posY * 2);
            int z = (int) (mc.thePlayer.posZ * 2);

            Minecraft.getMinecraft().fontRendererObj.drawStringWithShadow("X " + (x > 0 ? "+" : "") + (float) x/2,1,sr.getScaledHeight()-30,0xffffffff);
            Minecraft.getMinecraft().fontRendererObj.drawStringWithShadow("Y " + (y> 0 ? "+" : "")+ (float) y/2,1,sr.getScaledHeight()-20,0xffffffff);
            Minecraft.getMinecraft().fontRendererObj.drawStringWithShadow("Z " + (z > 0 ? "+" : "")+ (float) z/2,1,sr.getScaledHeight()-10,0xffffffff);
            Main.getMain.waterMark.drawWaterMark(sr.getScaledWidth(),sr.getScaledHeight());
            Main.getMain.arrayList.draw(sr.getScaledWidth(),sr.getScaledHeight());
		try {

			if (mc.currentScreen instanceof GuiChat) {
				if (this.animations > 0) {
					--this.animations;
					--this.animations;
				}

			} else {

				if (this.animations < (49 + mc.fontRendererObj.getStringWidth(GuiChat.inputField.getText()) * 1.3)) {
					++this.animations;

				} else {
					this.animations = (int) (49 + mc.fontRendererObj.getStringWidth(GuiChat.inputField.getText()) * 1.3);
					GuiChat.inputField.setText(" ");
				}
			}


			if(mc.currentScreen instanceof GuiChat){

			GL11.glTranslated(-animations, 0, 0);
			GuiApi.drawBorderedRect(-8, sr.getScaledHeight() - 31,
					(int) (48 + mc.fontRendererObj.getStringWidth(GuiChat.inputField.getText()) * 1.3),
					sr.getScaledHeight() - 6,GuiChat.inputField.getText().startsWith(".") ? Main.getMain.getClientColor().getRGB() : Color.gray.darker().darker().darker().getRGB(),
					Color.gray.darker().darker().darker().darker().darker().getRGB());
			GuiChat.drawAltFace(mc.thePlayer.getName(), 2, sr.getScaledHeight() - 30, 24, 24, false);
			this.drawRect(30, sr.getScaledHeight() - 5, 32, sr.getScaledHeight() - 31,
					new Color(Main.getMain.getClientColor().getRGB()).getRGB());
			GL11.glTranslated(30, -4, 0);
			GuiChat.inputField.drawChatBox();
				GL11.glTranslated(-30, 4, 0);

			GL11.glTranslated(animations, 0, 0);
			}
		}catch(Exception ignored){

		}

            GlStateManager.enablePolygonOffset();
            GlStateManager.doPolygonOffset(1.0F, -1500000.0F);
		GL11.glTranslated(0,  Main.getMain.waterMark.getHeight()-7, 0);
		Main.getMain.tabGui.drawTabGui();
		GL11.glTranslated(0, -Main.getMain.waterMark.getHeight()-7, 0);
            GlStateManager.disablePolygonOffset();
            GlStateManager.doPolygonOffset(1.0F, 1500000.0F);
		GL11.glPopMatrix();



	}catch(Exception ignored){

	}
	}
}

minecraft_de_Client_Render_NahrFontRenderer.java

package de.Client.Render;

import net.minecraft.client.Minecraft;
import net.minecraft.client.renderer.GlStateManager;
import net.minecraft.client.renderer.Tessellator;
import net.minecraft.client.renderer.WorldRenderer;
import net.minecraft.client.renderer.texture.DynamicTexture;
import net.minecraft.util.ResourceLocation;
import net.minecraft.util.StringUtils;

import java.awt.*;
import java.awt.geom.Rectangle2D;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.InputStream;
import java.util.Arrays;
import java.util.List;
import java.util.regex.Pattern;

public class NahrFontRenderer {
    public enum FontType {
        NORMAL, EMBOSS_TOP, EMBOSS_BOTTOM, OUTLINE_THIN, SHADOW_THICK, SHADOW_THIN
    }

    private BufferedImage bufferedImage;
    private final int endChar;
    private float extraSpacing = 0.0F;
    private final float fontSize;
    private final Pattern patternControlCode = Pattern.compile("(?i)\\u00A7[0-9A-FK-OG]");
    private final Pattern patternUnsupported = Pattern.compile("(?i)\\u00A7[K-O]");
    private ResourceLocation resourceLocation;
    private final int startChar;
    private Font theFont;
    private Graphics2D theGraphics;
    private FontMetrics theMetrics;
    private final float[] xPos;
    private final float[] yPos;

    public NahrFontRenderer(Object font, float size) {
        this(font, size, 0.0F);
    }

    public NahrFontRenderer(Object font, float size, float spacing) {
        this.fontSize = size;
        this.startChar = 32;
        this.endChar = 255;
        this.extraSpacing = spacing;
        this.xPos = new float[this.endChar - this.startChar];
        this.yPos = new float[this.endChar - this.startChar];
        setupGraphics2D();
        createFont(font, size);
    }

    private void createFont(Object font, float size) {
        try {
            if (font instanceof Font) {
                this.theFont = (Font) font;
            } else if (font instanceof File) {
                this.theFont = Font.createFont(0, (File) font).deriveFont(size);
            } else if (font instanceof InputStream) {
                this.theFont = Font.createFont(0, (InputStream) font).deriveFont(size);
            } else if (font instanceof String) {
                this.theFont = new Font((String) font, 0, Math.round(size));
            } else {
                this.theFont = new Font("Verdana", 0, Math.round(size));
            }

            this.theGraphics.setFont(this.theFont);
        } catch (final Exception e) {
            e.printStackTrace();
            Minecraft.getMinecraft().shutdown();
        }
        this.theGraphics.setFont(this.theFont);
        this.theGraphics.setColor(new Color(255, 255, 255, 0));
        this.theGraphics.fillRect(0, 0, 256, 256);
        this.theGraphics.setColor(Color.white);
        this.theMetrics = this.theGraphics.getFontMetrics();

        float x = 5.0F;
        float y = 5.0F;
        for (int i = this.startChar; i < this.endChar; i++) {
            this.theGraphics.drawString(Character.toString((char) i), x, y + this.theMetrics.getAscent());
            this.xPos[i - this.startChar] = x;
            this.yPos[i - this.startChar] = y - this.theMetrics.getMaxDescent();
            x += this.theMetrics.stringWidth(Character.toString((char) i)) + 2.0F;
            if (x >= 250 - this.theMetrics.getMaxAdvance()) {
                x = 5.0F;
                y += this.theMetrics.getMaxAscent() + this.theMetrics.getMaxDescent() + this.fontSize / 2.0F;
            }
        }
        DynamicTexture dynamicTexture;
        this.resourceLocation = Minecraft.getMinecraft().getTextureManager().getDynamicTextureLocation("font" + font.toString() + size, dynamicTexture = new DynamicTexture(this.bufferedImage));
    }

    private void drawChar(char character, float x, float y) {
        final Rectangle2D bounds = this.theMetrics.getStringBounds(Character.toString(character), this.theGraphics);
        drawTexturedModalRect(x, y, this.xPos[character - this.startChar], this.yPos[character - this.startChar], (float) bounds.getWidth(), (float) bounds.getHeight() + this.theMetrics.getMaxDescent() + 1.0F);
    }

    private void drawer(String text, float x, float y, int color) {
        x *= 2.0F;
        y *= 2.0F;
        GlStateManager.func_179098_w();
        Minecraft.getMinecraft().getTextureManager().bindTexture(this.resourceLocation);
        final float alpha = (color >> 24 & 0xFF) / 255.0F;
        final float red = (color >> 16 & 0xFF) / 255.0F;
        final float green = (color >> 8 & 0xFF) / 255.0F;
        final float blue = (color & 0xFF) / 255.0F;
        GlStateManager.color(red, green, blue, alpha);
        final float startX = x;
        for (int i = 0; i < text.length(); i++)
            if (text.charAt(i) == '\247' && i + 1 < text.length()) {
                final char oneMore = Character.toLowerCase(text.charAt(i + 1));
                if (oneMore == 'n') {
                    y += this.theMetrics.getAscent() + 2;
                    x = startX;
                }
                final int colorCode = Minecraft.getMinecraft().fontRendererObj.func_175064_b(oneMore);
                if (colorCode != 16777215)
                    GlStateManager.color((colorCode >> 16) / 255.0F, (colorCode >> 8 & 0xFF) / 255.0F, (colorCode & 0xFF) / 255.0F, alpha);
                else if (oneMore == 'r')
                    GlStateManager.color(red, green, blue, alpha);
                else if (oneMore == 'g')
                    GlStateManager.color(0.3F, 0.7F, 1.0F, alpha);
                i++;
            } else {
                char character = text.charAt(i);
                try {
                    drawChar(character, x, y);
                } catch (ArrayIndexOutOfBoundsException exception) {
                    character = '?';
                    drawChar(character, x, y);
                }
                x += getStringWidth(Character.toString(character)) * 2.0F;
            }
        GlStateManager.color(1.0F, 1.0F, 1.0F, 1.0F);
    }

    public void drawString(String text, float x, float y, int color, int shadowColor) {
        this.drawString(text, x, y, FontType.SHADOW_THICK, color, shadowColor);
    }

    public void drawString(String text, float x, float y, FontType fontType, int color) {
        this.drawString(text, x, y, fontType, color, (color & 16579836) >> 2 | color & -16777216);
    }

    public void drawString(String text, float x, float y, FontType fontType, int color, int color2) {
        text = stripUnsupported(text);
        GlStateManager.pushMatrix();
        GlStateManager.enableBlend();
        GlStateManager.scale(0.5F, 0.5F, 0.5F);
        final String colorless = stripControlCodes(text);
        switch (fontType) {
            case SHADOW_THICK:
                drawer(colorless, x + 1.0F, y + 1.0F, color2);
                break;
            case SHADOW_THIN:
                drawer(colorless, x + 0.5F, y + 0.5F, color2);
                break;
            case OUTLINE_THIN:
                drawer(colorless, x + 0.5F, y, color2);
                drawer(colorless, x - 0.5F, y, color2);
                drawer(colorless, x, y + 0.5F, color2);
                drawer(colorless, x, y - 0.5F, color2);
                break;
            case EMBOSS_BOTTOM:
                drawer(colorless, x, y + 0.5F, color2);
                break;
            case EMBOSS_TOP:
                drawer(colorless, x, y - 0.5F, color2);
                break;
            case NORMAL:
            default:
                break;
        }

        drawer(text, x, y, color);
        GlStateManager.scale(2.0F, 2.0F, 2.0F);
        GlStateManager.popMatrix();
    }

    private void drawTexturedModalRect(float x, float y, float u, float v, float width, float height) {
        final float scale = 0.0039063F;
        final WorldRenderer worldRenderer = Tessellator.getInstance().getWorldRenderer();
        final Tessellator tessellator = Tessellator.getInstance();
        worldRenderer.startDrawingQuads();
        worldRenderer.addVertexWithUV(x + 0.0F, y + height, 0.0D, (u + 0.0F) * scale, (v + height) * scale);
        worldRenderer.addVertexWithUV(x + width, y + height, 0.0D, (u + width) * scale, (v + height) * scale);
        worldRenderer.addVertexWithUV(x + width, y + 0.0F, 0.0D, (u + width) * scale, (v + 0.0F) * scale);
        worldRenderer.addVertexWithUV(x + 0.0F, y + 0.0F, 0.0D, (u + 0.0F) * scale, (v + 0.0F) * scale);
        tessellator.draw();
    }

    private Rectangle2D getBounds(String text) {
        return this.theMetrics.getStringBounds(text, this.theGraphics);
    }

    public Font getFont() {
        return this.theFont;
    }

    private String getFormatFromString(String par0Str) {
        String var1 = "";
        int var2 = -1;
        final int var3 = par0Str.length();

        while ((var2 = par0Str.indexOf('\247', var2 + 1)) != -1) {
            if (var2 < var3 - 1) {
                final char var4 = par0Str.charAt(var2 + 1);

                if (isFormatColor(var4)) {
                    var1 = "\247" + var4;
                } else if (isFormatSpecial(var4)) {
                    var1 = var1 + "\247" + var4;
                }
            }
        }

        return var1;
    }

    public Graphics2D getGraphics() {
        return this.theGraphics;
    }

    public float getStringHeight(String text) {
        return (float) getBounds(text).getHeight() / 2.0F;
    }

    public float getStringWidth(String text) {
    	text = StringUtils.stripControlCodes(text);
        return (float) (getBounds(text).getWidth() + this.extraSpacing) / 2.0F;
    }

    private boolean isFormatColor(char par0) {
        return par0 >= '0' && par0 <= '9' || par0 >= 'a' && par0 <= 'f' || par0 >= 'A' && par0 <= 'F';
    }

    private boolean isFormatSpecial(char par0) {
        return par0 >= 'k' && par0 <= 'o' || par0 >= 'K' && par0 <= 'O' || par0 == 'r' || par0 == 'R';
    }

    public List listFormattedStringToWidth(String s, int width) {
        return Arrays.asList(wrapFormattedStringToWidth(s, width).split("\n"));
    }

    private void setupGraphics2D() {
        this.bufferedImage = new BufferedImage(256, 256, 2);
        this.theGraphics = (Graphics2D) this.bufferedImage.getGraphics();
        this.theGraphics.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
    }

    private int sizeStringToWidth(String par1Str, float par2) {
        final int var3 = par1Str.length();
        float var4 = 0.0F;
        int var5 = 0;
        int var6 = -1;

        for (boolean var7 = false; var5 < var3; var5++) {
            final char var8 = par1Str.charAt(var5);

            switch (var8) {
                case '\n':
                    var5--;
                    break;
                case '\247':
                    if (var5 < var3 - 1) {
                        var5++;
                        final char var9 = par1Str.charAt(var5);

                        if (var9 != 'l' && var9 != 'L') {
                            if (var9 == 'r' || var9 == 'R' || isFormatColor(var9)) {
                                var7 = false;
                            }
                        } else {
                            var7 = true;
                        }
                    }
                    break;
                case ' ':
                case '-':
                case '_':
                case ':':
                    var6 = var5;
                default:
                    final String text = String.valueOf(var8);
                    var4 += getStringWidth(text);

                    if (var7) {
                        var4 += 1.0F;
                    }
                    break;
            }
            if (var8 == '\n') {
                var5++;
                var6 = var5;
            } else {
                if (var4 > par2) {
                    break;
                }
            }
        }
        return var5 != var3 && var6 != -1 && var6 < var5 ? var6 : var5;
    }

    public String stripControlCodes(String s) {
        return this.patternControlCode.matcher(s).replaceAll("");
    }

    public String stripUnsupported(String s) {
        return this.patternUnsupported.matcher(s).replaceAll("");
    }

    public String wrapFormattedStringToWidth(String s, float width) {
        final int wrapWidth = sizeStringToWidth(s, width);

        if (s.length() <= wrapWidth)
            return s;
        final String split = s.substring(0, wrapWidth);
        final String split2 = getFormatFromString(split) + s.substring(wrapWidth + (s.charAt(wrapWidth) == ' ' || s.charAt(wrapWidth) == '\n' ? 1 : 0));
        try {
            return split + "\n" + wrapFormattedStringToWidth(split2, width);
        } catch (final Exception e) {
            System.out.println("Cannot wrap string to width.");
        }
        return "";
    }
}

minecraft_de_Client_Render_Outline.java

package de.Client.Render;

import net.minecraft.client.Minecraft;
import org.lwjgl.BufferUtils;
import org.lwjgl.opengl.ARBShaderObjects;
import org.lwjgl.opengl.EXTFramebufferObject;
import org.lwjgl.opengl.GL11;
import org.lwjgl.opengl.GL13;

import java.nio.ByteBuffer;
import java.nio.FloatBuffer;
import java.nio.IntBuffer;
//BY ARAB
public class Outline
{
  private float outlineSize;
  private int sampleRadius;
  private final int targetTextureID;
  private final int textureWidth;
  private final int textureHeight;
  private final int renderWidth;
  private final int renderHeight;
  private int fboTextureID;
  private int fboID;
  private int renderBufferID;
  private static int vertexShaderID = -1;
  private static int fragmentShaderID = -1;
  private static int shaderProgramID = -1;
  private static int diffuseSamperUniformID = -1;
  private static int texelSizeUniformID = -1;
  private static int sampleRadiusUniformID = -1;
  
  public Outline(int targetTextureID, int textureWidth, int textureHeight, int dispWidth, int dispHeight, float outlineSize, int sampleRadius)
  {
    this.fboTextureID = -1;
    this.fboID = -1;
    this.renderBufferID = -1;
    shaderProgramID = -1;
    fragmentShaderID = -1;
    vertexShaderID = -1;
    diffuseSamperUniformID = -1;
    texelSizeUniformID = -1;
    sampleRadiusUniformID = -1;
    this.fboTextureID = -1;
    this.fboID = -1;
    this.renderBufferID = -1;
    this.targetTextureID = targetTextureID;
    this.textureWidth = textureWidth;
    this.textureHeight = textureHeight;
    this.renderWidth = dispWidth;
    this.renderHeight = dispHeight;
    this.outlineSize = outlineSize;
    this.sampleRadius = sampleRadius;
    generateFBO();
    initShaders();
  }
  
  public Outline setOutlineSize(float size)
  {
    this.outlineSize = size;
    return this;
  }
  
  public Outline setSampleRadius(int radius)
  {
    this.sampleRadius = radius;
    return this;
  }
  
  public int getTextureID()
  {
    return this.fboTextureID;
  }
  
  public void delete()
  {
    if (this.renderBufferID > -1) {
      EXTFramebufferObject.glDeleteRenderbuffersEXT(this.renderBufferID);
    }
    if (this.fboID > -1) {
      EXTFramebufferObject.glDeleteFramebuffersEXT(this.fboID);
    }
    if (this.fboTextureID > -1) {
      GL11.glDeleteTextures(this.fboTextureID);
    }
  }
  
  public Outline update()
  {
    if ((this.fboID == -1) || (this.renderBufferID == -1) || (shaderProgramID == -1)) {
      throw new RuntimeException("Invalid IDs!");
    }
    EXTFramebufferObject.glBindFramebufferEXT(36160, this.fboID);
    int var9 = Math.max(Minecraft.func_175610_ah(), 30);
    GL11.glClear(16640);
    Minecraft.getMinecraft().entityRenderer
      .updateFogColor((float)(Minecraft.getMinecraft().entityRenderer.renderEndNanoTime + 1000000000 / var9));
    ARBShaderObjects.glUseProgramObjectARB(shaderProgramID);
    ARBShaderObjects.glUniform1iARB(diffuseSamperUniformID, 0);
    GL13.glActiveTexture(33984);
    GL11.glEnable(3553);
    GL11.glBindTexture(3553, this.targetTextureID);
    FloatBuffer texelSizeBuffer = BufferUtils.createFloatBuffer(2);
    texelSizeBuffer.position(0);
    texelSizeBuffer.put(1.0F / this.textureWidth * this.outlineSize);
    texelSizeBuffer.put(1.0F / this.textureHeight * this.outlineSize);
    texelSizeBuffer.flip();
    ARBShaderObjects.glUniform2ARB(texelSizeUniformID, texelSizeBuffer);
    IntBuffer sampleRadiusBuffer = BufferUtils.createIntBuffer(1);
    sampleRadiusBuffer.position(0);
    sampleRadiusBuffer.put(this.sampleRadius);
    sampleRadiusBuffer.flip();
    ARBShaderObjects.glUniform1ARB(sampleRadiusUniformID, sampleRadiusBuffer);
    GL11.glDisable(3553);
    GL11.glBegin(4);
    GL11.glTexCoord2d(0.0D, 1.0D);
    GL11.glVertex2d(0.0D, 0.0D);
    GL11.glTexCoord2d(0.0D, 0.0D);
    GL11.glVertex2d(0.0D, this.renderHeight);
    GL11.glTexCoord2d(1.0D, 0.0D);
    GL11.glVertex2d(this.renderWidth, this.renderHeight);
    GL11.glTexCoord2d(1.0D, 0.0D);
    GL11.glVertex2d(this.renderWidth, this.renderHeight);
    GL11.glTexCoord2d(1.0D, 1.0D);
    GL11.glVertex2d(this.renderWidth, 0.0D);
    GL11.glTexCoord2d(0.0D, 1.0D);
    GL11.glVertex2d(0.0D, 0.0D);
    GL11.glEnd();
    ARBShaderObjects.glUseProgramObjectARB(0);
    return this;
  }
  
  private void generateFBO()
  {
    this.fboID = EXTFramebufferObject.glGenFramebuffersEXT();
    this.fboTextureID = GL11.glGenTextures();
    this.renderBufferID = EXTFramebufferObject.glGenRenderbuffersEXT();
    GL11.glBindTexture(3553, this.fboTextureID);
    GL11.glTexParameterf(3553, 10241, 9729.0F);
    GL11.glTexParameterf(3553, 10240, 9729.0F);
    GL11.glTexParameterf(3553, 10242, 10496.0F);
    GL11.glTexParameterf(3553, 10243, 10496.0F);
    GL11.glBindTexture(3553, 0);
    GL11.glBindTexture(3553, this.fboTextureID);
    GL11.glTexImage2D(3553, 0, 32856, this.textureWidth, this.textureHeight, 0, 6408, 5121, (ByteBuffer)null);
    EXTFramebufferObject.glBindFramebufferEXT(36160, this.fboID);
    EXTFramebufferObject.glFramebufferTexture2DEXT(36160, 36064, 3553, this.fboTextureID, 0);
    EXTFramebufferObject.glBindRenderbufferEXT(36161, this.renderBufferID);
    EXTFramebufferObject.glRenderbufferStorageEXT(36161, 34041, this.textureWidth, this.textureHeight);
    EXTFramebufferObject.glFramebufferRenderbufferEXT(36160, 36128, 36161, this.renderBufferID);
    checkFBO();
  }
  public static String getLogInfo(int obj)
  {
    return ARBShaderObjects.glGetInfoLogARB(obj, ARBShaderObjects.glGetObjectParameteriARB(obj, 35716));
  }
  
  public static int createShader(String shaderCode, int shaderType)
		    throws Exception
		  {
		    int shader = 0;
		    try
		    {
		      shader = ARBShaderObjects.glCreateShaderObjectARB(shaderType);
		      if (shader == 0) {
		        return 0;
		      }
		      ARBShaderObjects.glShaderSourceARB(shader, shaderCode);
		      ARBShaderObjects.glCompileShaderARB(shader);
		      if (ARBShaderObjects.glGetObjectParameteriARB(shader, 35713) == 0) {
		        throw new RuntimeException("Error creating shader: " + getLogInfo(shader));
		      }
		      return shader;
		    }
		    catch (Exception exc)
		    {
		      ARBShaderObjects.glDeleteObjectARB(shader);
		      throw exc;
		    }
		  }
  
  private void checkFBO() {}
  
  public void initShaders()
  {
    if (shaderProgramID == -1)
    {
      shaderProgramID = ARBShaderObjects.glCreateProgramObjectARB();
      try
      {
        if (vertexShaderID == -1)
        {
          String vertexShaderCode = "#version 120 \nvoid main() { \ngl_TexCoord[0] = gl_MultiTexCoord0; \ngl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; \n}";
          vertexShaderID = this.createShader("#version 120 \nvoid main() { \ngl_TexCoord[0] = gl_MultiTexCoord0; \ngl_Position = gl_ModelViewProjectionMatrix * gl_Vertex; \n}", 35633);
        }
        if (fragmentShaderID == -1)
        {
          String fragmentShaderCode = "#version 120 \nuniform sampler2D DiffuseSamper; \nuniform vec2 TexelSize; \nuniform int SampleRadius; \nvoid main(){ \nvec4 centerCol = texture2D(DiffuseSamper, gl_TexCoord[0].st); \nif(centerCol.a != 0.0F) { \ngl_FragColor = vec4(0, 0, 0, 0); \nreturn; \n} \nvec4 colAvg = vec4(0, 0, 0, 0); \nfor(int xo = -SampleRadius; xo <= SampleRadius; xo++) { \nfor(int yo = -SampleRadius; yo <= SampleRadius; yo++) { \nvec4 currCol = texture2D(DiffuseSamper, gl_TexCoord[0].st + vec2(xo * TexelSize.x, yo * TexelSize.y)); \nif(currCol.r != 0.0F || currCol.g != 0.0F || currCol.b != 0.0F || currCol.a != 0.0F) { \ncolAvg += vec4(1, 1, 1, max(0, (SampleRadius*1.0F - sqrt(xo * xo * 0.75f + yo * yo * 0.9f)) / SampleRadius * 1.00F)); \n} \n} \n} \ncolAvg.a /= SampleRadius*SampleRadius * 1.0F / 2.0F; \ngl_FragColor = colAvg; \n}";
          
          fragmentShaderCode = "#version 120 \nuniform sampler2D DiffuseSamper; \nuniform vec2 TexelSize; \nuniform int SampleRadius; \nvoid main(){ \nvec4 centerCol = texture2D(DiffuseSamper, gl_TexCoord[0].st); \nif(centerCol.a != 0.0F) { \ngl_FragColor = vec4(0, 0, 0, 0); \nreturn; \n} \nfloat closest = SampleRadius * 1.0F + 1.0F; \nfor(int xo = -SampleRadius; xo <= SampleRadius; xo++) { \nfor(int yo = -SampleRadius; yo <= SampleRadius; yo++) { \nvec4 currCol = texture2D(DiffuseSamper, gl_TexCoord[0].st + vec2(xo * TexelSize.x, yo * TexelSize.y)); \nif(currCol.r != 0.0F || currCol.g != 0.0F || currCol.b != 0.0F || currCol.a != 0.0F) { \nfloat currentDist = sqrt(xo*xo*1.0f + yo*yo*1.0f); \nif(currentDist < closest) { closest = currentDist; } \n} \n} \n} \ngl_FragColor = vec4(1, 1, 1, max(0, ((SampleRadius*1.0F) - (closest - 1)) / (SampleRadius*1.0F))); \n}";
          
          fragmentShaderID = this.createShader(fragmentShaderCode, 35632);
        }
      }
      catch (Exception ex)
      {
        shaderProgramID = -1;
        vertexShaderID = -1;
        fragmentShaderID = -1;
        ex.printStackTrace();
      }
      if (shaderProgramID != -1)
      {
        ARBShaderObjects.glAttachObjectARB(shaderProgramID, vertexShaderID);
        ARBShaderObjects.glAttachObjectARB(shaderProgramID, fragmentShaderID);
        ARBShaderObjects.glLinkProgramARB(shaderProgramID);
        if (ARBShaderObjects.glGetObjectParameteriARB(shaderProgramID, 35714) == 0)
        {
          System.err.println(this.getLogInfo(shaderProgramID));
          return;
        }
        ARBShaderObjects.glValidateProgramARB(shaderProgramID);
        if (ARBShaderObjects.glGetObjectParameteriARB(shaderProgramID, 35715) == 0)
        {
          System.err.println(this.getLogInfo(shaderProgramID));
          return;
        }
        ARBShaderObjects.glUseProgramObjectARB(0);
        diffuseSamperUniformID = ARBShaderObjects.glGetUniformLocationARB(shaderProgramID, "DiffuseSamper");
        
        texelSizeUniformID = ARBShaderObjects.glGetUniformLocationARB(shaderProgramID, "TexelSize");
        
        sampleRadiusUniformID = ARBShaderObjects.glGetUniformLocationARB(shaderProgramID, "SampleRadius");
      }
    }
  }
}

minecraft_de_Client_Render_StaticClickGui_ElementButton.java

package de.Client.Render.StaticClickGui;


import java.awt.Color;

import de.Client.Main.Main;
import de.Client.Main.Modules.Category;
import de.Client.Render.GuiApi;
import de.Client.Utils.ColorUtil;
import net.minecraft.client.Minecraft;
import net.minecraft.client.entity.EntityPlayerSP;
import net.minecraft.client.gui.Gui;
import net.minecraft.client.gui.ScaledResolution;
import net.minecraft.client.renderer.GlStateManager;
import net.minecraft.client.renderer.Tessellator;
import net.minecraft.client.renderer.WorldRenderer;
import net.minecraft.client.renderer.entity.RenderItem;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.init.Blocks;
import net.minecraft.init.Items;
import net.minecraft.item.ItemStack;
import net.minecraft.util.ResourceLocation;
import org.lwjgl.input.Mouse;
import org.lwjgl.opengl.GL11;

public class ElementButton
        extends Gui
{
    public int x;
    public int y;
    public Category cat;
    private RenderItem itemRenderer;
    public boolean hovered;
    public int id;
    public int particalticks;

    public ElementButton(int x, int y, Category cat, int id)
    {
        this.x = x;
        this.y = y;
        this.cat = cat;
        itemRenderer = Minecraft.getMinecraft().getRenderItem();
        this.id = id;
    }

    public void drawItem(int p_184044_1_, int p_184044_2_, float p_184044_3_, EntityPlayer p_184044_4_, ItemStack p_184044_5_)
    {
        if (p_184044_5_ != null)
        {
            GlStateManager.enableLighting();
            GlStateManager.enableBlend();
        //    GlStateManager.enableColorMaterial();
            itemRenderer.func_180450_b(p_184044_5_, p_184044_1_, p_184044_2_);
            itemRenderer.func_175030_a(Minecraft.getMinecraft().fontRendererObj, p_184044_5_, p_184044_1_, p_184044_2_);
            GlStateManager.disableBlend();
            GlStateManager.disableLighting();
        }
    }

    public boolean mousePressed(int mouseX, int mouseY)
    {
        this.hovered = (mouse(mouseX, mouseY, this.x - 70, this.x + 70, this.y - 70, this.y + 70)) && (Mouse.isButtonDown(0)) ? true : false;
        return hovered;
    }

    public void Update(int mouseX, int mouseY)
    {
        if (mousePressed(mouseX, mouseY))
        {
            Minecraft.getMinecraft().thePlayer.playSound("random.pop", 1.0F, 1.0F);
  //          Minecraft.getMinecraft().displayGuiScreen(new GuiModuleListForCategory(this.cat));
        }
    }

    public ItemStack getItemForCateGory(Category cat)
    {
        ItemStack item = null;
        if (cat == Category.COMBAT) {
            item = new ItemStack(Items.diamond_sword, 1);
        }
        if (cat == Category.MOVEMENT) {
            item = new ItemStack(Items.golden_boots, 1);
        }
        if (cat == Category.RENDER) {
            item = new ItemStack(Items.diamond, 1);
        }
        if (cat == Category.WORLD) {
            item = new ItemStack(Blocks.bedrock, 1);
        }
        if (cat == Category.PLAYER) {
            item = new ItemStack(Items.fireworks, 1);
        }
        return item;
    }

    private boolean mouse(int mouseX, int mouseY, int minX, int maxX, int minY, int maxY)
    {
        if ((mouseX >= minX) && (mouseX <= maxX) && (mouseY >= minY) && (mouseY <= maxY)) {
            return true;
        }
        return false;
    }


    public void drawButton(Minecraft mc, int mouseX, int mouseY, Category cat, float particalticks)
    {
        

        GlStateManager.color(1.0F, 1.0F, 1.0F, 1.0F);
        this.hovered = mouse(mouseX, mouseY, this.x - 70, this.x + 70, this.y - 70, this.y + 70);
        ScaledResolution sr = new ScaledResolution();
        float scale = 4.0F;
        GuiApi.drawRect(this.x - 70, this.y - 70, this.x + 70, this.y + 70, 0xff2b2b2b);
        Minecraft.getMinecraft().getTextureManager().bindTexture(new ResourceLocation("textures/misc/vignette.png"));
       // Gui.drawModalRectWithCustomSizedTexture(((int)x+70),((int)y+70),((int)x-70),((int)y-70),((int)x+70),((int)y+70),((int)x-70),((int)y-70));
        /*/
        GL11.glPushMatrix();

        double width = sr.getScaledWidth();
        double height = sr.getScaledHeight();

        GL11.glScaled(height/width,1,0);

        ColorUtil.setColor(new Color(0x303030));
        Tessellator var9 = Tessellator.getInstance();
        WorldRenderer var10 = var9.getWorldRenderer();
        var10.startDrawingQuads();
        var10.addVertexWithUV(0.0D, (double)sr.getScaledHeight(), -90.0D, 0.0D, 1.0D);
        var10.addVertexWithUV((double)sr.getScaledWidth(), (double)sr.getScaledHeight(), -90.0D, 1.0D, 1.0D);
        var10.addVertexWithUV((double)sr.getScaledWidth(), 0.0D, -90.0D, 1.0D, 0.0D);
        var10.addVertexWithUV(0.0D, 0.0D, -90.0D, 0.0D, 0.0D);
        var9.draw();

        GL11.glPopMatrix();
        /*/
        GL11.glScalef(scale, scale, scale);
        GL11.glTranslatef(-7.0F, -7.0F, 0.0F);
        GL11.glColor3d(1.0D, 1.0D, 1.0D);
        drawItem((int)(this.x / scale), (int)(this.y / scale), particalticks + 50.0F, Minecraft.getMinecraft().thePlayer, getItemForCateGory(cat));
        GL11.glTranslatef(7.0F, 7.0F, 0.0F);
        GL11.glScalef(1.0F / scale, 1.0F / scale, 1.0F / scale);
        Main.getMain.verdanas.drawCenteredStringWithShadow(this.cat.name(), this.x, this.y + 57,this.hovered ? Main.getMain.getClientColor().getRGB() : 0xffffffff);
    }
}

minecraft_de_Client_Render_StaticClickGui_MainPanel.java

package de.Client.Render.StaticClickGui;

import de.Client.Main.Main;
import de.Client.Main.Modules.Category;
import de.Client.Render.GuiApi;
import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.GuiScreen;
import net.minecraft.client.gui.ScaledResolution;

import java.awt.*;
import java.util.ArrayList;

/**
 * Created by Daniel on 09.09.2017.
 */
public class MainPanel extends GuiScreen{
    public ArrayList<ElementButton> buttons = new ArrayList();

    public void initGui()
    {
        buttons.clear();
        ScaledResolution sr = new ScaledResolution();
        buttons.add(new ElementButton(sr.getScaledWidth() / 2 - 160, sr.getScaledHeight() / 2 - 50, Category.COMBAT, 1));
        buttons.add(new ElementButton(sr.getScaledWidth() / 2, sr.getScaledHeight() / 2 - 50, Category.MOVEMENT, 2));
        buttons.add(new ElementButton(sr.getScaledWidth() / 2 + 160, sr.getScaledHeight() / 2 - 50, Category.PLAYER, 3));
        buttons.add(new ElementButton(sr.getScaledWidth() / 2-80 , sr.getScaledHeight() / 2 + 110, Category.WORLD, 4));
        buttons.add(new ElementButton(sr.getScaledWidth() / 2+80, sr.getScaledHeight() / 2 + 110, Category.RENDER, 5));
    }

    public void drawScreen(int mouseX, int mouseY, float partialTicks) {
        ScaledResolution sr = new ScaledResolution();
      //  GuiApi.drawRect(sr.getScaledWidth() / 2 - 251, sr.getScaledHeight() / 2 - 141, sr.getScaledWidth() / 2 + 251, sr.getScaledHeight() / 2 + 201, Color.black.darker().getRGB());
        GuiApi.drawBorderRectNoCorners(sr.getScaledWidth() / 2 - 250, sr.getScaledHeight() / 2 - 140, sr.getScaledWidth() / 2 + 250, sr.getScaledHeight() / 2 + 200,Main.getMain.getClientColor().getRGB(), Color.darkGray.getRGB());
        //GuiApi.drawRect(sr.getScaledWidth() / 2 - 252, sr.getScaledHeight() / 2 - 155, sr.getScaledWidth() / 2 + 252, sr.getScaledHeight() / 2- 140, Main.getMain.getClientColor().getRGB());
        for (ElementButton e : buttons) {
            e.drawButton(Minecraft.getMinecraft(), mouseX, mouseY, e.cat, partialTicks);
            e.Update(mouseX, mouseY);
        }
    }
}

minecraft_de_Client_Render_TabGuis_TabGuiC.java

package de.Client.Render.TabGuis;

import de.Client.Main.Main;
import de.Client.Main.Modules.Category;
import de.Client.Main.Modules.Module;
import de.Client.Render.GuiApi;
import de.Client.Utils.ColorUtil;
import de.Client.Utils.TabGui;
import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.Gui;
import net.minecraft.client.gui.ScaledResolution;
import org.lwjgl.opengl.GL11;

import java.awt.*;
import java.util.ArrayList;
import java.util.HashMap;

public class TabGuiC extends TabGui{


    public TabGuiC(){
        for(Category c : Category.values()){
            animationForCategory.put(c, 0);
        }
    }

    public static void startScissors(int x, int y, int width, int height) {
        GL11.glPushMatrix();
        GL11.glEnable(GL11.GL_SCISSOR_TEST);
        ScaledResolution sr1 = new ScaledResolution();
        int factor = sr1.getScaleFactor();
        GL11.glScissor(x * factor, (sr1.getScaledHeight() - height) * factor, Math.abs((width - x) * factor), Math.abs((height - y) * factor));
    }

    public static void stopScissor() {
        GL11.glDisable(GL11.GL_SCISSOR_TEST);
        GL11.glPopMatrix();
    }
    public boolean isMainMenu = true;
    public int mainMenu;
    public int modMenu;
    public Category currentcategory;
    public Module currentmodule;
    public int longesmodname = 0;
    public ArrayList<Module> modsforcategory = new ArrayList<Module>();
    public float renderY;
    public float animationY;
    public float animationmodule;
    public float rendermodule;
    public float animation;
    public HashMap animationForCategory = new HashMap<Category,Integer>();
    public void upKey() {
        Category categories[] = Category.values();
        if (this.isMainMenu) {
            if (this.mainMenu > 0) {
                --this.mainMenu;
            } else {
                this.mainMenu = categories.length - 1 - 2;
            }
        } else {
            this.modMenu--;
        }
    }

    public void downKey() {
        Category categories[] = Category.values();
        if (this.isMainMenu) {
            if (this.mainMenu < categories.length - 1 - 2) {
                ++this.mainMenu;
            } else {
                this.mainMenu = 0;
            }
        } else {
            this.modMenu++;

        }
    }

    public void rightKey() {
        if (this.isMainMenu) {
            animation = 10f;
            this.isMainMenu = false;
            this.rendermodule= this.mainMenu *15+10;

        } else {
            if (this.currentcategory != null) {
                this.currentmodule.toggleModule();
            }
        }

    }

    public void leftKey() {
        this.isMainMenu = true;
        this.modMenu = 0;

    }

    public void returnKey() {
        if (this.isMainMenu) {
            this.isMainMenu = false;
        } else {
            this.currentmodule.toggleModule();
        }
    }

    public float getDiffrent(float f1, float f2){
        return (float)  Math.sqrt((f1-f2)*(f1-f2));
    }

    public void upDateAnimations(){
        if(Minecraft.getMinecraft().thePlayer == null){
            return;
        }
        for(Category c : Category.values()){
            int animation = (Integer) this.animationForCategory.get(c);
            if(this.currentcategory == c){
                if(animation < 40){
                    animation +=getDiffrent(animation,80)/20;
                }
            }else{
                if(animation > 0){
                    animation -=2;
                }
                if(animation < 0){
                    animation = 0;
                }
            }
            animationForCategory.put(c, animation);
        }
        if(this.renderY > this.animationY){
            float plusgleich = getDiffrent(animationY,renderY);
            renderY -=  plusgleich/6;
        }else{
            float plusgleich = getDiffrent(animationY,renderY);
            renderY +=  plusgleich/6f;
        }
        if(this.rendermodule > this.animationmodule){
            float plusgleich = getDiffrent(animationmodule,rendermodule);
            rendermodule -=  plusgleich/6;
        }else{
            float plusgleich = getDiffrent(animationmodule,rendermodule);
            rendermodule +=  plusgleich/6f;
        }
    }

    public void drawTabGui() {

        ScaledResolution sr = new ScaledResolution();
        if (this.isMainMenu) {
            longesmodname = 0;
        }
        Category categories[] = Category.values();

        int y = 0;

        GuiApi.drawBorderRectNoCorners(1.5, 9, 80, (categories.length - 3) * 12 + 22.5, ColorUtil.transparency(Color.BLACK,0.9),
                ColorUtil.transparency(Color.BLACK,0.7));



    //    +((Integer) this.animationForCategory.get(categories[i]))
       //  Gui.drawRect(2, 10 + this.renderY, 80, 25 + this.renderY,  Main.getMain.getClientColor().getRGB() );
        //GuiApi.drawGradientRect(2, 10 + this.renderY-4, 80, 25 + this.renderY, 0, Integer.MIN_VALUE);



        for (int i = 0; i < categories.length - 2; ++i) {

            if (this.mainMenu == i) {
                this.animationY = y;
                currentcategory =categories[i];
            }

            String s = String.valueOf(String.valueOf(categories[i].toString().substring(0, 1)))
                    + categories[i].toString().substring(1, categories[i].toString().length()).toLowerCase();
            String replace = s.replace(s.substring(1), "");
            startScissors(2,(int) (10 +y + Main.getMain.waterMark.getHeight()-7), 80, (int) (23 + y+ Main.getMain.waterMark.getHeight()-7));
            GuiApi.drawBorderedCircle(41,((10 +y ) + 23 + y) / 2,animationForCategory.get(categories[i]).hashCode(), Main.getMain.getClientColor().getRGB(),Main.getMain.getClientColor().getRGB());
            //     Gui.drawRect(2, 10 + this.renderY, 80, 23 + this.renderY,  Main.getMain.getClientColor().getRGB() );
            stopScissor();
            Main.getMain.verdana.drawCenteredStringWithShadow(s, 40, y + 13f-5.5f,

                    this.mainMenu == i ? 0xffffffff : 0xff95a5a6);

            y += 12;
        }
        float newy = y;
        int x = 81;
        int size = 0;
        if (!this.modsforcategory.isEmpty()) {
            this.modsforcategory.clear();
        }
        if (!this.isMainMenu) {

            for (int i = 0; i < Main.getMain.moduleManager.getModules().size(); ++i) {
                Module mod = Main.getMain.moduleManager.getModules().get(i);
                if (mod != null) {

                    if (mod.category == this.currentcategory) {
                        this.modsforcategory.add(mod);

                    } else {

                    }
                }
            }

            for (int i = 0; i < this.modsforcategory.size(); ++i) {
                Module mod = modsforcategory.get(i);
                if (Minecraft.getMinecraft().fontRendererObj.getStringWidth(mod.name) > longesmodname) {
                    longesmodname = (int) ((int) Main.getMain.verdana.getWidth(mod.name)*1.1);

                }
            }
            //this.startScissors((int) ((int)x + 0.5), (int) ((int)newy), (int) ((int)x + 1 + longesmodname + 10), (int) ((int)newy+this.animation-1));
            if(this.animation+1 < 22 + this.modsforcategory.size() * 15 - 12+ newy+15){
                this.animation  *=1.2;
            }
            GuiApi.drawFineBorderedRect(x + 0.5, 10 + newy - 0.5, x + 1 + longesmodname + 10,
                    (int) (22 + this.modsforcategory.size() * 15 - 12+ newy), Color.black.getRGB(),
                    ColorUtil.transparency( new Color(0x991D1D1D),0.5));
         //   Gui.drawRect(x + 1, this.rendermodule, 0.5f + x + longesmodname + 10, this.rendermodule+15, Main.getMain.getClientColor().getRGB());
            for (int i = 0; i < this.modsforcategory.size(); ++i) {
                Module mod = modsforcategory.get(i);
                if (Main.getMain.verdana.getWidth(mod.name) > longesmodname) {
                    longesmodname = (int) Main.getMain.verdana.getWidth(mod.name);

                }

                if (!(i == this.modMenu)) {
                    Main.getMain.verdana.drawCenteredString(mod.name, x+this.longesmodname/2+5,
                            newy + 15-7, (mod.getState()) ? 0xffffffff : 0xff95a5a6);
                } else {
                    this.animationmodule = 10 + newy;
                    //	Gui.drawRect(x + 1, 10 + newy, 0.5f + x + longesmodname + 10, 25 + newy, Main.getMain.getClientColor().getRGB());
                    //	Gui.drawRect(x + 1, this.rendermodule, 0.5f + x + longesmodname + 10, this.rendermodule+15, Main.getMain.getClientColor().getRGB());
                    Main.getMain.verdana.drawCenteredStringWithShadow(mod.name, x+this.longesmodname/2+5,
                            newy + 15-7, (mod.getState()) ? 0xffffffff : 0xff95a5a6);

                }
                newy += 15;
                ++size;
                if (i == this.modMenu) {
                    currentmodule = mod;
                }

            }
            if (this.modMenu < 0) {
                this.modMenu = size - 1;
            }
            if (this.modMenu > size - 1) {
                this.modMenu = 0;
            }
            //	this.stopScissor();

        }
    }
}

minecraft_de_Client_Render_TabGuis_TabGuiD.java

package de.Client.Render.TabGuis;

import de.Client.Main.Main;
import de.Client.Main.Modules.Category;
import de.Client.Main.Modules.Module;
import de.Client.Render.GuiApi;
import de.Client.Utils.TabGui;
import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.Gui;
import net.minecraft.client.gui.ScaledResolution;
import org.lwjgl.opengl.GL11;

import java.awt.*;
import java.util.ArrayList;
import java.util.HashMap;

public class TabGuiD extends TabGui{

	
	public TabGuiD(){
		for(Category c : Category.values()){
			animationForCategory.put(c, 0);
		}
	}

	public static void startScissors(int x, int y, int width, int height) {
		GL11.glPushMatrix();
		GL11.glEnable(GL11.GL_SCISSOR_TEST);
		ScaledResolution sr1 = new ScaledResolution();
		int factor = sr1.getScaleFactor();
		GL11.glScissor(x * factor, (sr1.getScaledHeight() - height) * factor, Math.abs((width - x) * factor), Math.abs((height - y) * factor));
	}

	public static void stopScissor() {
		GL11.glDisable(GL11.GL_SCISSOR_TEST);
		GL11.glPopMatrix();
	}
	public boolean isMainMenu = true;
	public int mainMenu;
	public int modMenu;
	public Category currentcategory;
	public Module currentmodule;
	public float longesmodname = 0;
	public ArrayList<Module> modsforcategory = new ArrayList<Module>();
	public float renderY;
	public float animationY;
	public float animationmodule;
	public float rendermodule;
	public float animation;
	public HashMap animationForCategory = new HashMap<Category,Integer>();
	public void upKey() {
		Category categories[] = Category.values();
		if (this.isMainMenu) {
			if (this.mainMenu > 0) {
				--this.mainMenu;
			} else {
				this.mainMenu = categories.length - 1 - 2;
			}
		} else {
			this.modMenu--;
		}
	}

	public void downKey() {
		Category categories[] = Category.values();
		if (this.isMainMenu) {
			if (this.mainMenu < categories.length - 1 - 2) {
				++this.mainMenu;
			} else {
				this.mainMenu = 0;
			}
		} else {
			this.modMenu++;

		}
	}

	public void rightKey() {
		if (this.isMainMenu) {
			animation = 10f;
			this.isMainMenu = false;
			this.rendermodule= this.mainMenu *15+10;

		} else {
			if (this.currentcategory != null) {
				this.currentmodule.toggleModule();
			}
		}
		
	}

	public void leftKey() {
		this.isMainMenu = true;
		this.modMenu = 0;
		
	}

	public void returnKey() {
		if (this.isMainMenu) {
			this.isMainMenu = false;
		} else {
			this.currentmodule.toggleModule();
		}
	}
	
	public float getDiffrent(float f1, float f2){
		return (float)  Math.sqrt((f1-f2)*(f1-f2));	
	}	
	
	public void upDateAnimations(){
		if(Minecraft.getMinecraft().thePlayer == null){
			return;
		}
		for(Category c : Category.values()){
			int animation = (Integer) this.animationForCategory.get(c);
			if(this.currentcategory == c){
				if(animation < 10){
				animation ++;
				}
			}else{
				if(animation > 0){
					animation --;
				}
			}
			animationForCategory.put(c, animation);
		}
		if(this.renderY > this.animationY){
			float plusgleich = getDiffrent(animationY,renderY);
			renderY -=  plusgleich/6;
		}else{
			float plusgleich = getDiffrent(animationY,renderY);
			renderY +=  plusgleich/6f;	
		}
		if(this.rendermodule > this.animationmodule){
			float plusgleich = getDiffrent(animationmodule,rendermodule);
			rendermodule -=  plusgleich/6;
		}else{
			float plusgleich = getDiffrent(animationmodule,rendermodule);
			rendermodule +=  plusgleich/6f;	
		}
	}

	public void drawTabGui() {
        ScaledResolution sr = new ScaledResolution();
		if (this.isMainMenu) {
			longesmodname = 0;
		}
		Category categories[] = Category.values();
	
		int y = 0;

		GuiApi.drawBorderRectNoCorners(1.5, 9.5, 80, (categories.length - 3) * 15 + 25, Color.black.getRGB(),
				0xff2b2b2b);

		
		
		
		Gui.drawRect(2, 10 + this.renderY, 80, 25 + this.renderY,  Main.getMain.getClientColor().getRGB() );
        GL11.glPushMatrix();
        GuiApi.drawGradientRect(2, 10 + this.renderY-4, 80, 25 + this.renderY,0, Integer.MIN_VALUE);
        GL11.glPopMatrix();
        //GuiApi.drawGradientRect(2, 10 + this.renderY-4, 80, 25 + this.renderY, 0, Integer.MIN_VALUE);
		
		
	
		for (int i = 0; i < categories.length - 2; ++i) {

			if (this.mainMenu == i) {
			this.animationY = y;
			currentcategory =categories[i];
			}
			
			String s = String.valueOf(String.valueOf(categories[i].toString().substring(0, 1)))
					+ categories[i].toString().substring(1, categories[i].toString().length()).toLowerCase();
			String replace = s.replace(s.substring(1), "");

		Main.getMain.verdanas.drawStringWithShadow(s, 2+((Integer) this.animationForCategory.get(categories[i])), y + 13.5f-4,
			
					this.mainMenu == i ? 0xffffffff : 0xff95a5a6);
		
			y += 15;

		}
		float newy = this.renderY;
		int x = 81;
		int size = 0;
		if (!this.modsforcategory.isEmpty()) {
			this.modsforcategory.clear();
		}
		if (!this.isMainMenu) {
			
			for (int i = 0; i < Main.getMain.moduleManager.getModules().size(); ++i) {
				Module mod = Main.getMain.moduleManager.getModules().get(i);
				if (mod != null) {

					if (mod.category == this.currentcategory) {
						this.modsforcategory.add(mod);

					} else {

					}
				}
			}

			for (int i = 0; i < this.modsforcategory.size(); ++i) {
				Module mod = modsforcategory.get(i);
				if (Minecraft.getMinecraft().fontRendererObj.getStringWidth(mod.name) > longesmodname) {
					longesmodname = (float) (Main.getMain.verdanas.getWidth(mod.name)*1.1);

				}
			}
			//this.startScissors((int) ((int)x + 0.5), (int) ((int)newy), (int) ((int)x + 1 + longesmodname + 10), (int) ((int)newy+this.animation-1));
			if(this.animation+1 < 22 + this.modsforcategory.size() * 15 - 12+ newy+15){
				this.animation  *=1.2;
			}
			GuiApi.drawFineBorderedRect(x + 0.5, 10 + newy - 0.5, x + 1 + longesmodname + 10-0.5,
					(int) (22 + this.modsforcategory.size() * 15 - 12+ newy), Color.black.getRGB(),
					0xff2b2b2b);
			Gui.drawRect(x + 1, this.rendermodule, 0.5f + x + longesmodname + 10, this.rendermodule+15, Main.getMain.getClientColor().getRGB());
            GL11.glPushMatrix();
            GuiApi.drawGradientRect(x + 1, this.rendermodule-4, 0.5f + x + longesmodname + 10, this.rendermodule+15,0, Integer.MIN_VALUE);
            GL11.glPopMatrix();
			for (int i = 0; i < this.modsforcategory.size(); ++i) {
				Module mod = modsforcategory.get(i);
				if (Main.getMain.verdanas.getWidth(mod.name) > longesmodname) {
					longesmodname = (int) Main.getMain.verdanas.getWidth(mod.name);

				}

				if (!(i == this.modMenu)) {
					Main.getMain.verdanas.drawCenteredStringWithShadow(mod.name, x+this.longesmodname/2+5,
							newy + 15-6, (mod.getState()) ? 0xffffffff : 0xff95a5a6);
				} else {
					this.animationmodule = 10 + newy;
				//	Gui.drawRect(x + 1, 10 + newy, 0.5f + x + longesmodname + 10, 25 + newy, Main.getMain.getClientColor().getRGB());
				//	Gui.drawRect(x + 1, this.rendermodule, 0.5f + x + longesmodname + 10, this.rendermodule+15, Main.getMain.getClientColor().getRGB());
					Main.getMain.verdanas.drawCenteredStringWithShadow(mod.name, x+this.longesmodname/2+5,
							newy + 15-6, (mod.getState()) ? 0xffffffff : 0xff95a5a6);

				}
				newy += 15;
				++size;
				if (i == this.modMenu) {
					currentmodule = mod;
				}

			}
			if (this.modMenu < 0) {
				this.modMenu = size - 1;
			}
			if (this.modMenu > size - 1) {
				this.modMenu = 0;
			}
	//	this.stopScissor();
		}
	}
}

minecraft_de_Client_Render_TabGuis_TabGuiS.java

package de.Client.Render.TabGuis;

import de.Client.Main.Main;
import de.Client.Main.Modules.Category;
import de.Client.Main.Modules.Module;
import de.Client.Render.GuiApi;
import de.Client.Utils.TabGui;
import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.Gui;
import net.minecraft.client.gui.ScaledResolution;
import org.lwjgl.opengl.GL11;

import java.awt.*;
import java.util.ArrayList;
import java.util.HashMap;

public class TabGuiS extends TabGui{


    public TabGuiS(){
        for(Category c : Category.values()){
            animationForCategory.put(c, 0);
        }
    }

    public static void startScissors(int x, int y, int width, int height) {
        GL11.glPushMatrix();
        GL11.glEnable(GL11.GL_SCISSOR_TEST);
        ScaledResolution sr1 = new ScaledResolution();
        int factor = sr1.getScaleFactor();
        GL11.glScissor(x * factor, (sr1.getScaledHeight() - height) * factor, Math.abs((width - x) * factor), Math.abs((height - y) * factor));
    }

    public static void stopScissor() {
        GL11.glDisable(GL11.GL_SCISSOR_TEST);
        GL11.glPopMatrix();
    }
    public boolean isMainMenu = true;
    public int mainMenu;
    public int modMenu;
    public Category currentcategory;
    public Module currentmodule;
    public int longesmodname = 0;
    public ArrayList<Module> modsforcategory = new ArrayList<Module>();
    public float renderY;
    public float animationY;
    public float animationmodule;
    public float rendermodule;
    public float animation;
    public HashMap animationForCategory = new HashMap<Category,Integer>();
    public void upKey() {
        Category categories[] = Category.values();
        if (this.isMainMenu) {
            if (this.mainMenu > 0) {
                --this.mainMenu;
            } else {
                this.mainMenu = categories.length - 1 - 2;
            }
        } else {
            this.modMenu--;
        }
    }

    public void downKey() {
        Category categories[] = Category.values();
        if (this.isMainMenu) {
            if (this.mainMenu < categories.length - 1 - 2) {
                ++this.mainMenu;
            } else {
                this.mainMenu = 0;
            }
        } else {
            this.modMenu++;

        }
    }

    public void rightKey() {
        if (this.isMainMenu) {
            animation = 10f;
            this.isMainMenu = false;
            this.rendermodule= this.mainMenu *15+10;

        } else {
            if (this.currentcategory != null) {
                this.currentmodule.toggleModule();
            }
        }

    }

    public void leftKey() {
        this.isMainMenu = true;
        this.modMenu = 0;

    }

    public void returnKey() {
        if (this.isMainMenu) {
            this.isMainMenu = false;
        } else {
            this.currentmodule.toggleModule();
        }
    }

    public float getDiffrent(float f1, float f2){
        return (float)  Math.sqrt((f1-f2)*(f1-f2));
    }

    public void upDateAnimations(){
        if(Minecraft.getMinecraft().thePlayer == null){
            return;
        }
        for(Category c : Category.values()){
            int animation = (Integer) this.animationForCategory.get(c);
            if(this.currentcategory == c){
                if(animation < 10){
                    animation ++;
                }
            }else{
                if(animation > 0){
                    animation --;
                }
            }
            animationForCategory.put(c, animation);
        }
        if(this.renderY > this.animationY){
            float plusgleich = getDiffrent(animationY,renderY);
            renderY -=  plusgleich/6;
        }else{
            float plusgleich = getDiffrent(animationY,renderY);
            renderY +=  plusgleich/6f;
        }
        if(this.rendermodule > this.animationmodule){
            float plusgleich = getDiffrent(animationmodule,rendermodule);
            rendermodule -=  plusgleich/6;
        }else{
            float plusgleich = getDiffrent(animationmodule,rendermodule);
            rendermodule +=  plusgleich/6f;
        }
    }
    public void drawShadeRect(double x,double y, double x2,double y2){
        Gui.drawRect(x, y-1, x2+1,y2,
                new Color(0x6F6F6F).getRGB());
        Gui.drawRect(x-1, y, x2,y2+1,
                new Color(0x323232).getRGB());

        Gui.drawRect(x, y, x2,y2,
                new Color(0x505050).getRGB());
    }
    public void drawTabGui() {

        ScaledResolution sr = new ScaledResolution();
        if (this.isMainMenu) {
            longesmodname = 0;
        }
        Category categories[] = Category.values();

        int y = 0;


        Gui.drawRect(2, 9, 80, (categories.length - 3) * 15 + 24,
                new Color(0x505050).getRGB());




      //  Gui.drawRect(2, 10 + this.renderY, 80, 25 + this.renderY,  Main.getMain.getClientColor().getRGB() );
        //GuiApi.drawGradientRect(2, 10 + this.renderY-4, 80, 25 + this.renderY, 0, Integer.MIN_VALUE);



        for (int i = 0; i < categories.length - 2; ++i) {
            if (this.mainMenu == i) {
                this.animationY = y;
                currentcategory =categories[i];
                Gui.drawRect(3, y+1+ 13.5f-4.5, 79, y  + 14+ 13.5f-4.5,
                        new Color(0x3E3E3E).getRGB());
                Gui.drawRect(3, y+1+ 13.5f-4.5, 4, y  + 14+ 13.5f-4.5,
                        new Color(0x5E5E5E).getRGB());
                Gui.drawRect(3, y+1+ 13.5f-4.5, 79, y+1+ 13.5f-5.5,
                        new Color(0x5E5E5E).getRGB());

                Gui.drawRect(3, y  + 14+ 13.5f-3.5, 79, y  + 14+ 13.5f-4.5,
                        new Color(0x212121).getRGB());
                Gui.drawRect(78, y+1+ 13.5f-4.5, 79, y  + 14+ 13.5f-4.5,
                        new Color(0x212121).getRGB());
            }else{
                Gui.drawRect(3, y+1+ 13.5f-4.5, 79, y  + 14+ 13.5f-4.5,
                        new Color(0x3E3E3E).getRGB());
                Gui.drawRect(3, y+1+ 13.5f-4.5, 4, y  + 14+ 13.5f-4.5,
                        new Color(0x212121).getRGB());
                Gui.drawRect(3, y+1+ 13.5f-4.5, 79, y+1+ 13.5f-5.5,
                        new Color(0x212121).getRGB());

                Gui.drawRect(3, y  + 14+ 13.5f-3.5, 79, y  + 14+ 13.5f-4.5,
                        new Color(0x5E5E5E).getRGB());
                Gui.drawRect(78, y+1+ 13.5f-4.5, 79, y  + 14+ 13.5f-4.5,
                        new Color(0x5E5E5E).getRGB());
            }

            String s = String.valueOf(String.valueOf(categories[i].toString().substring(0, 1)))
                    + categories[i].toString().substring(1, categories[i].toString().length()).toLowerCase();
            String replace = s.replace(s.substring(1), "");

            Main.getMain.verdanas.drawCenteredStringWithShadow(s, 39, y + 13.5f-5,

                    this.mainMenu == i ? 0xffffffff : 0xff95a5a6);

            y += 15;

        }
        float newy = mainMenu*15;
        int x = 81;
        int size = 0;
        if (!this.modsforcategory.isEmpty()) {
            this.modsforcategory.clear();
        }
        if (!this.isMainMenu) {

            for (int i = 0; i < Main.getMain.moduleManager.getModules().size(); ++i) {
                Module mod = Main.getMain.moduleManager.getModules().get(i);
                if (mod != null) {

                    if (mod.category == this.currentcategory) {
                        this.modsforcategory.add(mod);

                    } else {

                    }
                }
            }

            for (int i = 0; i < this.modsforcategory.size(); ++i) {
                Module mod = modsforcategory.get(i);
                if (Minecraft.getMinecraft().fontRendererObj.getStringWidth(mod.name) > longesmodname) {
                    longesmodname = (int) ((int) Main.getMain.verdana.getWidth(mod.name)*1.1);

                }
            }
            //this.startScissors((int) ((int)x + 0.5), (int) ((int)newy), (int) ((int)x + 1 + longesmodname + 10), (int) ((int)newy+this.animation-1));
            if(this.animation+1 < 22 + this.modsforcategory.size() * 15 - 12+ newy+15){
                this.animation  *=1.2;
            }
          //  GuiApi.drawFineBorderedRect(x + 0.5, 10 + newy - 0.5, x + 1 + longesmodname + 10,
                  //  (int) (22 + this.modsforcategory.size() * 15 - 12+ newy), Color.black.getRGB(),
                 //   0xff2b2b2b);

            GL11.glTranslated(2,0,0);
            drawShadeRect(x + 0.5, 10 + newy - 0.5, x + 1 + longesmodname + 9.5,
                      (int) (22 + this.modsforcategory.size() * 15 - 12+ newy));
           // Gui.drawRect(x + 1, this.rendermodule, 0.5f + x + longesmodname + 10, this.rendermodule+15, Main.getMain.getClientColor().getRGB());
            for (int i = 0; i < this.modsforcategory.size(); ++i) {
                Module mod = modsforcategory.get(i);
                if (Main.getMain.verdana.getWidth(mod.name) > longesmodname) {
                    longesmodname = (int) Main.getMain.verdana.getWidth(mod.name);

                }
                double x1 = x+1;
                double y1 = newy+9;
                double x2 = x + this.longesmodname+10;
                double y2 = newy + 10+14;
                if (!(i == this.modMenu)) {


                        Gui.drawRect(x1, y1, x2, y2,
                                new Color(0x3E3E3E).getRGB());
                        Gui.drawRect(x1, y2, x2, y2 - 1,
                                new Color(0x5E5E5E).getRGB());
                        Gui.drawRect(x2, y1, x2 - 1, y2,
                                new Color(0x5E5E5E).getRGB());

                        Gui.drawRect(x1, y1, x2, y1 + 1,
                                new Color(0x212121).getRGB());
                        Gui.drawRect(x1+1, y1, x1 , y2,
                                new Color(0x212121).getRGB());


                } else {
                    Gui.drawRect(x1, y1, x2, y2,
                            new Color(0x3E3E3E).getRGB());
                    Gui.drawRect(x1, y2, x2, y2 - 1,
                            new Color(0x212121).getRGB());
                    Gui.drawRect(x2, y1, x2 - 1, y2,
                            new Color(0x212121).getRGB());

                    Gui.drawRect(x1, y1, x2, y1 + 1,
                            new Color(0x5E5E5E).getRGB());
                    Gui.drawRect(x1+1, y1, x1 , y2,
                            new Color(0x5E5E5E).getRGB());
                    this.animationmodule = 10 + newy;
                    //	Gui.drawRect(x + 1, 10 + newy, 0.5f + x + longesmodname + 10, 25 + newy, Main.getMain.getClientColor().getRGB());
                    //	Gui.drawRect(x + 1, this.rendermodule, 0.5f + x + longesmodname + 10, this.rendermodule+15, Main.getMain.getClientColor().getRGB());


                }
                Main.getMain.verdanas.drawCenteredStringWithShadow(mod.name, x+this.longesmodname/2+5,
                        newy + 15-7, (mod.getState()) ? 0xffffffff : 0xff95a5a6);
                newy += 15;
                ++size;
                if (i == this.modMenu) {
                    currentmodule = mod;
                }

            }
            GL11.glTranslated(-2,0,0);
            if (this.modMenu < 0) {
                this.modMenu = size - 1;
            }
            if (this.modMenu > size - 1) {
                this.modMenu = 0;
            }
            //	this.stopScissor();

        }
    }
}

minecraft_de_Client_Render_TTFChat.java

package de.Client.Render;

import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.ChatLine;
import net.minecraft.client.gui.GuiNewChat;
import net.minecraft.client.gui.GuiUtilRenderComponents;
import net.minecraft.client.gui.ScaledResolution;
import net.minecraft.client.renderer.GlStateManager;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.potion.Potion;
import net.minecraft.util.ChatComponentText;
import net.minecraft.util.IChatComponent;
import net.minecraft.util.MathHelper;

import java.util.Iterator;

public class TTFChat extends GuiNewChat {
    private int x, y, dragX, dragY;

    private NahrFontRenderer font;

    public TTFChat(Minecraft mcIn) {
        super(mcIn);
    }


    @Override
    public void resetScroll() {
        super.resetScroll();

        boolean dragging = false;
    }

    @Override
    public void drawChat(int p_146230_1_) {
 
        if (font == null) {
            font = new NahrFontRenderer("Verdana", 18);
        }
     
        if (this.mc.gameSettings.chatVisibility != EntityPlayer.EnumChatVisibility.HIDDEN) {
            int var2 = this.getLineCount();
            boolean var3 = false;
            int var4 = 0;
            int var5 = this.field_146253_i.size();
            float var6 = this.mc.gameSettings.chatOpacity * 0.9F + 0.1F;

            if (var5 > 0) {
                if (this.getChatOpen()) {
                    var3 = true;
                }

                float var7 = this.getChatScale();
                GlStateManager.pushMatrix();
                float yOffset = 20.0F;
                if (!mc.thePlayer.capabilities.isCreativeMode) {
                    yOffset = 6.0F;
                    if (mc.thePlayer.getTotalArmorValue() > 0)
                        yOffset -= 10;
                    if (mc.thePlayer.getActivePotionEffect(Potion.absorption) != null)
                        yOffset -= 10;
                }
                GlStateManager.translate(2.0F, yOffset, 0.0F);
                GlStateManager.scale(var7, var7, 1.0F);
                int var9;
                int var11;
                int var14;

                for (var9 = 0; var9 + this.scrollPos < this.field_146253_i.size() && var9 < var2; ++var9) {
                    ChatLine var10 = (ChatLine) this.field_146253_i.get(var9 + this.scrollPos);

                    if (var10 != null) {
                        var11 = p_146230_1_ - var10.getUpdatedCounter();

                        if (var11 < 200 || var3) {
                            ++var4;
                        }
                    }
                }

                GlStateManager.translate(0, -8, 0);
                int height = -1;
                if (!getChatOpen()) {
                    if (var4 > 0) {
                        height = -var4 * 9;
                    }
                } else if (getChatOpen()) {
                    height = -var2 * 9;
                    GuiApi.drawBorderedRect(0.0F + x, height - 8 + y, getChatWidth() + 3.0F + x, height + 4.5 + y, 0x60000000, 0x80000000);
                    font.drawString("Chat", 1 + x, height - 10 + y, NahrFontRenderer.FontType.NORMAL, 0xFFFFFFFF);
                }

                if (height != -1) {
                	GuiApi.drawBorderedRect(0.0F + x, height + 5 + y, getChatWidth() + 3.0F + x, 9.0F + y, 0x60000000, 0x80000000);
                }
                GlStateManager.translate(1, 8, 0);

                for (var9 = 0; var9 + this.scrollPos < this.field_146253_i.size() && var9 < var2; ++var9) {
                    ChatLine var10 = (ChatLine) this.field_146253_i.get(var9 + this.scrollPos);

                    if (var10 != null) {
                        var11 = p_146230_1_ - var10.getUpdatedCounter();

                        if (var11 < 200 || var3) {
                            double var12 = (double) var11 / 200.0D;
                            var12 = 1.0D - var12;
                            var12 *= 10.0D;
                            var12 = MathHelper.clamp_double(var12, 0.0D, 1.0D);
                            var12 *= var12;
                            var14 = (int) (255.0D * var12);

                            if (var3) {
                                var14 = 255;
                            }

                            var14 = (int) ((float) var14 * var6);

                            byte var15 = 0;
                            int var16 = -var9 * 9;
                            String var17 = var10.getChatComponent().getFormattedText().replace("�", ">");

                            GlStateManager.enableBlend();
                            font.drawString(var17, (float) var15 + x, (float) (var16 - 14) + y, NahrFontRenderer.FontType.SHADOW_THIN, 16777215 + (var14 << 24), (var14 << 24));
                            GlStateManager.disableAlpha();
                            GlStateManager.disableBlend();
                        }
                    }
                }

                if (var3) {
                    var9 = this.mc.fontRendererObj.FONT_HEIGHT;
                    GlStateManager.translate(-3.0F, 0.0F, 0.0F);
                    int var18 = var5 * var9 + var5;
                    var11 = var4 * var9 + var4;
                    int var19 = this.scrollPos * var11 / var5;
                    int var13 = var11 * var11 / var18;

                    if (var18 != var11) {
                        var14 = var19 > 0 ? 170 : 96;
                        int var20 = this.isScrolled ? 13382451 : 3355562;
                        drawRect(0, -var19, 2, -var19 - var13, var20 + (var14 << 24));
                        drawRect(2, -var19, 1, -var19 - var13, 13421772 + (var14 << 24));
                    }
                }

                GlStateManager.popMatrix();
            }
        }
    }

    @Override
    public IChatComponent getChatComponent(int p_146236_1_, int p_146236_2_) {
        if (!this.getChatOpen()) {
            return null;
        } else {
            ScaledResolution var3 = new ScaledResolution(this.mc, this.mc.displayWidth, this.mc.displayHeight);
            int var4 = var3.getScaleFactor();
            float var5 = this.getChatScale();
            int var6 = p_146236_1_ / var4 - 3;
            int var7 = p_146236_2_ / var4 - 27;
            var6 = MathHelper.floor_float((float) var6 / var5) + x;
            var7 = MathHelper.floor_float((float) var7 / var5) + y;

            if (var6 >= 0 && var7 >= 0) {
                int var8 = Math.min(this.getLineCount(), this.field_146253_i.size());

                if (var6 <= MathHelper.floor_float((float) this.getChatWidth() / this.getChatScale()) && var7 < this.mc.fontRendererObj.FONT_HEIGHT * var8 + var8) {
                    int yOffset = 0;
                    if (!mc.thePlayer.capabilities.isCreativeMode) {
                        yOffset = 2;
                        if (mc.thePlayer.getTotalArmorValue() > 0)
                            yOffset += 1;
                        if (mc.thePlayer.getActivePotionEffect(Potion.absorption) != null)
                            yOffset += 1;
                    }
                    int var9 = var7 / this.mc.fontRendererObj.FONT_HEIGHT + this.scrollPos - yOffset;

                    if (var9 >= 0 && var9 < this.field_146253_i.size()) {
                        ChatLine var10 = (ChatLine) this.field_146253_i.get(var9);
                        int var11 = 0;
                        Iterator var12 = var10.getChatComponent().iterator();

                        while (var12.hasNext()) {
                            IChatComponent var13 = (IChatComponent) var12.next();

                            if (var13 instanceof ChatComponentText) {
                                var11 += this.mc.fontRendererObj.getStringWidth(GuiUtilRenderComponents.func_178909_a(((ChatComponentText) var13).getChatComponentText_TextValue(), false));

                                if (var11 > var6) {
                                    return var13;
                                }
                            }
                        }
                    }

                    return null;
                } else {
                    return null;
                }
            } else {
                return null;
            }
        }
    }
}

minecraft_de_Client_Render_TTFManager.java

package de.Client.Render;

import net.minecraft.client.Minecraft;
import net.minecraft.util.StringUtils;
import org.lwjgl.opengl.GL11;
import org.newdawn.slick.UnicodeFont;
import org.newdawn.slick.font.effects.ColorEffect;

import java.awt.*;
import java.util.Random;


public class TTFManager
{
  private Minecraft mc = Minecraft.getMinecraft();
  private final UnicodeFont unicodeFont;
  private final int[] colorCodes = new int[32];
  public String fontName;
  private float kerning;
  
  public TTFManager(String fontName, int fontType, int size)
  {
    this(fontName, fontType, size, 0.0F);
  }
  
  public TTFManager(String fontName, int fontType, int size, float kerning)
  {
    this.fontName = fontName;

      this.unicodeFont = new UnicodeFont(new Font(fontName, fontType, size));
    this.kerning = kerning;
    
    this.unicodeFont.addAsciiGlyphs();
    this.unicodeFont.getEffects().add(new ColorEffect(java.awt.Color.WHITE));
    try
    {
      this.unicodeFont.loadGlyphs();
    }
    catch (Exception e)
    {
      e.printStackTrace();
    }
    for (int i = 0; i < 32; i++)
    {
      int shadow = (i >> 3 & 0x1) * 85;
      int red = (i >> 2 & 0x1) * 170 + shadow;
      int green = (i >> 1 & 0x1) * 170 + shadow;
      int blue = (i & 0x1) * 170 + shadow;
      if (i == 6) {
        red += 85;
      }
      if (i >= 16)
      {
        red /= 4;
        green /= 4;
        blue /= 4;
      }
      this.colorCodes[i] = ((red & 0xFF) << 16 | (green & 0xFF) << 8 | blue & 0xFF);
    }
  }



    public int drawGlitchString(String text, float x, float y, int color)
    {
        x *= 2.0F;
        y *= 2.0F;
        float originalX = x;

        GL11.glPushMatrix();
        GL11.glScaled(0.5D, 0.5D, 0.5D);

        boolean blend = GL11.glIsEnabled(3042);
        boolean lighting = GL11.glIsEnabled(2896);
        boolean texture = GL11.glIsEnabled(3553);
        if (!blend) {
            GL11.glEnable(3042);
        }
        if (lighting) {
            GL11.glDisable(2896);
        }
        if (texture) {
            GL11.glDisable(3553);
        }
        int currentColor = color;
        char[] characters = text.toCharArray();

        int index = 0;
        char[] arrayOfChar1;
        int j = (arrayOfChar1 = characters).length;
        for (int i = 0; i < j; i++)
        {
            int xo = 0;
            int yo = 0;
            if(new Random().nextInt(30) == 1){
                xo += new Random().nextInt(10)-5;
                yo += new Random().nextInt(10)-5;
            }
            if(new Random().nextInt(2000) == 1){
                xo += new Random().nextInt(50)-25;
                yo += new Random().nextInt(50)-25;
            }

            char c = arrayOfChar1[i];
            if (c == '\r') {
                x = originalX;
            }
            if (c == '\n') {
                y += getHeight(Character.toString(c)) * 2.0F;
            }
            if ((c != '§') && ((index == 0) || (index == characters.length - 1) || (characters[(index - 1)] != '§')))
            {
                if(new Random().nextInt(120) == 1){
                    c = '?';
                }

                if(new Random().nextInt(120) == 1){
                    this.unicodeFont.drawString(x+xo+5, y+yo+5, Character.toString(c), new org.newdawn.slick.Color(new Color(0xFF2835).getRGB()));
                    this.unicodeFont.drawString(x+xo-5, y+yo-5, Character.toString(c), new org.newdawn.slick.Color(new Color(0x169476).getRGB()));
                }
                this.unicodeFont.drawString(x+xo, y+yo, Character.toString(c), new org.newdawn.slick.Color(currentColor));
                x += getWidth(Character.toString(c)) * 2.0F;
            }
            else if (c == ' ')
            {
                x += this.unicodeFont.getSpaceWidth();
            }
            else if ((c == '§') && (index != characters.length - 1))
            {
                int codeIndex = "0123456789abcdefg".indexOf(text.charAt(index + 1));
                if (codeIndex < 0) {
                    continue;
                }
                currentColor = this.colorCodes[codeIndex];
            }
            index++;
        }
        GL11.glScaled(2.0D, 2.0D, 2.0D);
        if (texture) {
            GL11.glEnable(3553);
        }
        if (lighting) {
            GL11.glEnable(2896);
        }
        if (!blend) {
            GL11.glDisable(3042);
        }
        GL11.glPopMatrix();
        Minecraft.getMinecraft().fontRendererObj.drawString("", -88, -88, 0);
        return (int)x;
    }


    public int drawString(String text, float x, float y, int color)
  {
    x *= 2.0F;
    y *= 2.0F;
    float originalX = x;
    
    GL11.glPushMatrix();
    GL11.glScaled(0.5D, 0.5D, 0.5D);
    
    boolean blend = GL11.glIsEnabled(3042);
    boolean lighting = GL11.glIsEnabled(2896);
    boolean texture = GL11.glIsEnabled(3553);
    if (!blend) {
      GL11.glEnable(3042);
    }
    if (lighting) {
      GL11.glDisable(2896);
    }
    if (texture) {
      GL11.glDisable(3553);
    }
    int currentColor = color;
    char[] characters = text.toCharArray();
    
    int index = 0;
    char[] arrayOfChar1;
    int j = (arrayOfChar1 = characters).length;
    for (int i = 0; i < j; i++)
    {
      char c = arrayOfChar1[i];
      if (c == '\r') {
        x = originalX;
      }
      if (c == '\n') {
        y += getHeight(Character.toString(c)) * 2.0F;
      }
      if ((c != '§') && ((index == 0) || (index == characters.length - 1) || (characters[(index - 1)] != '§')))
      {
        this.unicodeFont.drawString(x, y, Character.toString(c), new org.newdawn.slick.Color(currentColor));
        x += getWidth(Character.toString(c)) * 2.0F;
      }
      else if (c == ' ')
      {
        x += this.unicodeFont.getSpaceWidth();
      }
      else if ((c == '§') && (index != characters.length - 1))
      {
        int codeIndex = "0123456789abcdefg".indexOf(text.charAt(index + 1));
        if (codeIndex < 0) {
          continue;
        }
          currentColor = this.colorCodes[codeIndex];
      }
      index++;
    }
    GL11.glScaled(2.0D, 2.0D, 2.0D);
    if (texture) {
      GL11.glEnable(3553);
    }
    if (lighting) {
      GL11.glEnable(2896);
    }
    if (!blend) {
      GL11.glDisable(3042);
    }
    GL11.glPopMatrix();
    Minecraft.getMinecraft().fontRendererObj.drawString("", -88, -88, 0);
    return (int)x;
  }
  
  public int drawStringWithShadow(String text, float x, float y, int color)
  {
    drawString(StringUtils.stripControlCodes(text), x + 0.5F, y + 0.5F, 0);
    return drawString(text, x, y, color);
  }
  
  public int drawfixedStringWithShadow(String text, float x, float y, int color)
  {
    drawString(StringUtils.stripControlCodes(text), x + 0.5F, y + 0.5F, 0);
    Minecraft.getMinecraft().fontRendererObj.drawString("f", -88, -878, 4);
    return drawString(text, x, y, color);
  }
  
  public void drawCenteredString(String text, float x, float y, int color)
  {
    drawString(text, x - (int)getWidth(text) / 2, y, color);
  }
  
  public void drawCenteredStringWithShadow(String text, float x, float y, int color)
  {
    drawCenteredString(StringUtils.stripControlCodes(text), x + 0.5F, y + 0.5F, 0);
    
    drawCenteredString(text, x, y, color);
  }
  
  public float getWidth(String s)
  {
    float width = 0.0F;
    
    String str = StringUtils.stripControlCodes(s);
    char[] arrayOfChar;
    int j = (arrayOfChar = str.toCharArray()).length;
    for (int i = 0; i < j; i++)
    {
      char c = arrayOfChar[i];
      width += this.unicodeFont.getWidth(Character.toString(c)) + this.kerning;
    }
    return width / 2.0F;
  }
  
  public float getCharWidth(char c)
  {
    return this.unicodeFont.getWidth(String.valueOf(c));
  }
  
  public float getHeight(String s)
  {
    return this.unicodeFont.getHeight(s) / 2.0F;
  }
  
  public UnicodeFont getFont()
  {
    return this.unicodeFont;
  }
  
  public String trimStringToWidth(String par1Str, int par2)
  {
    StringBuilder var4 = new StringBuilder();
    float var5 = 0.0F;
    int var6 = 0;
    int var7 = 1;
    boolean var8 = false;
    boolean var9 = false;
    for (int var10 = var6; (var10 >= 0) && (var10 < par1Str.length()) && (var5 < par2); var10 += var7)
    {
      char var11 = par1Str.charAt(var10);
      float var12 = getCharWidth(var11);
      if (var8)
      {
        var8 = false;
        if ((var11 != 'l') && (var11 != 'L'))
        {
          if ((var11 == 'r') || (var11 == 'R')) {
            var9 = false;
          }
        }
        else {
          var9 = true;
        }
      }
      else if (var12 < 0.0F)
      {
        var8 = true;
      }
      else
      {
        var5 += var12;
        if (var9) {
          var5 += 1.0F;
        }
      }
      if (var5 > par2) {
        break;
      }
      var4.append(var11);
    }
    return var4.toString();
  }
}

minecraft_de_Client_Render_Watermarks_WatermarkC.java

package de.Client.Render.Watermarks;

import de.Client.Main.Main;
import de.Client.Utils.ColorUtil;
import de.Client.Utils.Watermark;
import net.minecraft.client.Minecraft;
import org.lwjgl.opengl.GL11;

import java.awt.*;

/**
 * Created by Daniel on 13.07.2017.
 */
public class WatermarkC extends Watermark{
    @Override
    public void drawWaterMark(double scaledX, double scaledY){
        GL11.glScaled(1.2,1.2,1.2);
        Minecraft.getMinecraft().fontRendererObj.drawStringWithShadow("§oNight 1.0",2,1, ColorUtil.transparency(new Color(0x848484),0.8));
        GL11.glScaled(1/1.2,1/1.2,1/1.2);
    }
    @Override
    public double getHeight(){
        return 10;
    }

}

minecraft_de_Client_Render_Watermarks_WatermarkD.java

package de.Client.Render.Watermarks;

import de.Client.Main.Main;
import de.Client.Utils.Watermark;

/**
 * Created by Daniel on 13.07.2017.
 */
public class WatermarkD extends Watermark{
    @Override
    public void drawWaterMark(double scaledX, double scaledY){
        Main.getMain.watermark.drawfixedStringWithShadow("nigHT", 4, 0, Main.getMain.getClientColor().getRGB());
    }
    @Override
    public double getHeight(){
        return 27;
    }

}

minecraft_de_Client_Render_Watermarks_WatermarkS.java

package de.Client.Render.Watermarks;

import de.Client.Main.Main;
import de.Client.Utils.Watermark;
import net.minecraft.client.Minecraft;
import org.lwjgl.opengl.GL11;

import java.awt.*;

/**
 * Created by Daniel on 13.07.2017.
 */
public class WatermarkS extends Watermark{
    @Override
    public void drawWaterMark(double scaledX, double scaledY){
        Minecraft mc = Minecraft.getMinecraft();
        GL11.glScaled(2,2,2);
        mc.fontRendererObj.drawStringWithShadow("N",1,1,Main.getMain.getClientColor().getRGB());
        GL11.glScaled(0.5,0.5,0.5);
        mc.fontRendererObj.drawStringWithShadow("v2",15,2,new Color(0x8B8B8B).getRGB());
        mc.fontRendererObj.drawStringWithShadow("ight",15,10,Main.getMain.getClientColor().getRGB());
    }
    @Override
    public double getHeight(){
        return 18;
    }

}

minecraft_de_Client_Render_Watermarks_WatermarkSky.java

package de.Client.Render.Watermarks;

import de.Client.Main.Main;
import de.Client.Render.TTFManager;
import de.Client.Utils.ColorUtil;
import de.Client.Utils.Watermark;
import net.minecraft.client.Minecraft;
import org.lwjgl.opengl.GL11;

import java.awt.*;

/**
 * Created by Daniel on 14.08.2017.
 */

public class WatermarkSky extends Watermark {
    TTFManager elFont = new TTFManager("el&font gohtic!", Font.PLAIN,37);
    @Override
    public void drawWaterMark(double scaledX, double scaledY){

        elFont.drawCenteredStringWithShadow("(       )", (float) (scaledX/2),5,new Color(0x3B3C3F).getRGB());
        elFont.drawCenteredStringWithShadow(" niGHt", (float) (scaledX/2),5, Main.getMain.getClientColor().getRGB());
    }
    @Override
    public double getHeight(){
        return 0;
    }

}

minecraft_de_Client_Utils_AccountLoginThread.java

package de.Client.Utils;

import com.mojang.authlib.Agent;
import com.mojang.authlib.exceptions.AuthenticationException;
import com.mojang.authlib.yggdrasil.YggdrasilAuthenticationService;
import com.mojang.authlib.yggdrasil.YggdrasilUserAuthentication;
import de.Client.Main.Screens.AltManager;
import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.GuiMainMenu;
import net.minecraft.client.gui.GuiScreen;
import net.minecraft.util.Session;

import java.io.IOException;
import java.net.Proxy;

public class AccountLoginThread extends Thread {

	private final Minecraft mc = Minecraft.getMinecraft();
	private final String password;
	private String status;
	private final String username;
	public String logUsername = "";
    public Alt alt = null;

	public AccountLoginThread(String username, String password) {
		super("Alt Login Thread");
		this.username = username;
		this.password = password;
		this.setStatus( "§7Waiting");
	}
    public AccountLoginThread(String username, String password,Alt alt) {
        super("Alt Login Thread");
        this.username = username;
        this.password = password;
        this.alt = alt;
        this.setStatus( "§7Waiting");
    }

	private final Session createSession(String username, String password) {
		YggdrasilAuthenticationService service = new YggdrasilAuthenticationService(Proxy.NO_PROXY, "");
		YggdrasilUserAuthentication auth = (YggdrasilUserAuthentication) service
				.createUserAuthentication(Agent.MINECRAFT);
		auth.setUsername(username);
		auth.setPassword(password);
		try {
			auth.logIn();
			return new Session(auth.getSelectedProfile().getName(), auth.getSelectedProfile().getId().toString(),
					auth.getAuthenticatedToken(), "mojang");
		} catch (AuthenticationException ignored) {
		}
		return null;
	}

	public String getStatus() {
		return this.status;
	}
	
	public void run() {
		if (this.username.equals("")) {
			this.setStatus( "§cUsername/E-Mail wurde nicht gefunden");
            return;
		}
		if (this.password.equals("")) {
			this.mc.session = new Session(this.username, "", "", "mojang");
			this.setStatus( "§aEingeloggt in§8: §7" + this.username + " §§8 - §aOffline Modus");
			return;
		}
		this.setStatus( "§eLogging in...");
		Session auth = createSession(this.username, this.password);
		if (auth == null) {
			this.setStatus( "§cEinloggen Fehlgeschlagen");
			if(alt != null) {
                alt.name = "§4NOT WORKING ANYMORE";
            }
		} else {
            this.setStatus( "§aEingeloggt in§8: §7" + auth.getUsername());
            this.logUsername = auth.getUsername();
            this.mc.session = auth;
            if(alt != null){
                if(!alt.name.startsWith("§c")){
                    if(alt.name != mc.session.getUsername()){
                        this.setStatus( "§aEingeloggt in§8: §6" + auth.getUsername() +" | " + alt.name + "Changed his name to" + mc.session.getUsername());
                    }
                }
                alt.name = mc.session.getUsername();

            }
        }
	}

	public String getUsername() {
		return this.logUsername;
	}
	
	public void setStatus(String status) {
		this.status =status;
		AltManager.time.reset();
	}
}

minecraft_de_Client_Utils_Alt.java

package de.Client.Utils;

import de.Client.Main.Screens.AltManager;
import de.Client.Render.GuiApi;
import net.minecraft.client.Minecraft;
import net.minecraft.client.entity.AbstractClientPlayer;
import net.minecraft.client.gui.FontRenderer;
import net.minecraft.client.gui.Gui;
import net.minecraft.client.gui.ScaledResolution;
import org.lwjgl.input.Mouse;
import org.lwjgl.opengl.GL11;

import java.awt.*;

public class Alt {

	private String email;
	private String password;
	public static int scrollpos;
	public int id;
    public boolean selected;
    
    public Minecraft mc = Minecraft.getMinecraft();
    public FontRenderer fr = Minecraft.getMinecraft().fontRendererObj;
    public String name = "§cUnknown";
	public Alt(String email ,String password ,int id){
		this.email = email;
		this.password = password;
		this.id = id;
	}
    public Alt(String email ,String password ,String name,int id){
        this.email = email;
        this.password = password;
        this.id = id;
        this.name = name;
    }
	public String getPassword(){
		return password;
	}
	public String getEmail(){
		return email;
	}
    public String getPasswordCencored(){
    	return password.replaceAll(".", "*");
    }
    public boolean isSelected(){
    	return selected;
    }
    public void unSelectAll(){
    for(Alt alt : AltManager.AltListArray){
    	if(alt != this){
    		alt.selected = false;
    	}
    }
    }
    public void onMouse(int mouseX, int mouseY){
    	
    	ScaledResolution sr = new ScaledResolution(mc,mc.displayWidth,mc.displayHeight);
    	if(mouse(mouseX,mouseY, sr.getScaledWidth()/2-180, scrollpos+ (id*42), sr.getScaledWidth()/2+180, 40+scrollpos + (id*42)) && Mouse.isButtonDown(0)){
    	    float y = 40+scrollpos + (id*42);
    		if(y < sr.getScaledHeight()-25){
                unSelectAll();
    	        this.selected =!this.selected ;
    		}
    	}
    }
    public static void drawAltFace(String name, int x, int y, int w, int h, boolean selected) {
        try {
            AbstractClientPlayer.getDownloadImageSkin(AbstractClientPlayer.getLocationSkin(name), name)
                    .loadTexture(Minecraft.getMinecraft().getResourceManager());
            Minecraft.getMinecraft().getTextureManager().bindTexture(AbstractClientPlayer.getLocationSkin(name));
            GL11.glEnable(3042);
            if (selected) {
                GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
            } else {
                GL11.glColor4f(2F, 2F, 2F, 1.0F);
            }
            float fw = 192.0F;
            float fh = 192.0F;
            float u = 24.0F;
            float v = 24.0F;
            Gui.drawModalRectWithCustomSizedTexture(x, y, u, v, w, h, fw, fh);

            fw = 192.0F;
            fh = 192.0F;
            u = 120.0F;
            v = 24.0F;
            Gui.drawModalRectWithCustomSizedTexture(x, y, u, v, w, h, fw, fh);
            GL11.glDisable(3042);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public void drawAltEntry(int mouseX, int mouseY){

        if(scrollpos > 20){
            scrollpos =20;
        }
        if(scrollpos < -AltManager.AltListArray.size() * 42+ mc.displayHeight/2-70){
            scrollpos = -AltManager.AltListArray.size() * 42 + mc.displayHeight/2-70;
        }
    	ScaledResolution sr = new ScaledResolution(mc,mc.displayWidth,mc.displayHeight);
        if(40+scrollpos + (id*42) > sr.getScaledHeight()){
            return;
        }
        if(scrollpos + (id*42) + 40  < 0){
            return;
        }
    	GuiApi.drawBorderedRect(sr.getScaledWidth()/2-180, scrollpos + (id * 42), sr.getScaledWidth()/2+180, 40+scrollpos + (id*42),ColorUtil.transparency(Color.black, 0.5),ColorUtil.transparency(Color.black, 0.3));
    	Gui.drawCenteredString(fr, this.email, sr.getScaledWidth()/2, scrollpos + (id * 42) + 5, Color.gray.getRGB());
    	Gui.drawCenteredString(fr, this.getPasswordCencored(), sr.getScaledWidth()/2, scrollpos + (id * 42) + 15, Color.gray.darker().getRGB());
    	if(!name.startsWith("§4")) {
            Gui.drawCenteredString(fr, "name : §e" + this.name, sr.getScaledWidth() / 2, scrollpos + (id * 42) + 30, Color.white.darker().getRGB());
        }else{
            Gui.drawCenteredString(fr, "Most likely doesnt work" , sr.getScaledWidth() / 2, scrollpos + (id * 42) + 30, Color.red.darker().getRGB());
        }
    	if(this.selected){
        
    	GuiApi.drawBorderedRect(sr.getScaledWidth()/2-180, scrollpos + (id * 42), sr.getScaledWidth()/2+180, 40+scrollpos + (id*42),ColorUtil.transparency(Color.black, 0.5),ColorUtil.transparency(Color.white, 0.5));
        Gui.drawCenteredString(fr, "§f" + this.email, sr.getScaledWidth()/2, scrollpos + (id * 42) + 5, Color.white.getRGB());
        Gui.drawCenteredString(fr, this.getPasswordCencored(), sr.getScaledWidth()/2, scrollpos + (id * 42) + 15, Color.white.darker().getRGB());
            if(!name.startsWith("§4")) {
                Gui.drawCenteredString(fr, "name : §e" + this.name, sr.getScaledWidth() / 2, scrollpos + (id * 42) + 30, Color.white.darker().getRGB());
            }else{
                Gui.drawCenteredString(fr, "Most likely doesnt work" , sr.getScaledWidth() / 2, scrollpos + (id * 42) + 30, Color.red.darker().getRGB());
            }
    	}
        if(!name.startsWith("§")) {
            double scale = 1.34;
            GL11.glScaled(scale,scale,scale);
            this.drawAltFace(name, (int) ((sr.getScaledWidth()/2-175)/scale), (int) ((scrollpos + (id * 42)+4.8)/scale),24,24,this.isSelected());
            GL11.glScaled(1/scale,1/scale,1);
        }
    }
	public void login(){
		AltManager.thread = new AccountLoginThread(email, password,this);
		AltManager.thread.start();
	}
	private boolean mouse(int mouseX, int mouseY, int minX, int minY, int maxX, int maxY) {
        return (mouseX >= minX && mouseX <= maxX) && (mouseY >= minY && mouseY <= maxY);
    }
}

minecraft_de_Client_Utils_ArrayList.java

package de.Client.Utils;

/**
 * Created by Daniel on 13.07.2017.
 */
public class ArrayList {
    public ArrayList(){

    }
    public void draw(double scaledX, double scaledY){

    }
}

minecraft_de_Client_Utils_ChatColorUtils.java

package de.Client.Utils;

import com.google.common.collect.Maps;
import org.apache.commons.lang3.Validate;

import java.util.Map;
import java.util.regex.Pattern;

public enum ChatColorUtils {
	
	BLACK('0', 0), 
	DARK_BLUE('1', 1), 
	DARK_GREEN('2', 2), 
	DARK_AQUA('3', 3), 
	DARK_RED('4', 4), 
	DARK_PURPLE('5', 5), 
	GOLD('6', 6), 
	GRAY('7', 7), 
	DARK_GRAY('8', 8), 
	BLUE('9', 9), 
	GREEN('a', 10), 
	AQUA('b', 11), 
	RED('c', 12), 
	LIGHT_PURPLE('d', 13), 
	YELLOW('e', 14), 
	WHITE('f', 15), 
	MAGIC('k', 16, true), 
	BOLD('l', 17, true), 
	STRIKETHROUGH('m', 18, true), 
	UNDERLINE('n', 19, true), 
	ITALIC('o', 20, true), 
	RESET('r', 21);

	public static final char COLOR_CHAR = '�';
	private static final Pattern STRIP_COLOR_PATTERN;
	private final int intCode;
	private final char code;
	private final boolean isFormat;
	private final String toString;
	private static final Map<Integer, ChatColorUtils> BY_ID;
	private static final Map<Character, ChatColorUtils> BY_CHAR;

	ChatColorUtils(char code, int intCode) {
		this(code, intCode, false);
	}

	ChatColorUtils(char code, int intCode, boolean isFormat) {
		this.code = code;
		this.intCode = intCode;
		this.isFormat = isFormat;
		this.toString = new String(new char[] { '§', code });
	}

	public char getChar() {
		return this.code;
	}

	public String toString() {
		return this.toString;
	}

	public boolean isFormat() {
		return this.isFormat;
	}

	public boolean isColor() {
		return (!this.isFormat) && (this != RESET);
	}

	public static ChatColorUtils getByChar(char code) {
		return (ChatColorUtils) BY_CHAR.get(Character.valueOf(code));
	}

	public static ChatColorUtils getByChar(String code) {
		Validate.notNull(code, "Code cannot be null", new Object[0]);
		Validate.isTrue(code.length() > 0, "Code must have at least one char", new Object[0]);
		return (ChatColorUtils) BY_CHAR.get(Character.valueOf(code.charAt(0)));
	}

	public static String stripColor(String input) {
		if (input == null) {
			return null;
		}
		return STRIP_COLOR_PATTERN.matcher(input).replaceAll("");
	}

	public static String translateAlternateColorCodes(char altColorChar, String textToTranslate) {
		char[] b = textToTranslate.toCharArray();
		for (int i = 0; i < b.length - 1; i++) {
			if ((b[i] == altColorChar) && ("0123456789AaBbCcDdEeFfKkLlMmNnOoRr".indexOf(b[(i + 1)]) > -1)) {
				b[i] = '?';
				b[(i + 1)] = Character.toLowerCase(b[(i + 1)]);
			}
		}
		return new String(b);
	}

	public static String getLastColors(String input) {
		String result = "";
		int length = input.length();
		for (int index = length - 1; index > -1; index--) {
			char section = input.charAt(index);
			if ((section == '§') && (index < length - 1)) {
				char c = input.charAt(index + 1);
				ChatColorUtils color = getByChar(c);
				if (color != null) {
					result = color.toString() + result;
					if ((color.isColor()) || (color.equals(RESET))) {
						break;
					}
				}
			}
		}
		return result;
	}

	static {
		STRIP_COLOR_PATTERN = Pattern.compile("(§i)" + String.valueOf('§') + "[0-9A-FK-OR]");

		BY_ID = Maps.newHashMap();
		BY_CHAR = Maps.newHashMap();
		ChatColorUtils[] arrayOfChatColor;
		int j = (arrayOfChatColor = values()).length;
		for (int i = 0; i < j; i++) {
			ChatColorUtils color = arrayOfChatColor[i];
			BY_ID.put(Integer.valueOf(color.intCode), color);
			BY_CHAR.put(Character.valueOf(color.code), color);
		}
	}
}

minecraft_de_Client_Utils_ClientUpdateThread.java

package de.Client.Utils;

import de.Client.Main.Main;

/**
 * Created by Daniel on 27.07.2017.
 */
public class ClientUpdateThread {
    public void run(){
        new Thread(){
            @Override
            public void run(){
                while(true){

                    if(Main.getMain.ircManager.newMessages()) {

                        for(IRCChatLine ircChat : Main.getMain.ircManager.getUnreadLines()) {
                            Main.getMain.cmdManager.handleReceiveIRC(ircChat);
                            ircChat.setRead(true);

                        }
                    }
                    try{
                        sleep(500);
                    }catch (Exception e){

                    }
                }
            }
        }.start();
    }

}

minecraft_de_Client_Utils_ColorUtil.java

package de.Client.Utils;

import de.Client.Main.Values.ValueBoolean;
import de.Client.Main.Values.ValueDouble;
import net.minecraft.client.Minecraft;
import net.minecraft.entity.Entity;
import org.lwjgl.opengl.GL11;

import java.awt.*;
import java.util.HashMap;
import java.util.Map;

public class ColorUtil {

	public static Map<String, ChatColorUtils> colors = new HashMap();

	public static int transparency(Color c, double alpha) {
		float r = 0.003921569F * c.getRed();
		float g = 0.003921569F * c.getGreen();
		float b = 0.003921569F * c.getBlue();
		return new Color(r, g, b, (float) alpha).getRGB();
	}

	public static Color rainbow(double offset, float fade) {
		float hue = (float) (System.nanoTime() *fade+( offset*System.currentTimeMillis()))  / 1.0E10F % 1.0F;
		long color = Long.parseLong(Integer.toHexString(Integer.valueOf(Color.HSBtoRGB(hue, 1.0F, 1.0F)).intValue()),
				16);
		Color c = new Color((int) color);
		return new Color(c.getRed() / 255.0F, c.getGreen() / 255.0F, c.getBlue() / 255.0F,
				c.getAlpha() / 255.0F);
	}
	public static Color rainbow2(double offset, float fade) {
		float hue = (float) (System.nanoTime() *fade+( offset)) / 1.0E10F % 1.0F;
		long color = Long.parseLong(Integer.toHexString(Integer.valueOf(Color.HSBtoRGB(hue, 1.0F, 1.0F)).intValue()),
				16);
		Color c = new Color((int) color);
		return new Color(c.getRed() / 255.0F, c.getGreen() / 255.0F, c.getBlue() / 255.0F,
				c.getAlpha() / 255.0F);
	}

	public static float fade(long offset, float fade) {
		float hue = (float) (System.nanoTime() + offset) / 1.0E10F % 1.0F;
		long color = Long.parseLong(Integer.toHexString(Integer.valueOf(Color.HSBtoRGB(hue, 1.0F, 1.0F)).intValue()), 16);
		Color c = new Color((int) color);
		return c.getAlpha() / 255.0F;
	}

	public static float[] getRGBA(int color) {
		float a = (color >> 24 & 0xFF) / 255.0F;
		float r = (color >> 16 & 0xFF) / 255.0F;
		float g = (color >> 8 & 0xFF) / 255.0F;
		float b = (color & 0xFF) / 255.0F;
		return new float[] { r, g, b, a };
	}

	public static int intFromHex(String hex) {
		try {
			if (hex.equalsIgnoreCase("rainbow")) {
				return rainbow(0L, 1.0F).getRGB();
			}
			return Integer.parseInt(hex, 16);
		} catch (NumberFormatException ignored) {
		}
		return -1;
	}




    public static Color getTeamColor(Entity entity) {
	    if(FriendManager.friends.containsKey(entity.getName())){
            return new Color(0.101960786f, 0.7372549f, 0.6117647f, 0.0f);
        }
        if (!entity.isInvisible() && entity != Minecraft.getMinecraft().thePlayer) {
            String display = entity.getDisplayName().getFormattedText();
                // Dark Blue
                if (display.startsWith("§1")) {
                    return new Color(0.0F, 0.2F, 1.0F, 1.0F);
                } else
                    // Blue
                    if (display.startsWith("§2")) {
                        return new Color(0.05F, 1.0F, 0.1F, 1.0F); // JA
                    } else
                        //  Cyan
                        if (display.startsWith("§3") || display.startsWith("§b")) {
                            return new Color(0.0F, 0.8F, 1.0F, 1.0F);
                        } else
                            // Dark Red
                            if (display.startsWith("§4")) {
                                return new Color(0.8F, 0.0F, 0.0F, 0.0f);
                            } else
                                // Red
                                if (display.startsWith("§c")) {
                                    return new Color(1.0F, 0.0F, 0.0F, 1.0F);
                                } else
                                    // Yellow
                                    if (display.startsWith("§e")) {
                                        return new Color(1.0F, 1.0F, 0.0F, 1.0F);
                                    } else
                                        // Orange
                                        if (display.startsWith("§6")) {
                                            return new Color(1.0F, 0.5529412f, 0.02745098f, 0.0f);
                                        } else
                                            // Dark Green
                                            if (display.startsWith("§2")) {
                                                return new Color(0.0F, 0.0F, 1.0F, 1.0F);
                                            } else
                                                // Green
                                                if (display.startsWith("§a")) {
                                                    return new Color(0.1F, 0.8F, 0.0F, 1.0F);
                                                } else
                                                    // Dark Purple
                                                    if (display.startsWith("§5")) {
                                                        return new Color(0.5F, 0.0F, 0.5F, 1.0F);
                                                    } else
                                                        // Pink
                                                        if (display.startsWith("§d")) {
                                                            return new Color(1.0F, 0.0F, 1.0F, 1.0F);
                                                        } else
                                                            // White
                                                            if (display.startsWith("§f")) {
                                                                return new Color(1.0F, 1.0F, 1.0F, 1.0F);
                                                            } else
                                                                // Grey
                                                                if (display.startsWith("§7")) {
                                                                    return new Color(0.5F, 0.5F, 0.5F, 1.0F);
                                                                } else
                                                                    // Dark Grey
                                                                    if (display.startsWith("§8")) {
                                                                        return new Color(0.3F, 0.3F, 0.3F, 1.0F);
                                                                    } else
                                                                        // Blue
                                                                        if (display.startsWith("§9")) {
                                                                            return new Color(0.0F, 0.1F, 1.0F, 1.0F);
                                                                        } else
                                                                            // Black
                                                                            if (display.startsWith("§0")) {
                                                                                return new Color(0.0F, 0.0F, 0.0F, 1.0F);
                                                                            } else {
                                                                                return new Color(1.0F, 1.0F, 1.0F, 1.0F);
                                                                            }
          
        }

        return new Color(1,1,1);
    }
    public static String hexFromInt(int color) {
		return hexFromInt(new Color(color));
	}

	public static String hexFromInt(Color color) {
		return Integer.toHexString(color.getRGB()).substring(2);
	}

	public static Color blend(Color color1, Color color2) {
		return blend(color1, color2);
	}

	public static Color darker(Color color, double fraction) {
		int red = (int) Math.round(color.getRed() * (1.0D - fraction));
		int green = (int) Math.round(color.getGreen() * (1.0D - fraction));
		int blue = (int) Math.round(color.getBlue() * (1.0D - fraction));
		if (red < 0) {
			red = 0;
		} else if (red > 255) {
			red = 255;
		}
		if (green < 0) {
			green = 0;
		} else if (green > 255) {
			green = 255;
		}
		if (blue < 0) {
			blue = 0;
		} else if (blue > 255) {
			blue = 255;
		}
		int alpha = color.getAlpha();

		return new Color(red, green, blue, alpha);
	}

	public static Color lighter(Color color, double fraction) {
		int red = (int) Math.round(color.getRed() * (1.0D + fraction));
		int green = (int) Math.round(color.getGreen() * (1.0D + fraction));
		int blue = (int) Math.round(color.getBlue() * (1.0D + fraction));
		if (red < 0) {
			red = 0;
		} else if (red > 255) {
			red = 255;
		}
		if (green < 0) {
			green = 0;
		} else if (green > 255) {
			green = 255;
		}
		if (blue < 0) {
			blue = 0;
		} else if (blue > 255) {
			blue = 255;
		}
		int alpha = color.getAlpha();

		return new Color(red, green, blue, alpha);
	}

	public static String getHexName(Color color) {
		int r = color.getRed();
		int g = color.getGreen();
		int b = color.getBlue();

		String rHex = Integer.toString(r, 16);
		String gHex = Integer.toString(g, 16);
		String bHex = Integer.toString(b, 16);

		return (rHex.length() == 2 ? rHex : "0" + rHex)
				+ (gHex.length() == 2 ? gHex : "0" + gHex)
				+ (bHex.length() == 2 ? bHex : "0" + bHex);
	}

	public static double colorDistance(double r1, double g1, double b1, double r2, double g2, double b2) {
		double a = r2 - r1;
		double b = g2 - g1;
		double c = b2 - b1;

		return Math.sqrt(a + b + c * c);
	}

	public static double colorDistance(double[] color1, double[] color2) {
		return colorDistance(color1[0], color1[1], color1[2], color2[0], color2[1], color2[2]);
	}

	public static double colorDistance(Color color1, Color color2) {
		float[] rgb1 = new float[3];
		float[] rgb2 = new float[3];

		color1.getColorComponents(rgb1);
		color2.getColorComponents(rgb2);

		return colorDistance(rgb1[0], rgb1[1], rgb1[2], rgb2[0], rgb2[1], rgb2[2]);
	}

	public static boolean isDark(double r, double g, double b) {
		double dWhite = colorDistance(r, g, b, 1.0D, 1.0D, 1.0D);
		double dBlack = colorDistance(r, g, b, 0.0D, 0.0D, 0.0D);

		return dBlack < dWhite;
	}

	public static boolean isDark(Color color) {
		float r = color.getRed() / 255.0F;
		float g = color.getGreen() / 255.0F;
		float b = color.getBlue() / 255.0F;

		return isDark(r, g, b);
	}

	public static void setColor(Color c) {
		GL11.glColor4f(c.getRed() / 255.0F, c.getGreen() / 255.0F, c.getBlue() / 255.0F, c.getAlpha() / 255.0F);
	}
}

minecraft_de_Client_Utils_ControllerAPI.java

package de.Client.Utils;

import org.lwjgl.LWJGLException;
import org.lwjgl.input.Controller;
import org.lwjgl.input.Controllers;
import org.newdawn.slick.command.Control;

public class ControllerAPI {
    public Controller gameController;
    public void init(){
        try {
            Controllers.create();
        } catch (LWJGLException e) {
            e.printStackTrace();
        }
        Controllers.poll();
        for(int i = 0; i < Controllers.getControllerCount(); ++i){
            System.out.println("FOUND CONTROLLER" + Controllers.getController(i).getName());
                gameController = Controllers.getController(i);

    }


    }
}

minecraft_de_Client_Utils_DarkButton.java

package de.Client.Utils;

import de.Client.Main.Main;
import de.Client.Render.GuiApi;
import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.GuiButton;
import net.minecraft.client.gui.ScaledResolution;
import org.lwjgl.opengl.GL11;

import java.awt.*;

public class DarkButton
  extends GuiButton
{
  private int x;
  private int y;
  private int x1;
  private int y1;
  private String text;
  double alphaInc = 0;
  int alpha = 0;
  float size = 0;

  
  public DarkButton(int buttondid, int x, int y, int x1, int y1, String text)
  {
    super(buttondid, x, y, x1, y1, text);
    this.x = x;
    this.y = y;
    this.x1 = x1;
    this.y1 = y1;
    this.text = text;
  }
    public void startScissors(int x, int y, int width, int height) {
        GL11.glPushMatrix();
        GL11.glEnable(GL11.GL_SCISSOR_TEST);
        ScaledResolution sr1 = new ScaledResolution();
        int factor = sr1.getScaleFactor();

        GL11.glScissor(x * factor, (sr1.getScaledHeight() - height) * factor, Math.abs((width - x) * factor), Math.abs((height - y) * factor));
    }

    public void stopScissor() {
        GL11.glDisable(GL11.GL_SCISSOR_TEST);
        GL11.glPopMatrix();
    }
  public void drawCircleRect(){}
  
  public DarkButton(int buttonid, int x, int y, String stringParams)
  {
    this(buttonid, x, y, 200, 20, stringParams);
  }
  
  public void drawButton(Minecraft mc, int mouseX, int mouseY)
  {
    boolean isOverButton = (mouseX >= this.x) && (mouseX <= this.x + this.x1) && (mouseY >= this.y) && (mouseY <= this.y + this.y1);
      drawRect(this.x-1, this.y +1, this.x + this.x1 -1, this.y + this.y1+1 , ColorUtil.lighter(new Color(0x32333A),0).getRGB());
      drawRect(this.x, this.y , this.x + this.x1 , this.y + this.y1 , ColorUtil.darker(new Color(0xA0A4B4),alphaInc).getRGB());
        if(isOverButton){
            if(alphaInc <0.5){
                alphaInc+=0.05;
            }
            if(size < 2){
                size ++;
            }else{
                size *= 1.3;
            }

            if(size > x1/2+3){
                size = x1/2+3;
            }
        }else{
            if(alphaInc > 0){
                alphaInc -= 0.1;
            }
            if(alphaInc < 0){
                alphaInc = 0;
            }
            if(size > 0){
                size /= 1.2;
                size -= 0.01;
            }
            if(size < 0){
                size = 0;
            }
        }
      this.startScissors((int) (this.x), this.y , this.x + this.x1 , this.y + this.y1+1);
      GuiApi.drawBorderedCircle((x+x+x1)/2,(y+y+y1)/2,size,Main.getMain.getClientColor().getRGB(),Main.getMain.getClientColor().getRGB());
      this.stopScissor();
      Main.getMain.verdana.drawCenteredStringWithShadow(this.text, this.x + this.x1 / 2, this.y + this.y1 / 2 - 9, -1);
  }
}

minecraft_de_Client_Utils_DarkPasswordField.java

package de.Client.Utils;

import net.minecraft.client.gui.FontRenderer;
import net.minecraft.client.gui.Gui;
import net.minecraft.client.gui.GuiScreen;
import net.minecraft.util.ChatAllowedCharacters;
import org.lwjgl.opengl.GL11;

public final class DarkPasswordField extends Gui {
	
	private final int field_146209_f;
	private final int field_146210_g;
	private final FontRenderer field_146211_a;
	private boolean field_146212_n = true;
	private boolean field_146213_o;
	private int field_146214_l;
	private boolean field_146215_m = true;
	private String field_146216_j = "";
	private int field_146217_k = 32;
	private final int field_146218_h;
	private final int field_146219_i;
	private boolean field_146220_v = true;
	private int field_146221_u = 7368816;
	private int field_146222_t = 14737632;
	private int field_146223_s;
	private int field_146224_r;
	private int field_146225_q;
	private boolean field_146226_p = true;

	public DarkPasswordField(FontRenderer p_i1032_1_, int p_i1032_2_, int p_i1032_3_, int p_i1032_4_, int p_i1032_5_) {
		this.field_146211_a = p_i1032_1_;
		this.field_146209_f = p_i1032_2_;
		this.field_146210_g = p_i1032_3_;
		this.field_146218_h = p_i1032_4_;
		this.field_146219_i = p_i1032_5_;
	}

	public void drawTextBox() {
		if (func_146176_q()) {
			if (func_146181_i()) {
				Gui.drawRect(this.field_146209_f - 1, this.field_146210_g - 1, this.field_146209_f + this.field_146218_h + 1, this.field_146210_g + this.field_146219_i + 1, 0x80000000);
				Gui.drawRect(this.field_146209_f, this.field_146210_g, this.field_146209_f + this.field_146218_h, this.field_146210_g + this.field_146219_i, 0x80000000);
			}
			int var1 = this.field_146226_p ? this.field_146222_t : this.field_146221_u;
			int var2 = this.field_146224_r - this.field_146225_q;
			int var3 = this.field_146223_s - this.field_146225_q;
			String var4 = this.field_146211_a.trimStringToWidth(this.field_146216_j.substring(this.field_146225_q),
					func_146200_o());
			boolean var5 = (var2 >= 0) && (var2 <= var4.length());
			boolean var6 = (this.field_146213_o) && (this.field_146214_l / 6 % 2 == 0) && (var5);
			int var7 = this.field_146215_m ? this.field_146209_f + 4 : this.field_146209_f;
			int var8 = this.field_146215_m ? this.field_146210_g + (this.field_146219_i - 8) / 2 : this.field_146210_g;
			int var9 = var7;
			if (var3 > var4.length()) {
				var3 = var4.length();
			}
			if (var4.length() > 0) {
				String var10 = var5 ? var4.substring(0, var2) : var4;
				var9 = this.field_146211_a.drawString(var10.replaceAll(".", "*"), var7, var8, var1);
			}
			boolean var13 = (this.field_146224_r < this.field_146216_j.length())
					|| (this.field_146216_j.length() >= func_146208_g());
			int var11 = var9;
			if (!var5) {
				var11 = var2 > 0 ? var7 + this.field_146218_h : var7;
			} else if (var13) {
				var11 = var9 - 1;
				var9--;
			}
			if ((var4.length() > 0) && (var5) && (var2 < var4.length())) {
				this.field_146211_a.drawString(var4.substring(var2).replaceAll(".", "*"), var9, var8, var1);
			}
			if (var6) {
				if (var13) {
					Gui.drawRect(var11, var8 - 1, var11 + 1, var8 + 1 + this.field_146211_a.FONT_HEIGHT, -3092272);
				} else {
					this.field_146211_a.drawString("_", var11, var8, var1);
				}
			}
			if (var3 != var2) {
				int var12 = var7 + this.field_146211_a.getStringWidth(var4.substring(0, var3).replaceAll(".", "*"));
				func_146188_c(var11, var8 - 1, var12 - 1, var8 + 1 + this.field_146211_a.FONT_HEIGHT);
			}
		}
	}

	public void func_146175_b(int p_146175_1_) {
		if (this.field_146216_j.length() != 0) {
			if (this.field_146223_s != this.field_146224_r) {
				func_146191_b("");
			} else {
				boolean var2 = p_146175_1_ < 0;
				int var3 = var2 ? this.field_146224_r + p_146175_1_ : this.field_146224_r;
				int var4 = var2 ? this.field_146224_r : this.field_146224_r + p_146175_1_;
				String var5 = "";
				if (var3 >= 0) {
					var5 = this.field_146216_j.substring(0, var3);
				}
				if (var4 < this.field_146216_j.length()) {
					var5 = var5 + this.field_146216_j.substring(var4);
				}
				this.field_146216_j = var5;
				if (var2) {
					func_146182_d(p_146175_1_);
				}
			}
		}
	}

	public boolean func_146176_q() {
		return this.field_146220_v;
	}

	public void func_146177_a(int p_146177_1_) {
		if (this.field_146216_j.length() != 0) {
			if (this.field_146223_s != this.field_146224_r) {
				func_146191_b("");
			} else {
				func_146175_b(func_146187_c(p_146177_1_) - this.field_146224_r);
			}
		}
	}

	public boolean func_146181_i() {
		return this.field_146215_m;
	}

	public void func_146182_d(int p_146182_1_) {
		func_146190_e(this.field_146223_s + p_146182_1_);
	}

	public int func_146183_a(int p_146183_1_, int p_146183_2_) {
		return func_146197_a(p_146183_1_, func_146198_h(), true);
	}

	public void func_146184_c(boolean p_146184_1_) {
		this.field_146226_p = p_146184_1_;
	}

	public void func_146185_a(boolean p_146185_1_) {
		this.field_146215_m = p_146185_1_;
	}

	public int func_146186_n() {
		return this.field_146223_s;
	}

	public int func_146187_c(int p_146187_1_) {
		return func_146183_a(p_146187_1_, func_146198_h());
	}

	private void func_146188_c(int p_146188_1_, int p_146188_2_, int p_146188_3_, int p_146188_4_) {
		if (p_146188_1_ < p_146188_3_) {
			int var5 = p_146188_1_;
			p_146188_1_ = p_146188_3_;
			p_146188_3_ = var5;
		}
		if (p_146188_2_ < p_146188_4_) {
			int var5 = p_146188_2_;
			p_146188_2_ = p_146188_4_;
			p_146188_4_ = var5;
		}
		if (p_146188_3_ > this.field_146209_f + this.field_146218_h) {
			p_146188_3_ = this.field_146209_f + this.field_146218_h;
		}
		if (p_146188_1_ > this.field_146209_f + this.field_146218_h) {
			p_146188_1_ = this.field_146209_f + this.field_146218_h;
		}
		// WorldRenderer var2 = Tessellator.instance.getWorldRenderer();
		GL11.glColor4f(0.0F, 0.0F, 255.0F, 255.0F);
		GL11.glDisable(3553);
		GL11.glEnable(3058);
		GL11.glLogicOp(5387);
		// var2.startDrawingQuads();
		// var2.addVertex(p_146188_1_, p_146188_4_, 0.0D);
		// var2.addVertex(p_146188_3_, p_146188_4_, 0.0D);
		// var2.addVertex(p_146188_3_, p_146188_2_, 0.0D);
		// var2.addVertex(p_146188_1_, p_146188_2_, 0.0D);
		// var2.draw();
		GL11.glDisable(3058);
		GL11.glEnable(3553);
	}

	public void func_146189_e(boolean p_146189_1_) {
		this.field_146220_v = p_146189_1_;
	}

	public void func_146190_e(int p_146190_1_) {
		this.field_146224_r = p_146190_1_;
		int var2 = this.field_146216_j.length();
		if (this.field_146224_r < 0) {
			this.field_146224_r = 0;
		}
		if (this.field_146224_r > var2) {
			this.field_146224_r = var2;
		}
		func_146199_i(this.field_146224_r);
	}

	public void func_146191_b(String p_146191_1_) {
		String var2 = "";
		String var3 = ChatAllowedCharacters.filterAllowedCharacters(p_146191_1_);
		int var4 = this.field_146224_r < this.field_146223_s ? this.field_146224_r : this.field_146223_s;
		int var5 = this.field_146224_r < this.field_146223_s ? this.field_146223_s : this.field_146224_r;
		int var6 = this.field_146217_k - this.field_146216_j.length() - (var4 - this.field_146223_s);
		if (this.field_146216_j.length() > 0) {
			var2 = var2 + this.field_146216_j.substring(0, var4);
		}
		int var8;
		if (var6 < var3.length()) {
			var2 = var2 + var3.substring(0, var6);
			var8 = var6;
		} else {
			var2 = var2 + var3;
			var8 = var3.length();
		}
		if ((this.field_146216_j.length() > 0) && (var5 < this.field_146216_j.length())) {
			var2 = var2 + this.field_146216_j.substring(var5);
		}
		this.field_146216_j = var2;
		func_146182_d(var4 - this.field_146223_s + var8);
	}

	public void func_146193_g(int p_146193_1_) {
		this.field_146222_t = p_146193_1_;
	}

	public void func_146196_d() {
		func_146190_e(0);
	}

	public int func_146197_a(int p_146197_1_, int p_146197_2_, boolean p_146197_3_) {
		int var4 = p_146197_2_;
		boolean var5 = p_146197_1_ < 0;
		int var6 = Math.abs(p_146197_1_);
		for (int var7 = 0; var7 < var6; var7++) {
			if (var5) {
				for (;;) {
					var4--;
					if ((p_146197_3_) && (var4 > 0)) {
						if (this.field_146216_j.charAt(var4 - 1) != ' ') {
							break;
						}
					}
				}
				do {
					var4--;
					if (var4 <= 0) {
						break;
					}
				} while (this.field_146216_j.charAt(var4 - 1) != ' ');
			} else {
				int var8 = this.field_146216_j.length();
				var4 = this.field_146216_j.indexOf(' ', var4);
				if (var4 == -1) {
					var4 = var8;
				} else {
					while ((p_146197_3_) && (var4 < var8) && (this.field_146216_j.charAt(var4) == ' ')) {
						var4++;
					}
				}
			}
		}
		return var4;
	}

	public int func_146198_h() {
		return this.field_146224_r;
	}

	public void func_146199_i(int p_146199_1_) {
		int var2 = this.field_146216_j.length();
		if (p_146199_1_ > var2) {
			p_146199_1_ = var2;
		}
		if (p_146199_1_ < 0) {
			p_146199_1_ = 0;
		}
		this.field_146223_s = p_146199_1_;
		if (this.field_146211_a != null) {
			if (this.field_146225_q > var2) {
				this.field_146225_q = var2;
			}
			int var3 = func_146200_o();
			String var4 = this.field_146211_a.trimStringToWidth(this.field_146216_j.substring(this.field_146225_q),
					var3);
			int var5 = var4.length() + this.field_146225_q;
			if (p_146199_1_ == this.field_146225_q) {
				this.field_146225_q = (this.field_146225_q
						- this.field_146211_a.trimStringToWidth(this.field_146216_j, var3, true).length());
			}
			if (p_146199_1_ > var5) {
				this.field_146225_q += p_146199_1_ - var5;
			} else if (p_146199_1_ <= this.field_146225_q) {
				this.field_146225_q -= this.field_146225_q - p_146199_1_;
			}
			if (this.field_146225_q < 0) {
				this.field_146225_q = 0;
			}
			if (this.field_146225_q > var2) {
				this.field_146225_q = var2;
			}
		}
	}

	public int func_146200_o() {
		return func_146181_i() ? this.field_146218_h - 8 : this.field_146218_h;
	}

	public void func_146202_e() {
		func_146190_e(this.field_146216_j.length());
	}

	public void func_146203_f(int p_146203_1_) {
		this.field_146217_k = p_146203_1_;
		if (this.field_146216_j.length() > p_146203_1_) {
			this.field_146216_j = this.field_146216_j.substring(0, p_146203_1_);
		}
	}

	public void func_146204_h(int p_146204_1_) {
		this.field_146221_u = p_146204_1_;
	}

	public void func_146205_d(boolean p_146205_1_) {
		this.field_146212_n = p_146205_1_;
	}

	public String func_146207_c() {
		int var1 = this.field_146224_r < this.field_146223_s ? this.field_146224_r : this.field_146223_s;
		int var2 = this.field_146224_r < this.field_146223_s ? this.field_146223_s : this.field_146224_r;
		return this.field_146216_j.substring(var1, var2);
	}

	public int func_146208_g() {
		return this.field_146217_k;
	}

	public String getText() {
		return this.field_146216_j;
	}

	public boolean isFocused() {
		return this.field_146213_o;
	}

	public void mouseClicked(int p_146192_1_, int p_146192_2_, int p_146192_3_) {
		boolean var4 = (p_146192_1_ >= this.field_146209_f) && (p_146192_1_ < this.field_146209_f + this.field_146218_h)
				&& (p_146192_2_ >= this.field_146210_g) && (p_146192_2_ < this.field_146210_g + this.field_146219_i);
		if (this.field_146212_n) {
			setFocused(var4);
		}
		if ((this.field_146213_o) && (p_146192_3_ == 0)) {
			int var5 = p_146192_1_ - this.field_146209_f;
			if (this.field_146215_m) {
				var5 -= 4;
			}
			String var6 = this.field_146211_a.trimStringToWidth(this.field_146216_j.substring(this.field_146225_q),
					func_146200_o());
			func_146190_e(this.field_146211_a.trimStringToWidth(var6, var5).length() + this.field_146225_q);
		}
	}

	public void setFocused(boolean p_146195_1_) {
		if ((p_146195_1_) && (!this.field_146213_o)) {
			this.field_146214_l = 0;
		}
		this.field_146213_o = p_146195_1_;
	}

	public void setText(String p_146180_1_) {
		if (p_146180_1_.length() > this.field_146217_k) {
			this.field_146216_j = p_146180_1_.substring(0, this.field_146217_k);
		} else {
			this.field_146216_j = p_146180_1_;
		}
		func_146202_e();
	}

	public boolean textboxKeyTyped(char p_146201_1_, int p_146201_2_) {
		if (!this.field_146213_o) {
			return false;
		}
		switch (p_146201_1_) {
		case '\001':
			func_146202_e();
			func_146199_i(0);
			return true;
		case '\003':
			GuiScreen.setClipboardString(func_146207_c());
			return true;
		case '\026':
			if (this.field_146226_p) {
				func_146191_b(GuiScreen.getClipboardString());
			}
			return true;
		case '\030':
			GuiScreen.setClipboardString(func_146207_c());
			if (this.field_146226_p) {
				func_146191_b("");
			}
			return true;
		}
		switch (p_146201_2_) {
		case 14:
			if (GuiScreen.isCtrlKeyDown()) {
				if (this.field_146226_p) {
					func_146177_a(-1);
				}
			} else if (this.field_146226_p) {
				func_146175_b(-1);
			}
			return true;
		case 199:
			if (GuiScreen.isShiftKeyDown()) {
				func_146199_i(0);
			} else {
				func_146196_d();
			}
			return true;
		case 203:
			if (GuiScreen.isShiftKeyDown()) {
				if (GuiScreen.isCtrlKeyDown()) {
					func_146199_i(func_146183_a(-1, func_146186_n()));
				} else {
					func_146199_i(func_146186_n() - 1);
				}
			} else if (GuiScreen.isCtrlKeyDown()) {
				func_146190_e(func_146187_c(-1));
			} else {
				func_146182_d(-1);
			}
			return true;
		case 205:
			if (GuiScreen.isShiftKeyDown()) {
				if (GuiScreen.isCtrlKeyDown()) {
					func_146199_i(func_146183_a(1, func_146186_n()));
				} else {
					func_146199_i(func_146186_n() + 1);
				}
			} else if (GuiScreen.isCtrlKeyDown()) {
				func_146190_e(func_146187_c(1));
			} else {
				func_146182_d(1);
			}
			return true;
		case 207:
			if (GuiScreen.isShiftKeyDown()) {
				func_146199_i(this.field_146216_j.length());
			} else {
				func_146202_e();
			}
			return true;
		case 211:
			if (GuiScreen.isCtrlKeyDown()) {
				if (this.field_146226_p) {
					func_146177_a(1);
				}
			} else if (this.field_146226_p) {
				func_146175_b(1);
			}
			return true;
		}
		if (ChatAllowedCharacters.isAllowedCharacter(p_146201_1_)) {
			if (this.field_146226_p) {
				func_146191_b(Character.toString(p_146201_1_));
			}
			return true;
		}
		return false;
	}

	public void updateCursorCounter() {
		this.field_146214_l += 1;
	}
}

minecraft_de_Client_Utils_DarkTextField.java

package de.Client.Utils;

import com.google.common.base.Predicate;
import com.google.common.base.Predicates;
import net.minecraft.client.gui.FontRenderer;
import net.minecraft.client.gui.Gui;
import net.minecraft.client.gui.GuiPageButtonList;
import net.minecraft.client.gui.GuiScreen;
import net.minecraft.client.renderer.GlStateManager;
import net.minecraft.client.renderer.Tessellator;
import net.minecraft.client.renderer.WorldRenderer;
import net.minecraft.util.ChatAllowedCharacters;
import net.minecraft.util.MathHelper;

public class DarkTextField extends Gui {
	
	private final int id;
	private final FontRenderer fontRendererInstance;
	public int xPosition;
	public int yPosition;

	/** The width of this text field. */
	private final int width;
	private final int height;

	/** Has the current text being edited on the textbox. */
	private String text = "";
	private int maxStringLength = 32;
	private int cursorCounter;
	private boolean enableBackgroundDrawing = true;

	/**
	 * if true the textbox can lose focus by clicking elsewhere on the screen
	 */
	private boolean canLoseFocus = true;

	/**
	 * If this value is true along with isEnabled, keyTyped will process the
	 * keys.
	 */
	private boolean isFocused;

	/**
	 * If this value is true along with isFocused, keyTyped will process the
	 * keys.
	 */
	private boolean isEnabled = true;

	/**
	 * The current character index that should be used as start of the rendered
	 * text.
	 */
	private int lineScrollOffset;
	private int cursorPosition;

	/** other selection position, maybe the same as the cursor */
	private int selectionEnd;
	private int enabledColor = 14737632;
	private int disabledColor = 7368816;

	/** True if this textbox is visible */
	private boolean visible = true;
	private GuiPageButtonList.GuiResponder field_175210_x;
	private Predicate<String> validator = Predicates.<String> alwaysTrue();

	public DarkTextField(int componentId, FontRenderer fontrendererObj, int x, int y, int width, int height) {
		this.id = componentId;
		this.fontRendererInstance = fontrendererObj;
		this.xPosition = x;
		this.yPosition = y;
		this.width = width;
		this.height = height;
	}

	public void func_175207_a(GuiPageButtonList.GuiResponder p_175207_1_) {
		this.field_175210_x = p_175207_1_;
	}

	/**
	 * Increments the cursor counter
	 */
	public void updateCursorCounter() {
		++this.cursorCounter;
	}

	/**
	 * Sets the text of the textbox
	 */
	public void setText(String p_146180_1_) {
		if (this.validator.apply(p_146180_1_)) {
			if (p_146180_1_.length() > this.maxStringLength) {
				this.text = p_146180_1_.substring(0, this.maxStringLength);
			} else {
				this.text = p_146180_1_;
			}

			this.setCursorPositionEnd();
		}
	}

	/**
	 * Returns the contents of the textbox
	 */
	public String getText() {
		return this.text;
	}

	/**
	 * returns the text between the cursor and selectionEnd
	 */
	public String getSelectedText() {
		int i = this.cursorPosition < this.selectionEnd ? this.cursorPosition : this.selectionEnd;
		int j = this.cursorPosition < this.selectionEnd ? this.selectionEnd : this.cursorPosition;
		return this.text.substring(i, j);
	}

	public void setValidator(Predicate<String> theValidator) {
		this.validator = theValidator;
	}

	/**
	 * replaces selected text, or inserts text at the position on the cursor
	 */
	public void writeText(String p_146191_1_) {
		String s = "";
		String s1 = ChatAllowedCharacters.filterAllowedCharacters(p_146191_1_);
		int i = this.cursorPosition < this.selectionEnd ? this.cursorPosition : this.selectionEnd;
		int j = this.cursorPosition < this.selectionEnd ? this.selectionEnd : this.cursorPosition;
		int k = this.maxStringLength - this.text.length() - (i - j);
		int l = 0;

		if (!this.text.isEmpty()) {
			s = s + this.text.substring(0, i);
		}

		if (k < s1.length()) {
			s = s + s1.substring(0, k);
			l = k;
		} else {
			s = s + s1;
			l = s1.length();
		}

		if (!this.text.isEmpty() && j < this.text.length()) {
			s = s + this.text.substring(j);
		}

		if (this.validator.apply(s)) {
			this.text = s;
			this.moveCursorBy(i - this.selectionEnd + l);

			if (this.field_175210_x != null) {
				this.field_175210_x.func_175319_a(this.id, this.text);
			}
		}
	}

	/**
	 * Deletes the specified number of words starting at the cursor position.
	 * Negative numbers will delete words left of the cursor.
	 */
	public void deleteWords(int p_146177_1_) {
		if (!this.text.isEmpty()) {
			if (this.selectionEnd != this.cursorPosition) {
				this.writeText("");
			} else {
				this.deleteFromCursor(this.getNthWordFromCursor(p_146177_1_) - this.cursorPosition);
			}
		}
	}

	/**
	 * delete the selected text, otherwsie deletes characters from either side
	 * of the cursor. params: delete num
	 */
	public void deleteFromCursor(int p_146175_1_) {
		if (!this.text.isEmpty()) {
			if (this.selectionEnd != this.cursorPosition) {
				this.writeText("");
			} else {
				boolean flag = p_146175_1_ < 0;
				int i = flag ? this.cursorPosition + p_146175_1_ : this.cursorPosition;
				int j = flag ? this.cursorPosition : this.cursorPosition + p_146175_1_;
				String s = "";

				if (i >= 0) {
					s = this.text.substring(0, i);
				}

				if (j < this.text.length()) {
					s = s + this.text.substring(j);
				}

				if (this.validator.apply(s)) {
					this.text = s;

					if (flag) {
						this.moveCursorBy(p_146175_1_);
					}

					if (this.field_175210_x != null) {
						this.field_175210_x.func_175319_a(this.id, this.text);
					}
				}
			}
		}
	}

	public int getId() {
		return this.id;
	}

	/**
	 * see @getNthNextWordFromPos() params: N, position
	 */
	public int getNthWordFromCursor(int p_146187_1_) {
		return this.getNthWordFromPos(p_146187_1_, this.getCursorPosition());
	}

	/**
	 * gets the position of the nth word. N may be negative, then it looks
	 * backwards. params: N, position
	 */
	public int getNthWordFromPos(int p_146183_1_, int p_146183_2_) {
		return this.func_146197_a(p_146183_1_, p_146183_2_, true);
	}

	public int func_146197_a(int p_146197_1_, int p_146197_2_, boolean p_146197_3_) {
		int i = p_146197_2_;
		boolean flag = p_146197_1_ < 0;
		int j = Math.abs(p_146197_1_);

		for (int k = 0; k < j; ++k) {
			if (!flag) {
				int l = this.text.length();
				i = this.text.indexOf(32, i);

				if (i == -1) {
					i = l;
				} else {
					while (p_146197_3_ && i < l && this.text.charAt(i) == 32) {
						++i;
					}
				}
			} else {
				while (p_146197_3_ && i > 0 && this.text.charAt(i - 1) == 32) {
					--i;
				}

				while (i > 0 && this.text.charAt(i - 1) != 32) {
					--i;
				}
			}
		}
		return i;
	}

	/**
	 * Moves the text cursor by a specified number of characters and clears the
	 * selection
	 */
	public void moveCursorBy(int p_146182_1_) {
		this.setCursorPosition(this.selectionEnd + p_146182_1_);
	}

	/**
	 * sets the position of the cursor to the provided index
	 */
	public void setCursorPosition(int p_146190_1_) {
		this.cursorPosition = p_146190_1_;
		int i = this.text.length();
		this.cursorPosition = MathHelper.clamp_int(this.cursorPosition, 0, i);
		this.setSelectionPos(this.cursorPosition);
	}

	/**
	 * sets the cursors position to the beginning
	 */
	public void setCursorPositionZero() {
		this.setCursorPosition(0);
	}

	/**
	 * sets the cursors position to after the text
	 */
	public void setCursorPositionEnd() {
		this.setCursorPosition(this.text.length());
	}

	/**
	 * Call this method from your GuiScreen to process the keys into the textbox
	 */
	public boolean textboxKeyTyped(char p_146201_1_, int p_146201_2_) {
        if (!this.isFocused)
        {
            return false;
        }
        else if (GuiScreen.func_175278_g(p_146201_2_))
        {
            this.setCursorPositionEnd();
            this.setSelectionPos(0);
            return true;
        }
        else if (GuiScreen.func_175280_f(p_146201_2_))
        {
            GuiScreen.setClipboardString(this.getSelectedText());
            return true;
        }
        else if (GuiScreen.func_175279_e(p_146201_2_))
        {
            if (this.isEnabled)
            {
                this.writeText(GuiScreen.getClipboardString());
            }

            return true;
        }
        else if (GuiScreen.func_175277_d(p_146201_2_))
        {
            GuiScreen.setClipboardString(this.getSelectedText());

            if (this.isEnabled)
            {
                this.writeText("");
            }

            return true;
        }
        else
        {
            switch (p_146201_2_)
            {
                case 14:
                    if (GuiScreen.isCtrlKeyDown())
                    {
                        if (this.isEnabled)
                        {
                            this.deleteWords(-1);
                        }
                    }
                    else if (this.isEnabled)
                    {
                        this.deleteFromCursor(-1);
                    }

                    return true;

                case 199:
                    if (GuiScreen.isShiftKeyDown())
                    {
                        this.setSelectionPos(0);
                    }
                    else
                    {
                        this.setCursorPositionZero();
                    }

                    return true;

                case 203:
                    if (GuiScreen.isShiftKeyDown())
                    {
                        if (GuiScreen.isCtrlKeyDown())
                        {
                            this.setSelectionPos(this.getNthWordFromPos(-1, this.getSelectionEnd()));
                        }
                        else
                        {
                            this.setSelectionPos(this.getSelectionEnd() - 1);
                        }
                    }
                    else if (GuiScreen.isCtrlKeyDown())
                    {
                        this.setCursorPosition(this.getNthWordFromCursor(-1));
                    }
                    else
                    {
                        this.moveCursorBy(-1);
                    }

                    return true;

                case 205:
                    if (GuiScreen.isShiftKeyDown())
                    {
                        if (GuiScreen.isCtrlKeyDown())
                        {
                            this.setSelectionPos(this.getNthWordFromPos(1, this.getSelectionEnd()));
                        }
                        else
                        {
                            this.setSelectionPos(this.getSelectionEnd() + 1);
                        }
                    }
                    else if (GuiScreen.isCtrlKeyDown())
                    {
                        this.setCursorPosition(this.getNthWordFromCursor(1));
                    }
                    else
                    {
                        this.moveCursorBy(1);
                    }

                    return true;

                case 207:
                    if (GuiScreen.isShiftKeyDown())
                    {
                        this.setSelectionPos(this.text.length());
                    }
                    else
                    {
                        this.setCursorPositionEnd();
                    }

                    return true;

                case 211:
                    if (GuiScreen.isCtrlKeyDown())
                    {
                        if (this.isEnabled)
                        {
                            this.deleteWords(1);
                        }
                    }
                    else if (this.isEnabled)
                    {
                        this.deleteFromCursor(1);
                    }

                    return true;

                default:
                    if (ChatAllowedCharacters.isAllowedCharacter(p_146201_1_))
                    {
                        if (this.isEnabled)
                        {
                            this.writeText(Character.toString(p_146201_1_));
                        }

                        return true;
                    }
                    else
                    {
                        return false;
                    }
            }
        }
    }

	/**
	 * Args: x, y, buttonClicked
	 */
	public void mouseClicked(int p_146192_1_, int p_146192_2_, int p_146192_3_) {
		boolean flag = p_146192_1_ >= this.xPosition && p_146192_1_ < this.xPosition + this.width
				&& p_146192_2_ >= this.yPosition && p_146192_2_ < this.yPosition + this.height;

		if (this.canLoseFocus) {
			this.setFocused(flag);
		}

		if (this.isFocused && flag && p_146192_3_ == 0) {
			int i = p_146192_1_ - this.xPosition;

			if (this.enableBackgroundDrawing) {
				i -= 4;
			}

			String s = this.fontRendererInstance.trimStringToWidth(this.text.substring(this.lineScrollOffset),
					this.getWidth());
			this.setCursorPosition(this.fontRendererInstance.trimStringToWidth(s, i).length() + this.lineScrollOffset);
		}
	}

	/**
	 * Draws the textbox
	 */
	public void drawTextBox() {
		if (this.getVisible()) {
			if (this.getEnableBackgroundDrawing()) {
				Gui.drawRect(this.xPosition - 1, this.yPosition - 1, this.xPosition + this.width + 1, this.yPosition + this.height + 1, 0x80000000);
				Gui.drawRect(this.xPosition, this.yPosition, this.xPosition + this.width, this.yPosition + this.height, 0x80000000);
			}

			int i = this.isEnabled ? this.enabledColor : this.disabledColor;
			int j = this.cursorPosition - this.lineScrollOffset;
			int k = this.selectionEnd - this.lineScrollOffset;
			String s = this.fontRendererInstance.trimStringToWidth(this.text.substring(this.lineScrollOffset), this.getWidth());
			boolean flag = j >= 0 && j <= s.length();
			boolean flag1 = this.isFocused && this.cursorCounter / 6 % 2 == 0 && flag;
			int l = this.enableBackgroundDrawing ? this.xPosition + 4 : this.xPosition;
			int i1 = this.enableBackgroundDrawing ? this.yPosition + (this.height - 8) / 2 : this.yPosition;
			int j1 = l;

			if (k > s.length()) {
				k = s.length();
			}

			if (!s.isEmpty()) {
				String s1 = flag ? s.substring(0, j) : s;
				j1 = this.fontRendererInstance.drawStringWithShadow(s1, (float) l, (float) i1, i);
			}

			boolean flag2 = this.cursorPosition < this.text.length() || this.text.length() >= this.getMaxStringLength();
			int k1 = j1;

			if (!flag) {
				k1 = j > 0 ? l + this.width : l;
			} else if (flag2) {
				k1 = j1 - 1;
				--j1;
			}

			if (!s.isEmpty() && flag && j < s.length()) {
				j1 = this.fontRendererInstance.drawStringWithShadow(s.substring(j), (float) j1, (float) i1, i);
			}

			if (flag1) {
				if (flag2) {
					Gui.drawRect(k1, i1 - 1, k1 + 1, i1 + 1 + this.fontRendererInstance.FONT_HEIGHT, -3092272);
				} else {
					this.fontRendererInstance.drawStringWithShadow("_", (float) k1, (float) i1, i);
				}
			}

			if (k != j) {
				int l1 = l + this.fontRendererInstance.getStringWidth(s.substring(0, k));
				this.drawCursorVertical(k1, i1 - 1, l1 - 1, i1 + 1 + this.fontRendererInstance.FONT_HEIGHT);
			}
		}
	}

	/**
	 * draws the vertical line cursor in the textbox
	 */
    private void drawCursorVertical(int p_146188_1_, int p_146188_2_, int p_146188_3_, int p_146188_4_)
    {
        int var5;

        if (p_146188_1_ < p_146188_3_)
        {
            var5 = p_146188_1_;
            p_146188_1_ = p_146188_3_;
            p_146188_3_ = var5;
        }

        if (p_146188_2_ < p_146188_4_)
        {
            var5 = p_146188_2_;
            p_146188_2_ = p_146188_4_;
            p_146188_4_ = var5;
        }

        if (p_146188_3_ > this.xPosition + this.width)
        {
            p_146188_3_ = this.xPosition + this.width;
        }

        if (p_146188_1_ > this.xPosition + this.width)
        {
            p_146188_1_ = this.xPosition + this.width;
        }

        Tessellator var7 = Tessellator.getInstance();
        WorldRenderer var6 = var7.getWorldRenderer();
        GlStateManager.color(0.0F, 0.0F, 255.0F, 255.0F);
        GlStateManager.func_179090_x();
        GlStateManager.enableColorLogic();
        GlStateManager.colorLogicOp(5387);
        var6.startDrawingQuads();
        var6.addVertex((double)p_146188_1_, (double)p_146188_4_, 0.0D);
        var6.addVertex((double)p_146188_3_, (double)p_146188_4_, 0.0D);
        var6.addVertex((double)p_146188_3_, (double)p_146188_2_, 0.0D);
        var6.addVertex((double)p_146188_1_, (double)p_146188_2_, 0.0D);
        var7.draw();
        GlStateManager.disableColorLogic();
        GlStateManager.func_179098_w();
    }

	public void setMaxStringLength(int p_146203_1_) {
		this.maxStringLength = p_146203_1_;

		if (this.text.length() > p_146203_1_) {
			this.text = this.text.substring(0, p_146203_1_);
		}
	}

	/**
	 * returns the maximum number of character that can be contained in this
	 * textbox
	 */
	public int getMaxStringLength() {
		return this.maxStringLength;
	}

	/**
	 * returns the current position of the cursor
	 */
	public int getCursorPosition() {
		return this.cursorPosition;
	}

	/**
	 * get enable drawing background and outline
	 */
	public boolean getEnableBackgroundDrawing() {
		return this.enableBackgroundDrawing;
	}

	/**
	 * enable drawing background and outline
	 */
	public void setEnableBackgroundDrawing(boolean p_146185_1_) {
		this.enableBackgroundDrawing = p_146185_1_;
	}

	/**
	 * Sets the text colour for this textbox (disabled text will not use this
	 * colour)
	 */
	public void setTextColor(int p_146193_1_) {
		this.enabledColor = p_146193_1_;
	}

	public void setDisabledTextColour(int p_146204_1_) {
		this.disabledColor = p_146204_1_;
	}

	/**
	 * Sets focus to this gui element
	 */
	public void setFocused(boolean p_146195_1_) {
		if (p_146195_1_ && !this.isFocused) {
			this.cursorCounter = 0;
		}

		this.isFocused = p_146195_1_;
	}

	/**
	 * Getter for the focused field
	 */
	public boolean isFocused() {
		return this.isFocused;
	}

	public void setEnabled(boolean p_146184_1_) {
		this.isEnabled = p_146184_1_;
	}

	/**
	 * the side of the selection that is not the cursor, may be the same as the
	 * cursor
	 */
	public int getSelectionEnd() {
		return this.selectionEnd;
	}

	/**
	 * returns the width of the textbox depending on if background drawing is
	 * enabled
	 */
	public int getWidth() {
		return this.getEnableBackgroundDrawing() ? this.width - 8 : this.width;
	}

	/**
	 * Sets the position of the selection anchor (i.e. position the selection
	 * was started at)
	 */
	public void setSelectionPos(int p_146199_1_) {
		int i = this.text.length();

		if (p_146199_1_ > i) {
			p_146199_1_ = i;
		}

		if (p_146199_1_ < 0) {
			p_146199_1_ = 0;
		}

		this.selectionEnd = p_146199_1_;

		if (this.fontRendererInstance != null) {
			if (this.lineScrollOffset > i) {
				this.lineScrollOffset = i;
			}

			int j = this.getWidth();
			String s = this.fontRendererInstance.trimStringToWidth(this.text.substring(this.lineScrollOffset), j);
			int k = s.length() + this.lineScrollOffset;

			if (p_146199_1_ == this.lineScrollOffset) {
				this.lineScrollOffset -= this.fontRendererInstance.trimStringToWidth(this.text, j, true).length();
			}

			if (p_146199_1_ > k) {
				this.lineScrollOffset += p_146199_1_ - k;
			} else if (p_146199_1_ <= this.lineScrollOffset) {
				this.lineScrollOffset -= this.lineScrollOffset - p_146199_1_;
			}

			this.lineScrollOffset = MathHelper.clamp_int(this.lineScrollOffset, 0, i);
		}
	}

	/**
	 * if true the textbox can lose focus by clicking elsewhere on the screen
	 */
	public void setCanLoseFocus(boolean p_146205_1_) {
		this.canLoseFocus = p_146205_1_;
	}

	/**
	 * returns true if this textbox is visible
	 */
	public boolean getVisible() {
		return this.visible;
	}

	/**
	 * Sets whether or not this textbox is visible
	 */
	public void setVisible(boolean p_146189_1_) {
		this.visible = p_146189_1_;
	}
}

minecraft_de_Client_Utils_FriendManager.java

package de.Client.Utils;

import de.Client.Main.Main;
import sun.security.provider.Sun;

import java.io.*;
import java.util.HashMap;
import java.util.List;

/**
 * Created by Daniel on 15.07.2017.
 */
public class FriendManager {
    public FriendManager(){
        FriendManager.setFriends(Main.getMain.friend);
    }
    public static HashMap<String,String[]> friends = new HashMap<>();
    public static void saveFriendrs(File file) {
        try {
            if (file.exists()) {
                file.delete();
            }
            file.createNewFile();

            PrintWriter output = new PrintWriter(new FileWriter(file, true));
            for (String m : friends.keySet()) {
                output.println(m+ "%%" + friends.get(m)[0]);

            }
            output.close();
        } catch (Exception localException) {
        }
    }

    public static String[] readFriends(File file) {
        try {
            if (!file.exists()) {
                file.createNewFile();
            }
            FileReader fileReader = new FileReader(file);
            BufferedReader bufferedReader = new BufferedReader(fileReader);
            java.util.ArrayList<String> lines = new java.util.ArrayList<String>();
            String line = null;
            while ((line = bufferedReader.readLine()) != null) {
                lines.add(line);
            }
            bufferedReader.close();
            return lines.toArray(new String[lines.size()]);
        } catch (Exception f) {
            return new String[] { "" };
        }
    }

    public static void setFriends(final File file) {
        try {
            new Thread("Friend Toggle Thread (StartUp)") {

                @Override
                public void run() {
                    for (String s : readFriends(file)) {
                        String[] splitString = s.split("%%");
                        friends.put(splitString[0],new String[]{splitString[1]});
                    }
                }
            }.start();
        } catch (Exception var1_1) {
        }
    }
}

minecraft_de_Client_Utils_IRC.java

package de.Client.Utils;

import java.io.IOException;

import de.Client.Main.Main;
import org.jibble.pircbot.IrcException;
import org.jibble.pircbot.NickAlreadyInUseException;
import org.jibble.pircbot.PircBot;


public class IRC extends PircBot {

    public static String CHANNEL_MAIN = "#Sun/Sky-Channel_Main";
    public static String CHANNEL_PRIVATE_1 = "#Sun/Sky-Channel_Private_1";
    public static String CHANNEL_PRIVATE_2 = "#Sun/Sky-Channel_Private_2";
    public static String CHANNEL_GAME = "#Sun/Sky-Channel_Game";

    public static String CURRENT_CHANNEL;

    private static String HOST = "irc.freenode.net";
    private static int PORT = 6667;

    public static String IRC_USERNAME;;

    public IRC(String username) {
        IRC.IRC_USERNAME = username;
    }



    public void connect() {
        new Thread() {
            
            @Override
            public void run() {
                System.out.println("IRC - Versuche zu connecten...");

                Main.getMain.ircManager. setAutoNickChange(true);


                        Main.getMain.ircManager.setName(IRC.IRC_USERNAME);


                Main.getMain.ircManager.changeNick(IRC.IRC_USERNAME);

                try

                {
                    connect(IRC.HOST, IRC.PORT);
                    if (IRC.CURRENT_CHANNEL == null || IRC.CURRENT_CHANNEL.equalsIgnoreCase("")) {
                        IRC.CURRENT_CHANNEL = IRC.CHANNEL_MAIN;
                    }
                    Main.getMain.ircManager.joinChannel(IRC.CURRENT_CHANNEL);
                    Main.getMain.cmdManager.sendChatMessage("§aIRC §fbeigetreten.");
                } catch (
                        NickAlreadyInUseException e)

                {
                    Main.getMain.cmdManager.sendChatMessage("§cDein IRC-Name wird bereits verwendet!");
                    e.printStackTrace();
                } catch (
                        IOException e)

                {
                    Main.getMain.cmdManager.sendChatMessage("§cFehler beim Verbinden mit dem IRC!");
                    e.printStackTrace();
                } catch (
                        IrcException e)

                {
                    Main.getMain.cmdManager.sendChatMessage("§cFehler mit dem IRC!");
                    e.printStackTrace();
                }
            }
        }.start();
    }
}

minecraft_de_Client_Utils_IRCChatLine.java

package de.Client.Utils;

public class IRCChatLine {

    private String sender;
    private String line;
    private int index;
    private boolean hasRead;

    public IRCChatLine(String sender, String line, int index, boolean hasRead) {
        this.sender = sender;
        this.line = line;
        this.index = index;
        this.hasRead = hasRead;
    }

    public String getSender() {
        return sender;
    }

    public void setSender(String sender) {
        this.sender = sender;
    }

    public String getLine() {
        return line;
    }

    public void setLine(String line) {
        this.line = line;
    }

    public int getIndex() {
        return index;
    }

    public void setIndex(int index) {
        this.index = index;
    }

    public boolean isRead() {
        return hasRead;
    }

    public void setRead(boolean hasRead) {
        this.hasRead = hasRead;
    }
}

minecraft_de_Client_Utils_Macro.java

package de.Client.Utils;

import de.Client.Main.Main;
import de.Client.Main.Modules.Module;
import de.Client.Main.Values.Value;
import de.Client.Main.Values.ValueBoolean;
import de.Client.Main.Values.ValueDouble;

import java.util.ArrayList;

public class Macro {
    public String key;

    public Macro(String keys) {
        key = keys;
    }

    public Macro(String keys,int keyBind,String name) {
        key = keyBind + "@@" + name + "%%" +keys ;
    }

    public Macro(int keyBind,String name){
        key = keyBind + "@@" + name + "%%";
    }

    public String[] splitKey(){
        return key.split("%%");
    }
    public String[] getKey(){
        return this.splitKey()[1].split("::");
    }
    public String[] getInfo(){
        return this.splitKey()[0].split("@@");
    }
    public String getKeybind(){
        return this.getInfo()[0];
    }
    public String getName(){
        return this.getInfo()[1];
    }
    public int getKeyBindI(){
        return Integer.parseInt(this.getKeybind());
    }
    public enum enumMode{
        DisableAllValuesBoolean,
        EnableAllValuesBoolean,
        EnableValueBoolean,
        DisableValueBoolean,
        ToggleValueBoolean,
        SetValueDouble,
    }
    public enumMode decryptKeyAction(String key){
        if(key.startsWith("DAVB")){
            return  enumMode.DisableAllValuesBoolean;
        }if(key.startsWith("EAVB")){
            return  enumMode.EnableAllValuesBoolean;
        }if(key.startsWith("DVB")){
            return  enumMode.DisableValueBoolean;
        }if(key.startsWith("EVB")){
            return enumMode.EnableValueBoolean;
        }if(key.startsWith("TVB")){
            return enumMode.ToggleValueBoolean;
        }if(key.startsWith("SVD")){
            return enumMode.SetValueDouble;
        }

        return null;
    }
    public void actionPerformed() {
        for (String key : this.getKey()) {
            for (Module m : Main.getMain.moduleManager.getModules()) {
                if (m.name.equalsIgnoreCase(this.getName())) {
                    enumMode mode = this.decryptKeyAction(key);
                    if (mode == enumMode.DisableAllValuesBoolean) {
                        for (Value v : m.values) {
                            if (v instanceof ValueBoolean) {
                                ValueBoolean vb = (ValueBoolean) v;
                                vb.setValue(false);
                            }
                        }
                    }
                    if (mode == enumMode.EnableAllValuesBoolean) {
                        for (Value v : m.values) {
                            if (v instanceof ValueBoolean) {
                                ValueBoolean vb = (ValueBoolean) v;
                                vb.setValue(true);
                            }
                        }
                    }if (mode == enumMode.DisableValueBoolean) {
                        String valuename = key.split("__")[1];
                        for (Value v : m.values) {
                            if (v instanceof ValueBoolean && v.getName().equalsIgnoreCase(valuename)) {
                                ValueBoolean vb = (ValueBoolean) v;
                                vb.setValue(false);
                            }
                        }
                    }if (mode == enumMode.EnableValueBoolean) {
                        String valuename = key.split("__")[1];
                        for (Value v : m.values) {
                            if (v instanceof ValueBoolean && v.getName().equalsIgnoreCase(valuename)) {
                                ValueBoolean vb = (ValueBoolean) v;
                                vb.setValue(true);
                            }
                        }
                    }if (mode == enumMode.ToggleValueBoolean) {
                        String valuename = key.split("__")[1];
                        for (Value v : m.values) {
                            if (v instanceof ValueBoolean && v.getName().equalsIgnoreCase(valuename)) {
                                ValueBoolean vb = (ValueBoolean) v;
                                vb.setValue(!vb.getValue());
                            }
                        }
                    }if (mode == enumMode.SetValueDouble) {
                        String valuename = key.split("__")[1];
                        for (Value v : m.values) {
                            if (v instanceof ValueDouble && v.getName().equalsIgnoreCase(valuename)) {
                                ValueDouble vd = (ValueDouble) v;
                                vd.setValue(Double.parseDouble(key.split("__")[2]));
                            }
                        }
                    }
                }
            }
        }
    }





}

minecraft_de_Client_Utils_MacroManager.java

package de.Client.Utils;

import de.Client.Main.Main;
import de.Client.Main.Modules.Module;
import de.Client.Main.Modules.ModuleManager;
import de.Client.Main.Values.Value;

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.HashMap;

public class MacroManager {
    public void init(){
        for(Module mods : Main.getMain.moduleManager.modules){
            for(Value v : mods.values){
                values.add(v);
            }
        }
    }
    public ArrayList<Macro> macroArrayList = new ArrayList<>();
    public ArrayList<Value> values = new ArrayList<>();
}

minecraft_de_Client_Utils_MiniValueBooleanArray.java

package de.Client.Utils;

import de.Client.Main.Main;
import de.Client.Main.Values.ValueBoolean;
import de.Client.Render.GuiApi;
import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.Gui;
import org.lwjgl.opengl.GL11;

import java.awt.*;
import java.sql.Wrapper;
import java.util.*;

/**
 * Created by Daniel on 15.08.2017.
 */
public   class MiniValueBooleanArray{
    public boolean isExtended = false;
    public String name = "";
    public java.util.ArrayList<ValueBoolean> valueBooleanArrayList;
    public MiniValueBooleanArray(java.util.ArrayList<ValueBoolean> valueArray, String name){
        valueBooleanArrayList = valueArray;
        this.name = name;
    }

    public void drawMini(float x, float y){
        float height = y+1;
        for(ValueBoolean v : this.valueBooleanArrayList){
            height -=20;

            if(!v.getValue()) {
                GuiApi.drawRect(((int) x - 55), (int) height - 9, (int) x + 55, (int) height + 9, new Color(0x292929).getRGB());
            }else{
                GuiApi.drawRect(((int) x - 55), (int) height - 9, (int) x + 55, (int) height + 9, Main.getMain.getClientColor().getRGB());
            }

            GL11.glPushMatrix();
            GuiApi.drawGradientRect(x - 55,height - 12,x + 55, height + 9,0, Integer.MIN_VALUE);
            GL11.glPopMatrix();
            Main.getMain.verdanas.drawStringWithShadow(v.getName(),x-55,height-8,0xffffffff);
        }

    }
}

minecraft_de_Client_Utils_RayTraceUtils.java

package de.Client.Utils;
import net.minecraft.entity.Entity;

import net.minecraft.util.BlockPos;
import net.minecraft.util.EnumFacing;
import net.minecraft.util.Vec3;

public class RayTraceUtils
{
    private BlockPos blockPos;

    /**
     * The type of hit that occured, see {@link RayTraceUtils#Type} for possibilities.
     */
    public RayTraceUtils.Type typeOfHit;
    public EnumFacing sideHit;

    /** The vector position of the hit */
    public Vec3 hitVec;

    /** The hit entity */
    public Entity entityHit;

    public RayTraceUtils(Vec3 hitVecIn, EnumFacing sideHitIn, BlockPos blockPosIn)
    {
        this(RayTraceUtils.Type.BLOCK, hitVecIn, sideHitIn, blockPosIn);
    }

    public RayTraceUtils(Vec3 hitVecIn, EnumFacing sideHitIn)
    {
        this(RayTraceUtils.Type.BLOCK, hitVecIn, sideHitIn, BlockPos.ORIGIN);
    }

    public RayTraceUtils(Entity entityIn)
    {
        this(entityIn, new Vec3(entityIn.posX, entityIn.posY, entityIn.posZ));
    }

    public RayTraceUtils(RayTraceUtils.Type typeIn, Vec3 hitVecIn, EnumFacing sideHitIn, BlockPos blockPosIn)
    {
        this.typeOfHit = typeIn;
        this.blockPos = blockPosIn;
        this.sideHit = sideHitIn;
        this.hitVec = new Vec3(hitVecIn.xCoord, hitVecIn.yCoord, hitVecIn.zCoord);
    }

    public RayTraceUtils(Entity entityHitIn, Vec3 hitVecIn)
    {
        this.typeOfHit = RayTraceUtils.Type.ENTITY;
        this.entityHit = entityHitIn;
        this.hitVec = hitVecIn;
    }

    public BlockPos getBlockPos()
    {
        return this.blockPos;
    }

    public String toString()
    {
        return "HitResult{type=" + this.typeOfHit + ", blockpos=" + this.blockPos + ", f=" + this.sideHit + ", pos=" + this.hitVec + ", entity=" + this.entityHit + '}';
    }

    public static enum Type
    {
        MISS,
        BLOCK,
        ENTITY;
    }
}

minecraft_de_Client_Utils_Rect.java

package de.Client.Utils;

import de.Client.Main.Main;
import de.Client.Render.GuiApi;
import net.minecraft.client.gui.ScaledResolution;
import net.minecraft.util.MathHelper;

import java.awt.*;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Random;

public class Rect {
	
	public int color;
	
	public double Speed;
	
	public double y;
	
	public double x;
	
	public double height;
	
	public double widht;

	public double timeExisted;

	public boolean dirty;
    public double abstand;
	public ArrayList<Rect> connectedRechts= new ArrayList();
	public float getDistanceToRect(Rect rect){
        float var2 = (float)(this.x - rect.x);
        float var3 = (float)(this.y - rect.y);
        return MathHelper.sqrt_float(var2 * var2 + var3 * var3);

    }

    public double xPos(){
	    return abstand + x;
    }

    public void draw(){
        GuiApi.drawBorderRectNoCorners(abstand + x-2,y+5,abstand+x+widht-2,y-this.height+5,new Color(0x000000).getRGB(),new Color(0x000000).getRGB());
        GuiApi.drawBorderRectNoCorners(abstand + x,y,abstand+x+widht,y-this.height,new Color(0x191B29).getRGB(),new Color(0x121B29).getRGB());
        x  += Speed;
        ScaledResolution sr = new ScaledResolution();
        if(sr.getScaledWidth() < x+abstand-widht){
            dirty = true;
            System.out.println("test");
        }
    }

	public Rect(double abstand){
        this.abstand = abstand;
		this.Speed =0.5;
        ScaledResolution sr = new ScaledResolution();
        widht = 20 + new Random().nextInt(20);
        this.height =  (new Random().nextInt(3)+1) * widht;
        this.height /= sr.getScaleFactor();
        this.widht /= sr.getScaleFactor();
        this.height *= 2;
        this.widht *= 2;
        this.timeExisted = new Random().nextInt();
		y = sr.getScaledHeight();

	}

}

minecraft_de_Client_Utils_RenderAPI2d.java

package de.Client.Utils;

import de.Client.Events.EventTarget;
import de.Client.Events.Events.Render3DEvent;
import de.Client.Main.Main;
import de.Client.Main.Modules.Category;
import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelOutboundBuffer;
import net.minecraft.client.Minecraft;
import net.minecraft.client.gui.ScaledResolution;
import net.minecraft.client.renderer.GlStateManager;
import net.minecraft.client.renderer.entity.RenderManager;
import net.minecraft.entity.Entity;
import net.minecraft.entity.player.EntityPlayer;
import org.lwjgl.BufferUtils;
import org.lwjgl.opengl.GL11;
import org.lwjgl.util.glu.GLU;
import org.newdawn.slick.opengl.Texture;
import org.newdawn.slick.opengl.TextureImpl;
import org.newdawn.slick.opengl.TextureLoader;

import java.io.IOException;
import java.nio.FloatBuffer;
import java.nio.IntBuffer;
import java.nio.channels.Channel;
import java.util.HashMap;
import java.util.logging.Handler;
import java.util.logging.LogRecord;

public class RenderAPI2d {

    public RenderAPI2d() {
        maps.add(upperPos1);
        maps.add(lowerPos1);
        maps.add(lowerPos2);
        maps.add(upperPos2);
        maps.add(lowerPos3);
        maps.add(upperPos4);
        maps.add(lowerPos4);
    }

    public HashMap<Entity, float[]> upperPos1 = new HashMap<>();
    public HashMap<Entity, float[]> lowerPos1 = new HashMap<>();
    public HashMap<Entity, float[]> upperPos2 = new HashMap<>();
    public HashMap<Entity, float[]> lowerPos2 = new HashMap<>();
    public HashMap<Entity, float[]> upperPos3 = new HashMap<>();
    public HashMap<Entity, float[]> lowerPos3 = new HashMap<>();
    public HashMap<Entity, float[]> upperPos4 = new HashMap<>();
    public HashMap<Entity, float[]> lowerPos4 = new HashMap<>();
    public java.util.ArrayList<HashMap<Entity, float[]>> maps = new java.util.ArrayList<>();
    public boolean shouldConvert2d;



    public void on3dRender() {



        if(!this.shouldConvert2d){
            return;
        }else{
            this.shouldConvert2d = false;
        }

            for(HashMap m : this.maps){
                m.clear();
            }

        for (Object objectEntity : Minecraft.getMinecraft().theWorld.loadedEntityList) {
            Entity entity = (Entity) objectEntity;
            if (entity instanceof EntityPlayer && entity != Minecraft.getMinecraft().thePlayer) {
                double pX = entity.lastTickPosX + (entity.posX - entity.lastTickPosX) * (double) Minecraft.getMinecraft().timer.renderPartialTicks - RenderManager.renderPosX;
                double pY = entity.lastTickPosY + (entity.posY - entity.lastTickPosY) * (double) Minecraft.getMinecraft().timer.renderPartialTicks - RenderManager.renderPosY;
                double pZ = entity.lastTickPosZ + (entity.posZ - entity.lastTickPosZ) * (double) Minecraft.getMinecraft().timer.renderPartialTicks - RenderManager.renderPosZ;
                convert2d(entity, pX, pY, pZ, 0.1F, 1.0F, 0.1F, 0.7F);
            }
        }
    }

    public float[] getBoundingBoxes(Entity e) {
        if (this.upperPos1.containsKey(e) && (upperPos1.get(e)[2] >= 0 && upperPos1.get(e)[2] < 1) ) {
            float xu1 = upperPos1.get(e)[0];
            float yu1 = upperPos1.get(e)[1];
            float xu2 = upperPos2.get(e)[0];
            float yu2 = upperPos2.get(e)[1];
            float xu3 = upperPos3.get(e)[0];
            float yu3 = upperPos3.get(e)[1];
            float xu4 = upperPos4.get(e)[0];
            float yu4 = upperPos4.get(e)[1];
            float xl1 = lowerPos1.get(e)[0];
            float yl1 = lowerPos1.get(e)[1];
            float xl2 = lowerPos2.get(e)[0];
            float yl2 = lowerPos2.get(e)[1];
            float xl3 = lowerPos3.get(e)[0];
            float yl3 = lowerPos3.get(e)[1];
            float xl4 = lowerPos4.get(e)[0];
            float yl4 = lowerPos4.get(e)[1];
            float highestY = -Integer.MAX_VALUE;
            float lowestY = Integer.MAX_VALUE;
            float highestX = -Integer.MAX_VALUE;
            float lowestX = Integer.MAX_VALUE;
            //HIGHESTX;
            if (xu1 > highestX) {
                highestX = xu1;
            }
            if (xu2 > highestX) {
                highestX = xu2;
            }
            if (xu3 > highestX) {
                highestX = xu3;
            }
            if (xu4 > highestX) {
                highestX = xu4;
            }
            if (xl1 > highestX) {
                highestX = xl1;
            }
            if (xl2 > highestX) {
                highestX = xl2;
            }
            if (xl3 > highestX) {
                highestX = xl3;
            }
            if (xl4 > highestX) {
                highestX = xl4;
            }
            //LOWESTX
            if (xu1 < lowestX) {
                lowestX = xu1;
            }
            if (xu2 < lowestX) {
                lowestX = xu2;
            }
            if (xu3 < lowestX) {
                lowestX = xu3;
            }
            if (xu4 < lowestX) {
                lowestX = xu4;
            }
            if (xl1 < lowestX) {
                lowestX = xl1;
            }
            if (xl2 < lowestX) {
                lowestX = xl2;
            }
            if (xl3 < lowestX) {
                lowestX = xl3;
            }
            if (xl4 < lowestX) {
                lowestX = xl4;
            }
            //HIGHESTY;
            if (yu1 > highestY) {
                highestY = yu1;
            }
            if (yu2 > highestY) {
                highestY = yu2;
            }
            if (yu3 > highestY) {
                highestY = yu3;
            }
            if (yu4 > highestY) {
                highestY = yu4;
            }
            if (yl1 > highestY) {
                highestY = yl1;
            }
            if (yl2 > highestY) {
                highestY = yl2;
            }
            if (yl3 > highestY) {
                highestY = yl3;
            }
            if (yl4 > highestY) {
                highestY = yl4;
            }
            //LOWESTY
            if (yu1 < lowestY) {
                lowestY = yu1;
            }
            if (yu2 < lowestY) {
                lowestY = yu2;
            }
            if (yu3 < lowestY) {
                lowestY = yu3;
            }
            if (yu4 < lowestY) {
                lowestY = yu4;
            }
            if (yl1 < lowestY) {
                lowestY = yl1;
            }
            if (yl2 < lowestY) {
                lowestY = yl2;
            }
            if (yl3 < lowestY) {
                lowestY = yl3;
            }
            if (yl4 < lowestY) {
                lowestY = yl4;
            }
            return new float[]{highestX, highestY, lowestX, lowestY};
        }
        return new float[]{0, 0, 0, 0};
    }

    public float getHighestX(Entity entity) {
        return this.getBoundingBoxes(entity)[0];
    }

    public float getLowestX(Entity entity) {
        return this.getBoundingBoxes(entity)[2];
    }

    public float getHighestY(Entity entity) {
        return this.getBoundingBoxes(entity)[1];
    }

    public float getLowestY(Entity entity) {
        return this.getBoundingBoxes(entity)[3];
    }

    public void rectTexture(float x, float y, float w, float h, Texture texture, int color) {
        if (texture == null) {
            return;
        }
        GlStateManager.color(0, 0, 0);
        GL11.glColor4f(0, 0, 0, 0);

        x = Math.round(x);
        w = Math.round(w);
        y = Math.round(y);
        h = Math.round(h);

        float var11 = (float) (color >> 24 & 255) / 255.0F;
        float var6 = (float) (color >> 16 & 255) / 255.0F;
        float var7 = (float) (color >> 8 & 255) / 255.0F;
        float var8 = (float) (color & 255) / 255.0F;

        GlStateManager.enableBlend();
        GlStateManager.func_179090_x();
        GlStateManager.tryBlendFuncSeparate(770, 771, 1, 0);
        GlStateManager.color(var6, var7, var8, var11);

        GL11.glEnable(GL11.GL_BLEND);
        GL11.glEnable(GL11.GL_TEXTURE_2D);
        texture.bind();

        float tw = (w / texture.getTextureWidth()) / (w / texture.getImageWidth());
        float th = (h / texture.getTextureHeight()) / (h / texture.getImageHeight());

        GL11.glBegin(GL11.GL_QUADS);
        GL11.glTexCoord2f(0, 0);
        GL11.glVertex2f(x, y);
        GL11.glTexCoord2f(0, th);
        GL11.glVertex2f(x, y + h);
        GL11.glTexCoord2f(tw, th);
        GL11.glVertex2f(x + w, y + h);
        GL11.glTexCoord2f(tw, 0);
        GL11.glVertex2f(x + w, y);
        GL11.glEnd();
        GL11.glDisable(GL11.GL_TEXTURE_2D);
        GL11.glDisable(GL11.GL_BLEND);
        GlStateManager.func_179098_w();
        GlStateManager.disableBlend();
    }

    public void convert2d(Entity e, double posX, double posY, double posZ, float alpha, float red, float green, float blue) {
        if (e == Minecraft.getMinecraft().thePlayer) {
            return;
        }
        //TODO UPPER POSITIONS
        float[] upcoords1 = this.getScreenCoords(posX + e.width / 1.9, posY + e.height + 0.1, posZ - e.width / 1.9);
        float[] upcoords2 = this.getScreenCoords(posX + e.width / 1.9, posY + e.height + 0.1, posZ + e.width / 1.9);
        float[] upcoords3 = this.getScreenCoords(posX - e.width / 1.9, posY + e.height + 0.1, posZ - e.width / 1.9);
        float[] upcoords4 = this.getScreenCoords(posX - e.width / 1.9, posY + e.height + 0.1, posZ + e.width / 1.9);
        upperPos1.put(e, upcoords1);
        upperPos2.put(e, upcoords2);
        upperPos3.put(e, upcoords3);
        upperPos4.put(e, upcoords4);
        //TODO LOWER POSITIONS
        float[] lowcoords1 = this.getScreenCoords(posX + e.width / 1.9, posY, posZ - e.width / 1.9);
        float[] lowcoords2 = this.getScreenCoords(posX + e.width / 1.9, posY, posZ + e.width / 1.9);
        float[] lowcoords3 = this.getScreenCoords(posX - e.width / 1.9, posY, posZ - e.width / 1.9);
        float[] lowcoords4 = this.getScreenCoords(posX - e.width / 1.9, posY, posZ + e.width / 1.9);
        lowerPos1.put(e, lowcoords1);
        lowerPos2.put(e, lowcoords2);
        lowerPos3.put(e, lowcoords3);
        lowerPos4.put(e, lowcoords4);
        // }
    }

    public float[] getScreenCoords(double x, double y, double z) {
        FloatBuffer screenCoords = BufferUtils.createFloatBuffer(3);
        IntBuffer viewport = BufferUtils.createIntBuffer(16);
        FloatBuffer modelView = BufferUtils.createFloatBuffer(16);
        FloatBuffer projection = BufferUtils.createFloatBuffer(16);
        GL11.glGetFloat(GL11.GL_MODELVIEW_MATRIX, modelView);
        GL11.glGetFloat(GL11.GL_PROJECTION_MATRIX, projection);
        GL11.glGetInteger(GL11.GL_VIEWPORT, viewport);
        boolean result = GLU.gluProject((float) x, (float) y, (float) z, modelView, projection, viewport, screenCoords);
        ScaledResolution sr = new ScaledResolution();
        if (result) {
            return new float[]{screenCoords.get(0) / sr.getScaleFactor(), sr.getScaledHeight() - screenCoords.get(1) / sr.getScaleFactor(), screenCoords.get(2)};
        }
        return null;
    }


    public static HashMap<Category,Texture> getTextureForCategory = new HashMap<Category,Texture>();
    public static void loadTextures() {
        try {
            Texture iconPlayer = TextureLoader.getTexture("PNG", Main.getMain.getClass().getClassLoader().getResourceAsStream("assets/night/clickgui/hacks/player.png"));
            textureShutDown= TextureLoader.getTexture("PNG", Main.getMain.getClass().getClassLoader().getResourceAsStream("assets/night/clickgui/hacks/exit.png"));
            getTextureForCategory.put(Category.PLAYER,iconPlayer);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public static Texture textureShutDown;

    public static void drawTexture(Texture texture, float x, float y, float width, float height) {
        GL11.glPushMatrix();
        GL11.glEnable(GL11.GL_BLEND);
        GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
       // GL11.glScalef(0.25F, 0.25F, 0.25F);

     //   Minecraft.getMinecraft().getTextureManager().bindTexture(Minecraft.getMinecraft().fontRendererObj.locationFontTextureBase);
      //  TextureImpl.bindNone();

        float tw = (width / texture.getTextureWidth()) / (width / texture.getImageWidth());
        float th = (height/texture.getTextureHeight()) / (height / texture.getImageHeight());

        texture.bind();

        GL11.glBegin(GL11.GL_QUADS);
        GL11.glTexCoord2f(0, 0);
        GL11.glVertex2f(x, y);
        GL11.glTexCoord2f(0, th);
        GL11.glVertex2f(x, y + height);
        GL11.glTexCoord2f(tw, th);
        GL11.glVertex2f(x + width, y + height);
        GL11.glTexCoord2f(tw, 0);
        GL11.glVertex2f(x + width, y);
        GL11.glEnd();
        GL11.glDisable(GL11.GL_BLEND);
        GL11.glPopMatrix();
    }
}

minecraft_de_Client_Utils_RotationUtil.java

package de.Client.Utils;

import net.minecraft.client.Minecraft;
import net.minecraft.entity.Entity;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.entity.projectile.EntitySnowball;
import net.minecraft.util.EnumFacing;
import net.minecraft.util.MathHelper;

public class RotationUtil {

    private static Minecraft mc = Minecraft.getMinecraft();

    public static float[] getYawAndPitch(Entity entity) {
        double posX = entity.posX;
        double n = posX - mc.thePlayer.posX;
        double posZ = entity.posZ;
        double n2 = posZ - mc.thePlayer.posZ;
        return new float[] { (float) (Math.atan2(n2, n) * 180.0D / 3.141592653589793D) - 90.0F,
                (float) (Math.atan2(mc.thePlayer.posY + 0.12D - (entity.posY + 1.82D), MathHelper.sqrt_double(n + n2))
                        * 180.0D / 3.141592653589793D) };
    }

    public static float getDistanceBetweenAngles(float paramFloat) {
        float n = Math.abs(paramFloat - mc.thePlayer.rotationYaw) % 360.0F;
        if (n > 180.0F) {
            n = 360.0F - n;
        }
        return n;
    }

    public static float[] getEntityRotations(EntityPlayer player, Entity target) {
        double posX = target.posX - player.posX;
        double posY = target.posY + target.getEyeHeight() - (player.posY + player.getEyeHeight());
        double posZ = target.posZ - player.posZ;
        double var14 = MathHelper.sqrt_double(posX * posX + posZ * posZ);
        float yaw = (float) (Math.atan2(posZ, posX) * 180.0D / 3.141592653589793D) - 90.0F;
        float pitch = (float) -(Math.atan2(posY, var14) * 180.0D / 3.141592653589793D);
        return new float[] { yaw, pitch };
    }

    public static float getPitchChangeToEntity(Entity entity) {
        double deltaX = entity.posX - mc.thePlayer.posX;
        double deltaZ = entity.posZ - mc.thePlayer.posZ;
        double deltaY = entity.posY - 1.6D + entity.getEyeHeight() - mc.thePlayer.posY;
        double distanceXZ = MathHelper.sqrt_double(deltaX * deltaX + deltaZ * deltaZ);

        double pitchToEntity = -Math.toDegrees(Math.atan(deltaY / distanceXZ));

        return -MathHelper.wrapAngleTo180_float(mc.thePlayer.rotationPitch - (float) pitchToEntity);
    }

    public static float[] getAngles(Entity e) {
        return new float[] { getYawChangeToEntity(e) + mc.thePlayer.rotationYaw,
                getPitchChangeToEntity(e) + mc.thePlayer.rotationPitch };
    }

    public static float getYawChangeToEntity(Entity entity) {
        double deltaX = entity.posX - mc.thePlayer.posX;
        double deltaZ = entity.posZ - mc.thePlayer.posZ;
        double yawToEntity;
        if ((deltaZ < 0.0D) && (deltaX < 0.0D)) {
            yawToEntity = 90.0D + Math.toDegrees(Math.atan(deltaZ / deltaX));
        } else {
            if ((deltaZ < 0.0D) && (deltaX > 0.0D)) {
                yawToEntity = -90.0D + Math.toDegrees(Math.atan(deltaZ / deltaX));
            } else {
                yawToEntity = Math.toDegrees(-Math.atan(deltaX / deltaZ));
            }
        }
        return MathHelper.wrapAngleTo180_float(-(mc.thePlayer.rotationYaw - (float) yawToEntity));
    }

    public static float[] getFacingRotations(int x, int y, int z, EnumFacing facing) {
        Entity temp = new EntitySnowball(mc.theWorld);
        temp.posX = (x + 0.5D);
        temp.posY = (y + 0.5D);
        temp.posZ = (z + 0.5D);
        temp.posX += facing.getDirectionVec().getX() * 0.25D;
        temp.posY += facing.getDirectionVec().getY() * 0.25D;
        temp.posZ += facing.getDirectionVec().getZ() * 0.25D;
        return getAngles(temp);
    }

    public static float[] getRotationFromPosition(double x, double z, double y) {
        Minecraft.getMinecraft();
        double xDiff = x - Minecraft.getMinecraft().thePlayer.posX;
        Minecraft.getMinecraft();
        double zDiff = z - Minecraft.getMinecraft().thePlayer.posZ;
        Minecraft.getMinecraft();
        Minecraft.getMinecraft();
        double yDiff = y - Minecraft.getMinecraft().thePlayer.posY + Minecraft.getMinecraft().thePlayer.getEyeHeight();
        double dist = MathHelper.sqrt_double(xDiff * xDiff + zDiff * zDiff);
        float yaw = (float) (Math.atan2(zDiff, xDiff) * 180.0D / 3.141592653589793D) - 90.0F;
        float pitch = (float) -(Math.atan2(yDiff, dist) * 180.0D / 3.141592653589793D);
        return new float[] { yaw, pitch };
    }

    public static float[] getRotations(Entity ent) {
        double x = ent.posX;
        double z = ent.posZ;
        double y = ent.boundingBox.maxY - 4.5D;
        return getRotationFromPosition(x, z, y);
    }

    public static float getDistanceBetweenAngles(float angle1, float angle2) {
        float angle = Math.abs(angle1 - angle2) % 360.0F;
        if (angle > 180.0F) {
            angle = 360.0F - angle;
        }
        return angle;
    }
}

minecraft_de_Client_Utils_ShaderResourcepack.java

package de.Client.Utils;

import de.Client.Main.Main;
import de.Client.Main.Modules.mods.Render.BetterOverlay;
import net.minecraft.client.resources.IResourceManager;
import net.minecraft.util.ResourceLocation;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class ShaderResourcepack{


    private final Map<ResourceLocation, String> loadedData;

    public ShaderResourcepack() {
        this.loadedData = new HashMap<ResourceLocation, String>();
    }
    public void func_110549_a(final IResourceManager resourceManager) {
        this.loadedData.clear();
    }
    public InputStream func_110590_a(final ResourceLocation location) throws IOException {
        // final InputStream in;

        final String s = this.loadedData.computeIfAbsent(location, loc -> {
            final InputStream  in = BetterOverlay.class.getResourceAsStream("/" + location.getResourceDomain());
            final StringBuilder data = new StringBuilder();
            final Scanner scan = new Scanner(in);
            try {
                while (scan.hasNextLine()) {
                    BetterOverlay b = (BetterOverlay) Main.getMain.moduleManager.getModule(BetterOverlay.class);
                    data.append(scan.nextLine().replaceAll("@radius@", Integer.toString(b.radius))).append('\n');
                }
            }
            finally {
                scan.close();
            }
            return data.toString();
        });
        return new ByteArrayInputStream(s.getBytes());
    }
}

minecraft_de_Client_Utils_TabGui.java

package de.Client.Utils;

import de.Client.Main.Modules.Category;

/**
 * Created by Daniel on 13.07.2017.
 */
public class TabGui {
    public TabGui(){

    }
    public TabGui getTabGui() {
        return this;
    }
    public void upKey() {
    }
    public void downKey() {
    }
    public void rightKey() {
    }
    public void leftKey() {
    }
    public void returnKey() {
    }
    public void drawTabGui() {
    }
    public void upDateAnimations(){
    }
}

minecraft_de_Client_Utils_TimeHelper.java

package de.Client.Utils;

public class TimeHelper {
	
	private long lastMS = 0L;

	public boolean isDelayComplete(long delay) {
        return System.currentTimeMillis() - this.lastMS >= delay;
    }

	public void setLastMS(long lastMS) {
		this.lastMS = lastMS;
	}

	public void setLastMS() {
		this.lastMS = System.currentTimeMillis();
	}

	public int convertToMS(int perSecond) {
		return 1000 / perSecond;
	}

	public long getCurrentMS() {
		return System.nanoTime() / 1000000L;
	}

	public double hasreachednow(){
		return getCurrentMS() - this.lastMS;
	}
	public boolean hasReached(long milliseconds) {
		return getCurrentMS() - this.lastMS >= milliseconds;
	}

	public void reset() {
		this.lastMS = getCurrentMS();
	}
	
	// NEU
	public long getTime() {
		return System.nanoTime() / 1000000L;
	}

	public boolean delay(double d) {
		if (getTime() - getLastMS() >= d) {
			reset();
			return true;
		}
		return false;
	}

	public long getLastMS() {
		return this.lastMS;
	}
	
	public final void updateLastMS() {
		this.lastMS = System.currentTimeMillis();
	}
}

minecraft_de_Client_Utils_Watermark.java

package de.Client.Utils;

/**
 * Created by Daniel on 13.07.2017.
 */
public class Watermark {
    public Watermark(){

    }
    public double getHeight(){
        return 0;
    }
    public void drawWaterMark(double scaledX,double scaledY){

    }
}

minecraft_META-INF_MANIFEST.MF

Manifest-Version: 1.0
Main-Class: net.minecraft.client.main;

minecraft_minecraft_blockstates_black_stained_glass_pane.json

{
    "variants": {
        "east=false,north=false,south=false,west=false": { "model": "black_pane_nsew" },
        "east=false,north=true,south=false,west=false": { "model": "black_pane_n" },
        "east=true,north=false,south=false,west=false": { "model": "black_pane_n", "y": 90 },
        "east=false,north=false,south=true,west=false": { "model": "black_pane_n", "y": 180 },
        "east=false,north=false,south=false,west=true": { "model": "black_pane_n", "y": 270 },
        "east=true,north=true,south=false,west=false": { "model": "black_pane_ne" },
        "east=true,north=false,south=true,west=false": { "model": "black_pane_ne", "y": 90 },
        "east=false,north=false,south=true,west=true": { "model": "black_pane_ne", "y": 180 },
        "east=false,north=true,south=false,west=true": { "model": "black_pane_ne", "y": 270 },
        "east=false,north=true,south=true,west=false": { "model": "black_pane_ns" },
        "east=true,north=false,south=false,west=true": { "model": "black_pane_ns", "y": 90 },
        "east=true,north=true,south=true,west=false": { "model": "black_pane_nse" },
        "east=true,north=false,south=true,west=true": { "model": "black_pane_nse", "y": 90 },
        "east=false,north=true,south=true,west=true": { "model": "black_pane_nse", "y": 180 },
        "east=true,north=true,south=false,west=true": { "model": "black_pane_nse", "y": 270 },
        "east=true,north=true,south=true,west=true": { "model": "black_pane_nsew" }
    }
}

minecraft_minecraft_blockstates_blue_stained_glass_pane.json

{
    "variants": {
        "east=false,north=false,south=false,west=false": { "model": "blue_pane_nsew" },
        "east=false,north=true,south=false,west=false": { "model": "blue_pane_n" },
        "east=true,north=false,south=false,west=false": { "model": "blue_pane_n", "y": 90 },
        "east=false,north=false,south=true,west=false": { "model": "blue_pane_n", "y": 180 },
        "east=false,north=false,south=false,west=true": { "model": "blue_pane_n", "y": 270 },
        "east=true,north=true,south=false,west=false": { "model": "blue_pane_ne" },
        "east=true,north=false,south=true,west=false": { "model": "blue_pane_ne", "y": 90 },
        "east=false,north=false,south=true,west=true": { "model": "blue_pane_ne", "y": 180 },
        "east=false,north=true,south=false,west=true": { "model": "blue_pane_ne", "y": 270 },
        "east=false,north=true,south=true,west=false": { "model": "blue_pane_ns" },
        "east=true,north=false,south=false,west=true": { "model": "blue_pane_ns", "y": 90 },
        "east=true,north=true,south=true,west=false": { "model": "blue_pane_nse" },
        "east=true,north=false,south=true,west=true": { "model": "blue_pane_nse", "y": 90 },
        "east=false,north=true,south=true,west=true": { "model": "blue_pane_nse", "y": 180 },
        "east=true,north=true,south=false,west=true": { "model": "blue_pane_nse", "y": 270 },
        "east=true,north=true,south=true,west=true": { "model": "blue_pane_nsew" }
    }
}

minecraft_minecraft_blockstates_brown_stained_glass_pane.json

{
    "variants": {
        "east=false,north=false,south=false,west=false": { "model": "brown_pane_nsew" },
        "east=false,north=true,south=false,west=false": { "model": "brown_pane_n" },
        "east=true,north=false,south=false,west=false": { "model": "brown_pane_n", "y": 90 },
        "east=false,north=false,south=true,west=false": { "model": "brown_pane_n", "y": 180 },
        "east=false,north=false,south=false,west=true": { "model": "brown_pane_n", "y": 270 },
        "east=true,north=true,south=false,west=false": { "model": "brown_pane_ne" },
        "east=true,north=false,south=true,west=false": { "model": "brown_pane_ne", "y": 90 },
        "east=false,north=false,south=true,west=true": { "model": "brown_pane_ne", "y": 180 },
        "east=false,north=true,south=false,west=true": { "model": "brown_pane_ne", "y": 270 },
        "east=false,north=true,south=true,west=false": { "model": "brown_pane_ns" },
        "east=true,north=false,south=false,west=true": { "model": "brown_pane_ns", "y": 90 },
        "east=true,north=true,south=true,west=false": { "model": "brown_pane_nse" },
        "east=true,north=false,south=true,west=true": { "model": "brown_pane_nse", "y": 90 },
        "east=false,north=true,south=true,west=true": { "model": "brown_pane_nse", "y": 180 },
        "east=true,north=true,south=false,west=true": { "model": "brown_pane_nse", "y": 270 },
        "east=true,north=true,south=true,west=true": { "model": "brown_pane_nsew" }
    }
}

minecraft_minecraft_blockstates_cyan_stained_glass_pane.json

{
    "variants": {
        "east=false,north=false,south=false,west=false": { "model": "cyan_pane_nsew" },
        "east=false,north=true,south=false,west=false": { "model": "cyan_pane_n" },
        "east=true,north=false,south=false,west=false": { "model": "cyan_pane_n", "y": 90 },
        "east=false,north=false,south=true,west=false": { "model": "cyan_pane_n", "y": 180 },
        "east=false,north=false,south=false,west=true": { "model": "cyan_pane_n", "y": 270 },
        "east=true,north=true,south=false,west=false": { "model": "cyan_pane_ne" },
        "east=true,north=false,south=true,west=false": { "model": "cyan_pane_ne", "y": 90 },
        "east=false,north=false,south=true,west=true": { "model": "cyan_pane_ne", "y": 180 },
        "east=false,north=true,south=false,west=true": { "model": "cyan_pane_ne", "y": 270 },
        "east=false,north=true,south=true,west=false": { "model": "cyan_pane_ns" },
        "east=true,north=false,south=false,west=true": { "model": "cyan_pane_ns", "y": 90 },
        "east=true,north=true,south=true,west=false": { "model": "cyan_pane_nse" },
        "east=true,north=false,south=true,west=true": { "model": "cyan_pane_nse", "y": 90 },
        "east=false,north=true,south=true,west=true": { "model": "cyan_pane_nse", "y": 180 },
        "east=true,north=true,south=false,west=true": { "model": "cyan_pane_nse", "y": 270 },
        "east=true,north=true,south=true,west=true": { "model": "cyan_pane_nsew" }
    }
}

minecraft_minecraft_blockstates_gray_stained_glass_pane.json

{
    "variants": {
        "east=false,north=false,south=false,west=false": { "model": "gray_pane_nsew" },
        "east=false,north=true,south=false,west=false": { "model": "gray_pane_n" },
        "east=true,north=false,south=false,west=false": { "model": "gray_pane_n", "y": 90 },
        "east=false,north=false,south=true,west=false": { "model": "gray_pane_n", "y": 180 },
        "east=false,north=false,south=false,west=true": { "model": "gray_pane_n", "y": 270 },
        "east=true,north=true,south=false,west=false": { "model": "gray_pane_ne" },
        "east=true,north=false,south=true,west=false": { "model": "gray_pane_ne", "y": 90 },
        "east=false,north=false,south=true,west=true": { "model": "gray_pane_ne", "y": 180 },
        "east=false,north=true,south=false,west=true": { "model": "gray_pane_ne", "y": 270 },
        "east=false,north=true,south=true,west=false": { "model": "gray_pane_ns" },
        "east=true,north=false,south=false,west=true": { "model": "gray_pane_ns", "y": 90 },
        "east=true,north=true,south=true,west=false": { "model": "gray_pane_nse" },
        "east=true,north=false,south=true,west=true": { "model": "gray_pane_nse", "y": 90 },
        "east=false,north=true,south=true,west=true": { "model": "gray_pane_nse", "y": 180 },
        "east=true,north=true,south=false,west=true": { "model": "gray_pane_nse", "y": 270 },
        "east=true,north=true,south=true,west=true": { "model": "gray_pane_nsew" }
    }
}

minecraft_minecraft_blockstates_green_stained_glass_pane.json

{
    "variants": {
        "east=false,north=false,south=false,west=false": { "model": "green_pane_nsew" },
        "east=false,north=true,south=false,west=false": { "model": "green_pane_n" },
        "east=true,north=false,south=false,west=false": { "model": "green_pane_n", "y": 90 },
        "east=false,north=false,south=true,west=false": { "model": "green_pane_n", "y": 180 },
        "east=false,north=false,south=false,west=true": { "model": "green_pane_n", "y": 270 },
        "east=true,north=true,south=false,west=false": { "model": "green_pane_ne" },
        "east=true,north=false,south=true,west=false": { "model": "green_pane_ne", "y": 90 },
        "east=false,north=false,south=true,west=true": { "model": "green_pane_ne", "y": 180 },
        "east=false,north=true,south=false,west=true": { "model": "green_pane_ne", "y": 270 },
        "east=false,north=true,south=true,west=false": { "model": "green_pane_ns" },
        "east=true,north=false,south=false,west=true": { "model": "green_pane_ns", "y": 90 },
        "east=true,north=true,south=true,west=false": { "model": "green_pane_nse" },
        "east=true,north=false,south=true,west=true": { "model": "green_pane_nse", "y": 90 },
        "east=false,north=true,south=true,west=true": { "model": "green_pane_nse", "y": 180 },
        "east=true,north=true,south=false,west=true": { "model": "green_pane_nse", "y": 270 },
        "east=true,north=true,south=true,west=true": { "model": "green_pane_nsew" }
    }
}

minecraft_minecraft_blockstates_light_blue_stained_glass_pane.json

{
    "variants": {
        "east=false,north=false,south=false,west=false": { "model": "light_blue_pane_nsew" },
        "east=false,north=true,south=false,west=false": { "model": "light_blue_pane_n" },
        "east=true,north=false,south=false,west=false": { "model": "light_blue_pane_n", "y": 90 },
        "east=false,north=false,south=true,west=false": { "model": "light_blue_pane_n", "y": 180 },
        "east=false,north=false,south=false,west=true": { "model": "light_blue_pane_n", "y": 270 },
        "east=true,north=true,south=false,west=false": { "model": "light_blue_pane_ne" },
        "east=true,north=false,south=true,west=false": { "model": "light_blue_pane_ne", "y": 90 },
        "east=false,north=false,south=true,west=true": { "model": "light_blue_pane_ne", "y": 180 },
        "east=false,north=true,south=false,west=true": { "model": "light_blue_pane_ne", "y": 270 },
        "east=false,north=true,south=true,west=false": { "model": "light_blue_pane_ns" },
        "east=true,north=false,south=false,west=true": { "model": "light_blue_pane_ns", "y": 90 },
        "east=true,north=true,south=true,west=false": { "model": "light_blue_pane_nse" },
        "east=true,north=false,south=true,west=true": { "model": "light_blue_pane_nse", "y": 90 },
        "east=false,north=true,south=true,west=true": { "model": "light_blue_pane_nse", "y": 180 },
        "east=true,north=true,south=false,west=true": { "model": "light_blue_pane_nse", "y": 270 },
        "east=true,north=true,south=true,west=true": { "model": "light_blue_pane_nsew" }
    }
}

minecraft_minecraft_blockstates_lime_stained_glass_pane.json

{
    "variants": {
        "east=false,north=false,south=false,west=false": { "model": "lime_pane_nsew" },
        "east=false,north=true,south=false,west=false": { "model": "lime_pane_n" },
        "east=true,north=false,south=false,west=false": { "model": "lime_pane_n", "y": 90 },
        "east=false,north=false,south=true,west=false": { "model": "lime_pane_n", "y": 180 },
        "east=false,north=false,south=false,west=true": { "model": "lime_pane_n", "y": 270 },
        "east=true,north=true,south=false,west=false": { "model": "lime_pane_ne" },
        "east=true,north=false,south=true,west=false": { "model": "lime_pane_ne", "y": 90 },
        "east=false,north=false,south=true,west=true": { "model": "lime_pane_ne", "y": 180 },
        "east=false,north=true,south=false,west=true": { "model": "lime_pane_ne", "y": 270 },
        "east=false,north=true,south=true,west=false": { "model": "lime_pane_ns" },
        "east=true,north=false,south=false,west=true": { "model": "lime_pane_ns", "y": 90 },
        "east=true,north=true,south=true,west=false": { "model": "lime_pane_nse" },
        "east=true,north=false,south=true,west=true": { "model": "lime_pane_nse", "y": 90 },
        "east=false,north=true,south=true,west=true": { "model": "lime_pane_nse", "y": 180 },
        "east=true,north=true,south=false,west=true": { "model": "lime_pane_nse", "y": 270 },
        "east=true,north=true,south=true,west=true": { "model": "lime_pane_nsew" }
    }
}

minecraft_minecraft_blockstates_magenta_stained_glass_pane.json

{
    "variants": {
        "east=false,north=false,south=false,west=false": { "model": "magenta_pane_nsew" },
        "east=false,north=true,south=false,west=false": { "model": "magenta_pane_n" },
        "east=true,north=false,south=false,west=false": { "model": "magenta_pane_n", "y": 90 },
        "east=false,north=false,south=true,west=false": { "model": "magenta_pane_n", "y": 180 },
        "east=false,north=false,south=false,west=true": { "model": "magenta_pane_n", "y": 270 },
        "east=true,north=true,south=false,west=false": { "model": "magenta_pane_ne" },
        "east=true,north=false,south=true,west=false": { "model": "magenta_pane_ne", "y": 90 },
        "east=false,north=false,south=true,west=true": { "model": "magenta_pane_ne", "y": 180 },
        "east=false,north=true,south=false,west=true": { "model": "magenta_pane_ne", "y": 270 },
        "east=false,north=true,south=true,west=false": { "model": "magenta_pane_ns" },
        "east=true,north=false,south=false,west=true": { "model": "magenta_pane_ns", "y": 90 },
        "east=true,north=true,south=true,west=false": { "model": "magenta_pane_nse" },
        "east=true,north=false,south=true,west=true": { "model": "magenta_pane_nse", "y": 90 },
        "east=false,north=true,south=true,west=true": { "model": "magenta_pane_nse", "y": 180 },
        "east=true,north=true,south=false,west=true": { "model": "magenta_pane_nse", "y": 270 },
        "east=true,north=true,south=true,west=true": { "model": "magenta_pane_nsew" }
    }
}

minecraft_minecraft_blockstates_orange_stained_glass_pane.json

{
    "variants": {
        "east=false,north=false,south=false,west=false": { "model": "orange_pane_nsew" },
        "east=false,north=true,south=false,west=false": { "model": "orange_pane_n" },
        "east=true,north=false,south=false,west=false": { "model": "orange_pane_n", "y": 90 },
        "east=false,north=false,south=true,west=false": { "model": "orange_pane_n", "y": 180 },
        "east=false,north=false,south=false,west=true": { "model": "orange_pane_n", "y": 270 },
        "east=true,north=true,south=false,west=false": { "model": "orange_pane_ne" },
        "east=true,north=false,south=true,west=false": { "model": "orange_pane_ne", "y": 90 },
        "east=false,north=false,south=true,west=true": { "model": "orange_pane_ne", "y": 180 },
        "east=false,north=true,south=false,west=true": { "model": "orange_pane_ne", "y": 270 },
        "east=false,north=true,south=true,west=false": { "model": "orange_pane_ns" },
        "east=true,north=false,south=false,west=true": { "model": "orange_pane_ns", "y": 90 },
        "east=true,north=true,south=true,west=false": { "model": "orange_pane_nse" },
        "east=true,north=false,south=true,west=true": { "model": "orange_pane_nse", "y": 90 },
        "east=false,north=true,south=true,west=true": { "model": "orange_pane_nse", "y": 180 },
        "east=true,north=true,south=false,west=true": { "model": "orange_pane_nse", "y": 270 },
        "east=true,north=true,south=true,west=true": { "model": "orange_pane_nsew" }
    }
}

minecraft_minecraft_blockstates_pink_stained_glass_pane.json

{
    "variants": {
        "east=false,north=false,south=false,west=false": { "model": "pink_pane_nsew" },
        "east=false,north=true,south=false,west=false": { "model": "pink_pane_n" },
        "east=true,north=false,south=false,west=false": { "model": "pink_pane_n", "y": 90 },
        "east=false,north=false,south=true,west=false": { "model": "pink_pane_n", "y": 180 },
        "east=false,north=false,south=false,west=true": { "model": "pink_pane_n", "y": 270 },
        "east=true,north=true,south=false,west=false": { "model": "pink_pane_ne" },
        "east=true,north=false,south=true,west=false": { "model": "pink_pane_ne", "y": 90 },
        "east=false,north=false,south=true,west=true": { "model": "pink_pane_ne", "y": 180 },
        "east=false,north=true,south=false,west=true": { "model": "pink_pane_ne", "y": 270 },
        "east=false,north=true,south=true,west=false": { "model": "pink_pane_ns" },
        "east=true,north=false,south=false,west=true": { "model": "pink_pane_ns", "y": 90 },
        "east=true,north=true,south=true,west=false": { "model": "pink_pane_nse" },
        "east=true,north=false,south=true,west=true": { "model": "pink_pane_nse", "y": 90 },
        "east=false,north=true,south=true,west=true": { "model": "pink_pane_nse", "y": 180 },
        "east=true,north=true,south=false,west=true": { "model": "pink_pane_nse", "y": 270 },
        "east=true,north=true,south=true,west=true": { "model": "pink_pane_nsew" }
    }
}

minecraft_minecraft_blockstates_purple_stained_glass_pane.json

{
    "variants": {
        "east=false,north=false,south=false,west=false": { "model": "purple_pane_nsew" },
        "east=false,north=true,south=false,west=false": { "model": "purple_pane_n" },
        "east=true,north=false,south=false,west=false": { "model": "purple_pane_n", "y": 90 },
        "east=false,north=false,south=true,west=false": { "model": "purple_pane_n", "y": 180 },
        "east=false,north=false,south=false,west=true": { "model": "purple_pane_n", "y": 270 },
        "east=true,north=true,south=false,west=false": { "model": "purple_pane_ne" },
        "east=true,north=false,south=true,west=false": { "model": "purple_pane_ne", "y": 90 },
        "east=false,north=false,south=true,west=true": { "model": "purple_pane_ne", "y": 180 },
        "east=false,north=true,south=false,west=true": { "model": "purple_pane_ne", "y": 270 },
        "east=false,north=true,south=true,west=false": { "model": "purple_pane_ns" },
        "east=true,north=false,south=false,west=true": { "model": "purple_pane_ns", "y": 90 },
        "east=true,north=true,south=true,west=false": { "model": "purple_pane_nse" },
        "east=true,north=false,south=true,west=true": { "model": "purple_pane_nse", "y": 90 },
        "east=false,north=true,south=true,west=true": { "model": "purple_pane_nse", "y": 180 },
        "east=true,north=true,south=false,west=true": { "model": "purple_pane_nse", "y": 270 },
        "east=true,north=true,south=true,west=true": { "model": "purple_pane_nsew" }
    }
}

minecraft_minecraft_blockstates_red_stained_glass_pane.json

{
    "variants": {
        "east=false,north=false,south=false,west=false": { "model": "red_pane_nsew" },
        "east=false,north=true,south=false,west=false": { "model": "red_pane_n" },
        "east=true,north=false,south=false,west=false": { "model": "red_pane_n", "y": 90 },
        "east=false,north=false,south=true,west=false": { "model": "red_pane_n", "y": 180 },
        "east=false,north=false,south=false,west=true": { "model": "red_pane_n", "y": 270 },
        "east=true,north=true,south=false,west=false": { "model": "red_pane_ne" },
        "east=true,north=false,south=true,west=false": { "model": "red_pane_ne", "y": 90 },
        "east=false,north=false,south=true,west=true": { "model": "red_pane_ne", "y": 180 },
        "east=false,north=true,south=false,west=true": { "model": "red_pane_ne", "y": 270 },
        "east=false,north=true,south=true,west=false": { "model": "red_pane_ns" },
        "east=true,north=false,south=false,west=true": { "model": "red_pane_ns", "y": 90 },
        "east=true,north=true,south=true,west=false": { "model": "red_pane_nse" },
        "east=true,north=false,south=true,west=true": { "model": "red_pane_nse", "y": 90 },
        "east=false,north=true,south=true,west=true": { "model": "red_pane_nse", "y": 180 },
        "east=true,north=true,south=false,west=true": { "model": "red_pane_nse", "y": 270 },
        "east=true,north=true,south=true,west=true": { "model": "red_pane_nsew" }
    }
}

minecraft_minecraft_blockstates_silver_stained_glass_pane.json

{
    "variants": {
        "east=false,north=false,south=false,west=false": { "model": "silver_pane_nsew" },
        "east=false,north=true,south=false,west=false": { "model": "silver_pane_n" },
        "east=true,north=false,south=false,west=false": { "model": "silver_pane_n", "y": 90 },
        "east=false,north=false,south=true,west=false": { "model": "silver_pane_n", "y": 180 },
        "east=false,north=false,south=false,west=true": { "model": "silver_pane_n", "y": 270 },
        "east=true,north=true,south=false,west=false": { "model": "silver_pane_ne" },
        "east=true,north=false,south=true,west=false": { "model": "silver_pane_ne", "y": 90 },
        "east=false,north=false,south=true,west=true": { "model": "silver_pane_ne", "y": 180 },
        "east=false,north=true,south=false,west=true": { "model": "silver_pane_ne", "y": 270 },
        "east=false,north=true,south=true,west=false": { "model": "silver_pane_ns" },
        "east=true,north=false,south=false,west=true": { "model": "silver_pane_ns", "y": 90 },
        "east=true,north=true,south=true,west=false": { "model": "silver_pane_nse" },
        "east=true,north=false,south=true,west=true": { "model": "silver_pane_nse", "y": 90 },
        "east=false,north=true,south=true,west=true": { "model": "silver_pane_nse", "y": 180 },
        "east=true,north=true,south=false,west=true": { "model": "silver_pane_nse", "y": 270 },
        "east=true,north=true,south=true,west=true": { "model": "silver_pane_nsew" }
    }
}

minecraft_minecraft_blockstates_white_stained_glass_pane.json

{
    "variants": {
        "east=false,north=false,south=false,west=false": { "model": "white_pane_nsew" },
        "east=false,north=true,south=false,west=false": { "model": "white_pane_n" },
        "east=true,north=false,south=false,west=false": { "model": "white_pane_n", "y": 90 },
        "east=false,north=false,south=true,west=false": { "model": "white_pane_n", "y": 180 },
        "east=false,north=false,south=false,west=true": { "model": "white_pane_n", "y": 270 },
        "east=true,north=true,south=false,west=false": { "model": "white_pane_ne" },
        "east=true,north=false,south=true,west=false": { "model": "white_pane_ne", "y": 90 },
        "east=false,north=false,south=true,west=true": { "model": "white_pane_ne", "y": 180 },
        "east=false,north=true,south=false,west=true": { "model": "white_pane_ne", "y": 270 },
        "east=false,north=true,south=true,west=false": { "model": "white_pane_ns" },
        "east=true,north=false,south=false,west=true": { "model": "white_pane_ns", "y": 90 },
        "east=true,north=true,south=true,west=false": { "model": "white_pane_nse" },
        "east=true,north=false,south=true,west=true": { "model": "white_pane_nse", "y": 90 },
        "east=false,north=true,south=true,west=true": { "model": "white_pane_nse", "y": 180 },
        "east=true,north=true,south=false,west=true": { "model": "white_pane_nse", "y": 270 },
        "east=true,north=true,south=true,west=true": { "model": "white_pane_nsew" }
    }
}

minecraft_minecraft_blockstates_yellow_stained_glass_pane.json

{
    "variants": {
        "east=false,north=false,south=false,west=false": { "model": "yellow_pane_nsew" },
        "east=false,north=true,south=false,west=false": { "model": "yellow_pane_n" },
        "east=true,north=false,south=false,west=false": { "model": "yellow_pane_n", "y": 90 },
        "east=false,north=false,south=true,west=false": { "model": "yellow_pane_n", "y": 180 },
        "east=false,north=false,south=false,west=true": { "model": "yellow_pane_n", "y": 270 },
        "east=true,north=true,south=false,west=false": { "model": "yellow_pane_ne" },
        "east=true,north=false,south=true,west=false": { "model": "yellow_pane_ne", "y": 90 },
        "east=false,north=false,south=true,west=true": { "model": "yellow_pane_ne", "y": 180 },
        "east=false,north=true,south=false,west=true": { "model": "yellow_pane_ne", "y": 270 },
        "east=false,north=true,south=true,west=false": { "model": "yellow_pane_ns" },
        "east=true,north=false,south=false,west=true": { "model": "yellow_pane_ns", "y": 90 },
        "east=true,north=true,south=true,west=false": { "model": "yellow_pane_nse" },
        "east=true,north=false,south=true,west=true": { "model": "yellow_pane_nse", "y": 90 },
        "east=false,north=true,south=true,west=true": { "model": "yellow_pane_nse", "y": 180 },
        "east=true,north=true,south=false,west=true": { "model": "yellow_pane_nse", "y": 270 },
        "east=true,north=true,south=true,west=true": { "model": "yellow_pane_nsew" }
    }
}

minecraft_minecraft_mcpatcher_ctm_default_0_glass_white_glass_pane_white.properties

# Stained glass white
matchBlocks=160
metadata=0
connect=block
method=ctm
tiles=0-11 16-27 32-43 48-58

minecraft_minecraft_mcpatcher_ctm_default_0_glass_white_glass_white.properties

# Stained glass white
matchBlocks=95
metadata=0
connect=block
method=ctm
tiles=0-11 16-27 32-43 48-58

minecraft_minecraft_mcpatcher_ctm_default_10_glass_purple_glass_pane_purple.properties

# Stained glass purple
matchBlocks=160
metadata=10
connect=block
method=ctm
tiles=0-11 16-27 32-43 48-58

minecraft_minecraft_mcpatcher_ctm_default_10_glass_purple_glass_purple.properties

# Stained glass purple
matchBlocks=95
metadata=10
connect=block
method=ctm
tiles=0-11 16-27 32-43 48-58

minecraft_minecraft_mcpatcher_ctm_default_11_glass_blue_glass_blue.properties

# Stained glass blue
matchBlocks=95
metadata=11
connect=block
method=ctm
tiles=0-11 16-27 32-43 48-58

minecraft_minecraft_mcpatcher_ctm_default_11_glass_blue_glass_pane_blue.properties

# Stained glass blue
matchBlocks=160
metadata=11
connect=block
method=ctm
tiles=0-11 16-27 32-43 48-58

minecraft_minecraft_mcpatcher_ctm_default_12_glass_brown_glass_brown.properties

# Stained glass brown
matchBlocks=95
metadata=12
connect=block
method=ctm
tiles=0-11 16-27 32-43 48-58

minecraft_minecraft_mcpatcher_ctm_default_12_glass_brown_glass_pane_brown.properties

# Stained glass brown
matchBlocks=160
metadata=12
connect=block
method=ctm
tiles=0-11 16-27 32-43 48-58

minecraft_minecraft_mcpatcher_ctm_default_13_glass_green_glass_green.properties

# Stained glass green
matchBlocks=95
metadata=13
connect=block
method=ctm
tiles=0-11 16-27 32-43 48-58

minecraft_minecraft_mcpatcher_ctm_default_13_glass_green_glass_pane_green.properties

# Stained glass green
matchBlocks=160
metadata=13
connect=block
method=ctm
tiles=0-11 16-27 32-43 48-58

minecraft_minecraft_mcpatcher_ctm_default_14_glass_red_glass_pane_red.properties

# Stained glass red
matchBlocks=160
metadata=14
connect=block
method=ctm
tiles=0-11 16-27 32-43 48-58

minecraft_minecraft_mcpatcher_ctm_default_14_glass_red_glass_red.properties

# Stained glass red
matchBlocks=95
metadata=14
connect=block
method=ctm
tiles=0-11 16-27 32-43 48-58

minecraft_minecraft_mcpatcher_ctm_default_15_glass_black_glass_black.properties

# Stained glass black
matchBlocks=95
metadata=15
connect=block
method=ctm
tiles=0-11 16-27 32-43 48-58

minecraft_minecraft_mcpatcher_ctm_default_15_glass_black_glass_pane_black.properties

# Stained glass black
matchBlocks=160
metadata=15
connect=block
method=ctm
tiles=0-11 16-27 32-43 48-58

minecraft_minecraft_mcpatcher_ctm_default_1_glass_orange_glass_orange.properties

# Stained glass orange
matchBlocks=95
metadata=1
connect=block
method=ctm
tiles=0-11 16-27 32-43 48-58

minecraft_minecraft_mcpatcher_ctm_default_1_glass_orange_glass_pane_orange.properties

# Stained glass orange
matchBlocks=160
metadata=1
connect=block
method=ctm
tiles=0-11 16-27 32-43 48-58

minecraft_minecraft_mcpatcher_ctm_default_2_glass_magenta_glass_magenta.properties

# Stained glass magenta
matchBlocks=95
metadata=2
connect=block
method=ctm
tiles=0-11 16-27 32-43 48-58

minecraft_minecraft_mcpatcher_ctm_default_2_glass_magenta_glass_pane_magenta.properties

# Stained glass magenta
matchBlocks=160
metadata=2
connect=block
method=ctm
tiles=0-11 16-27 32-43 48-58

minecraft_minecraft_mcpatcher_ctm_default_3_glass_light_blue_glass_light_blue.properties

# Stained glass light_blue
matchBlocks=95
metadata=3
connect=block
method=ctm
tiles=0-11 16-27 32-43 48-58

minecraft_minecraft_mcpatcher_ctm_default_3_glass_light_blue_glass_pane_light_blue.properties

# Stained glass light_blue
matchBlocks=160
metadata=3
connect=block
method=ctm
tiles=0-11 16-27 32-43 48-58

minecraft_minecraft_mcpatcher_ctm_default_4_glass_yellow_glass_pane_yellow.properties

# Stained glass yellow
matchBlocks=160
metadata=4
connect=block
method=ctm
tiles=0-11 16-27 32-43 48-58

minecraft_minecraft_mcpatcher_ctm_default_4_glass_yellow_glass_yellow.properties

# Stained glass yellow
matchBlocks=95
metadata=4
connect=block
method=ctm
tiles=0-11 16-27 32-43 48-58

minecraft_minecraft_mcpatcher_ctm_default_5_glass_lime_glass_lime.properties

# Stained glass lime
matchBlocks=95
metadata=5
connect=block
method=ctm
tiles=0-11 16-27 32-43 48-58

minecraft_minecraft_mcpatcher_ctm_default_5_glass_lime_glass_pane_lime.properties

# Stained glass lime
matchBlocks=160
metadata=5
connect=block
method=ctm
tiles=0-11 16-27 32-43 48-58

minecraft_minecraft_mcpatcher_ctm_default_6_glass_pink_glass_pane_pink.properties

# Stained glass pink
matchBlocks=160
metadata=6
connect=block
method=ctm
tiles=0-11 16-27 32-43 48-58

minecraft_minecraft_mcpatcher_ctm_default_6_glass_pink_glass_pink.properties

# Stained glass pink
matchBlocks=95
metadata=6
connect=block
method=ctm
tiles=0-11 16-27 32-43 48-58

minecraft_minecraft_mcpatcher_ctm_default_7_glass_gray_glass_gray.properties

# Stained glass gray
matchBlocks=95
metadata=7
connect=block
method=ctm
tiles=0-11 16-27 32-43 48-58

minecraft_minecraft_mcpatcher_ctm_default_7_glass_gray_glass_pane_gray.properties

# Stained glass gray
matchBlocks=160
metadata=7
connect=block
method=ctm
tiles=0-11 16-27 32-43 48-58

minecraft_minecraft_mcpatcher_ctm_default_8_glass_silver_glass_pane_silver.properties

# Stained glass silver
matchBlocks=160
metadata=8
connect=block
method=ctm
tiles=0-11 16-27 32-43 48-58

minecraft_minecraft_mcpatcher_ctm_default_8_glass_silver_glass_silver.properties

# Stained glass silver
matchBlocks=95
metadata=8
connect=block
method=ctm
tiles=0-11 16-27 32-43 48-58

minecraft_minecraft_mcpatcher_ctm_default_9_glass_cyan_glass_cyan.properties

# Stained glass cyan
matchBlocks=95
metadata=9
connect=block
method=ctm
tiles=0-11 16-27 32-43 48-58

minecraft_minecraft_mcpatcher_ctm_default_9_glass_cyan_glass_pane_cyan.properties

# Stained glass cyan
matchBlocks=160
metadata=9
connect=block
method=ctm
tiles=0-11 16-27 32-43 48-58

minecraft_minecraft_mcpatcher_ctm_default_bookshelf.properties

# Converted from /ctm.png
# Individual tiles are in /ctm/default
matchBlocks=47
method=horizontal
tiles=12-15
connect=block

minecraft_minecraft_mcpatcher_ctm_default_glass.properties

# Converted from /ctm.png
# Individual tiles are in /ctm/default
matchBlocks=20
method=ctm
tiles=0-11 16-27 32-43 48-58
connect=block

minecraft_minecraft_mcpatcher_ctm_default_glasspane.properties

# Converted from /ctm.png
# Individual tiles are in /ctm/default
matchBlocks=102
method=ctm
tiles=0-11 16-27 32-43 48-58
connect=block

minecraft_minecraft_mcpatcher_ctm_default_sandstone.properties

# Converted from /ctm.png
# Individual tiles are in /ctm/default
matchTiles=sandstone_normal
metadata=0
method=top
tiles=66
connect=tile

minecraft_minecraft_models_block_pane_n.json

{
    "ambientocclusion": false,
    "textures": {
        "particle": "#pane"
    },
    "elements": [
        {   "from": [ 7, 0, 0 ],
            "to": [ 9, 16, 9 ],
            "shade": false,
            "faces": {
                "down":  { "uv": [ 7, 0, 9, 9 ], "texture": "#edge" },
                "up":    { "uv": [ 7, 0, 9, 9 ], "texture": "#edge" },
                "north": { "uv": [ 7, 0, 9, 16 ], "texture": "#edge", "cullface": "north" },
                "south": { "uv": [ 7, 0, 9, 16 ], "texture": "#edge" },
                "west":  { "uv": [ 0, 0, 9, 16 ], "texture": "#pane" },
                "east":  { "uv": [ 7, 0, 16, 16 ], "texture": "#pane" }
            }
        }
    ]
}

minecraft_minecraft_models_block_pane_ne.json

{
    "ambientocclusion": false,
    "textures": {
        "particle": "#pane"
    },
    "elements": [
        {   "from": [ 7, 0, 0 ],
            "to": [ 9, 16, 9 ],
            "shade": false,
            "faces": {
                "down":  { "uv": [  7, 0,  9,  9 ], "texture": "#edge" },
                "up":    { "uv": [  7, 0,  9,  9 ], "texture": "#edge" },
                "north": { "uv": [  7, 0,  9, 16 ], "texture": "#edge", "cullface": "north" },
                "south": { "uv": [  7, 0,  9, 16 ], "texture": "#edge" },
                "west":  { "uv": [  0, 0,  9, 16 ], "texture": "#pane" },
                "east":  { "uv": [  7, 0, 16, 16 ], "texture": "#pane" }
            }
        },
        {   "from": [ 9, 0, 7 ],
            "to": [ 16, 16, 9 ],
            "shade": false,
            "faces": {
                "down":  { "uv": [  7, 9,  9, 16 ], "rotation": 90, "texture": "#edge" },
                "up":    { "uv": [  7, 9,  9, 16 ], "rotation": 90, "texture": "#edge" },
                "north": { "uv": [  0, 0,  7, 16 ], "texture": "#pane" },
                "south": { "uv": [  9, 0, 16, 16 ], "texture": "#pane" },
                "west":  { "uv": [  7, 0,  9, 16 ], "texture": "#pane" },
                "east":  { "uv": [  7, 0,  9, 16 ], "texture": "#edge", "cullface": "east" }
            }
        }
    ]
}

minecraft_minecraft_models_block_pane_ns.json

{
    "ambientocclusion": false,
    "textures": {
        "particle": "#pane"
    },
    "elements": [
        {   "from": [ 7, 0, 0 ],
            "to": [ 9, 16, 16 ],
            "shade": false,
            "faces": {
                "down":  { "uv": [ 7, 0, 9, 16 ], "texture": "#edge", "cull": false },
                "up":    { "uv": [ 7, 0, 9, 16 ], "texture": "#edge", "cull": false },
                "north": { "uv": [ 7, 0, 9, 16 ], "texture": "#edge" },
                "south": { "uv": [ 7, 0, 9, 16 ], "texture": "#edge" },
                "west":  { "uv": [ 0, 0, 16, 16 ], "texture": "#pane", "cull": false },
                "east":  { "uv": [ 0, 0, 16, 16 ], "texture": "#pane", "cull": false }
            }
        }
    ]
}

minecraft_minecraft_models_block_pane_nse.json

{
    "ambientocclusion": false,
    "textures": {
        "particle": "#pane"
    },
    "elements": [
        {   "from": [ 7, 0, 0 ],
            "to": [ 9, 16, 16 ],
            "shade": false,
            "faces": {
                "down":  { "uv": [  7, 0,  9, 16 ], "texture": "#edge" },
                "up":    { "uv": [  7, 0,  9, 16 ], "texture": "#edge" },
                "north": { "uv": [  7, 0,  9, 16 ], "texture": "#edge", "cullface": "north" },
                "south": { "uv": [  7, 0,  9, 16 ], "texture": "#edge", "cullface": "south" },
                "west":  { "uv": [  0, 0, 16, 16 ], "texture": "#pane" },
                "east":  { "uv": [  0, 0, 16, 16 ], "texture": "#pane" }
            }
        },
        {   "from": [ 9, 0, 7 ],
            "to": [ 16, 16, 9 ],
            "shade": false,
            "faces": {
                "down":  { "uv": [  7, 9,  9, 16 ], "rotation": 90, "texture": "#edge" },
                "up":    { "uv": [  7, 9,  9, 16 ], "rotation": 90, "texture": "#edge" },
                "north": { "uv": [  0, 0,  7, 16 ], "texture": "#pane" },
                "south": { "uv": [  9, 0, 16, 16 ], "texture": "#pane" },
                "west":  { "uv": [  7, 0,  9, 16 ], "texture": "#edge" },
                "east":  { "uv": [  7, 0,  9, 16 ], "texture": "#edge", "cullface": "east" }
            }
        }
    ]
}

minecraft_minecraft_optifine_lang_cs_CZ.lang

# Hlavní
of.general.ambiguous=dvojznačný
of.general.custom=Vlastní
of.general.from=Z
of.general.id=Id
of.general.restart=restart
of.general.smart=Chytrá

# Klávesy
of.key.zoom=Přiblížení

# Zprávy
of.message.aa.shaders1=Antialiasing není kompatibilní se Stíny.
of.message.aa.shaders2=Prosím vypni Stíny pro použití téhle možnosti.

of.message.af.shaders1=Anizotropní Filtrování není kompatibilní se Stíny
of.message.af.shaders2=Prosím vypni Stíny pro použití téhle možnosti.

of.message.fr.shaders1=Rychlý Render není kompatibilní se stíny.
of.message.fr.shaders2=Prosím vypni Stíny pro použití téhle možnosti

of.message.shaders.aa1=Stíny nejsou kompatibilní s Antialiasingem
of.message.shaders.aa2=Jdi do nastavení Kvality -> Antialiasing na vypnuto.

of.message.shaders.af1=Stíny nejsou kompatibilní s Anizotropním Filtrováním.
of.message.shaders.af2=Jdi do nastavení Kvality -> Anizotropní Filtrování na vypnuto.

of.message.shaders.fr1=Stíny nejsou komoatibilní s Rychlým Renderem.
of.message.shaders.fr2=Jdi do nastavení Výkonu -> Rychlý Render na vypnuto.

of.message.newVersion=Nová verze §eOptiFinu§f je k dispozici: §e%s§f
of.message.java64Bit=Můžeš si nainstalovat  §e64-bitovou Javu§f pro zvýšení výkonu
of.message.openglError=§eChyba OpenGL§f: %s (%s)

of.message.shaders.loading=Načítám stíny: %s

of.message.other.reset=Vyresetovat všechno nastavení videa (grafiky) na výchozí hodnoty?
 
# Nastavení Grafiky

options.graphics.tooltip.1=Vizuální kvality
options.graphics.tooltip.2=  Rychlá  - nižší kvalita, rychlejší
options.graphics.tooltip.3=  Pěkná - vyšší kvalita, pomalejší
options.graphics.tooltip.4=Mění vzhled mraků, listí, vody,
options.graphics.tooltip.5=stínů a stran trávníků.

of.options.renderDistance.extreme=Extrémní

options.renderDistance.tooltip.1=Viditelná vzdálenost
options.renderDistance.tooltip.2=  2 Maličká - 32m (nejrychlejší)
options.renderDistance.tooltip.3=  4 Malá - 64m (rychlejší)
options.renderDistance.tooltip.4=  8 Normální - 128m
options.renderDistance.tooltip.5=  16 Velká - 256m (pomalejší)
options.renderDistance.tooltip.6=  32 Extrémní - 512m (nejpomalejší!)
options.renderDistance.tooltip.7=Extrémní Viditelná vzdálenost je velmi výkonově náročná!
options.renderDistance.tooltip.8=Hodnoty nad 16 Velká jsou pouze pro lokální světy.

options.ao.tooltip.1=Vyhlazené osvětlení.
options.ao.tooltip.2=  VYPNUTO - žádné vyhlazené osvětlení (rychlé)
options.ao.tooltip.3=  Minimální - jednoduché vyhlazené osvětlení (pomalejší)
options.ao.tooltip.4=  Maximální - kompletně vyhlazené osvětlení (nejpomalejší)

options.framerateLimit.tooltip.1=Maximální FPS
options.framerateLimit.tooltip.2=  VSync - limitované pro max počet FPS pro monitor (60, 30, 20)
options.framerateLimit.tooltip.3=  5-255 - nastavitelné
options.framerateLimit.tooltip.4=  Neomezené - bez limitu (nejrychlejší)
options.framerateLimit.tooltip.5=FPS nepřekročí
options.framerateLimit.tooltip.6=stanovenou hondotu.
of.options.framerateLimit.vsync=VSync

of.options.AO_LEVEL=Úroveň Vyhlazeného Osvětlení
of.options.AO_LEVEL.tooltip.1=Úroveň vyhlazeného osvětlení
of.options.AO_LEVEL.tooltip.2=  VYPNUTO - žádné stíny
of.options.AO_LEVEL.tooltip.3=  50%% - světlé stíny
of.options.AO_LEVEL.tooltip.4=  100%% - tmavé stíny

options.viewBobbing.tooltip.1=Více realistický pohyb
options.viewBobbing.tooltip.2=Pokud používáš mipmapu, nastav na VYPNUTO pro nejlepší výsledky.

options.guiScale.tooltip.1=Velikost GUI
options.guiScale.tooltip.2=Menší GUI mohou být rychlejší.

options.vbo.tooltip.1=Vertexově Vyrovnávající objekty
options.vbo.tooltip.2=Používá alternativní model renderování, který je
options.vbo.tooltip.3=rychlejší (5-10%%) oproti výchozímu renderování.

options.gamma.tooltip.1=Zvýší jas tmavých objektů
options.gamma.tooltip.2=  Tmavý - standardní jas
options.gamma.tooltip.3=  1-99%% - nastavitelné
options.gamma.tooltip.4=  Světlé - maximální jas tmavých objektů
options.gamma.tooltip.5=Tato možnost nezmění jas
options.gamma.tooltip.6=úplně tmavých objektů.

options.anaglyph.tooltip.1=3D Zobrazení
options.anaglyph.tooltip.2=Zapne stereoskopické 3D, které používá každé barvy
options.anaglyph.tooltip.3=pro každé oko.
options.anaglyph.tooltip.4=Vyžaduje červeno-modré brýle pro lepší vidění.

of.options.ALTERNATE_BLOCKS=Alternativní Bloky
options.blockAlternatives.tooltip.1=Alternativní Bloky
options.blockAlternatives.tooltip.2=Používá alternativní model bloku pro některé modely.
options.blockAlternatives.tooltip.3=Záleží na vybraném balíčku zdrojů.

of.options.FOG_FANCY=Mlha
of.options.FOG_FANCY.tooltip.1=Typ mlhy
of.options.FOG_FANCY.tooltip.2=  Rychlá - rychlejší mlha
of.options.FOG_FANCY.tooltip.3=  Pěkná - pomalejší mlha, vypadá pěkněji
of.options.FOG_FANCY.tooltip.4=  VYPNUTO - žádná mlha, rychlejší
of.options.FOG_FANCY.tooltip.5=Pěkná mlha se aktivuje jen když je podporována
of.options.FOG_FANCY.tooltip.6=grafickou kartou.

of.options.FOG_START=Začátek Mlhy
of.options.FOG_START.tooltip.1=Start Mlhy
of.options.FOG_START.tooltip.2=  0.2 - mlha začne přímo u hráče
of.options.FOG_START.tooltip.3=  0.8 - mlha začne daleko od hráče
of.options.FOG_START.tooltip.4=Tato možnost většinou neovlivňuje výkon.

of.options.CHUNK_LOADING=Načítaní Chunků
of.options.CHUNK_LOADING.tooltip.1= Načítaní Chunků
of.options.CHUNK_LOADING.tooltip.2=  Výchozí - nestabilní FPS při načítání chunků
of.options.CHUNK_LOADING.tooltip.3=  Pllynulé - stabilní FPS
of.options.CHUNK_LOADING.tooltip.4=  Multi-Jádra - stabilní FPS, 3x rychlejší načítání světa
of.options.CHUNK_LOADING.tooltip.5=Plynulé a Multi-Jádra - odstraní sekání a 
of.options.CHUNK_LOADING.tooltip.6=zmrazování způsobené načítáním chunků.
of.options.CHUNK_LOADING.tooltip.7=Multi-Jádro může 3x zrychlit načítání světa a
of.options.CHUNK_LOADING.tooltip.8=zvýšit FPS používáním druhého jádra.
of.options.chunkLoading.smooth=Plynulé
of.options.chunkLoading.multiCore=Multi-Jádro

of.options.shaders=Stíny...
of.options.shadersTitle=Stíny

of.options.shaders.packNone=VYPNUTO
of.options.shaders.packDefault=(vložené)

of.options.shaders.ANTIALIASING=Antialiasing
of.options.shaders.NORMAL_MAP=Normální Mapa
of.options.shaders.SPECULAR_MAP=Zrcadlová Mapa
of.options.shaders.RENDER_RES_MUL=Kvalita Renderu
of.options.shaders.SHADOW_RES_MUL=Kvalita Osvětlení
of.options.shaders.HAND_DEPTH_MUL=Ruční Hloubka
of.options.shaders.CLOUD_SHADOW=Stíny mraků
of.options.shaders.OLD_HAND_LIGHT=Staré Přední Osvětlení
of.options.shaders.OLD_LIGHTING=Staré Osvětlení
of.options.shaders.SHADER_PACK=Balíček Stínů

of.options.shaders.shadersFolder=Složka Stínů
of.options.shaders.shaderOptions=Možnosti Stínů...

of.options.shaderOptionsTitle=Možnosti Stínů

of.options.quality=Kvalita...
of.options.qualityTitle=Nastavení Kvality

of.options.details=Detaily...
of.options.detailsTitle=Nastavení Detailů

of.options.performance=Výkon...
of.options.performanceTitle=Nastavení Výkonu

of.options.animations=Animace...
of.options.animationsTitle=Nastavení Animací

of.options.other=Ostatní...
of.options.otherTitle=Další Nastavení

of.options.other.reset=Vyresetovat Nastavení Videa/Grafiky ...

of.shaders.profile=Profil

# Kvalita

of.options.mipmap.bilinear=Bilineání
of.options.mipmap.linear=Lineární
of.options.mipmap.nearest=Nejbližší
of.options.mipmap.trilinear=Trilineární

options.mipmapLevels.tooltip.1=Vizuální efekty mohou udělat vzdálenější objekty pěknější
options.mipmapLevels.tooltip.2=vyhlazováním a detailními texturami.
options.mipmapLevels.tooltip.3=  VYPNUTO - žádné vyhlazování
options.mipmapLevels.tooltip.4=  1 - minimální vyhlazování
options.mipmapLevels.tooltip.5=  4 - maximální vyhlazování
options.mipmapLevels.tooltip.6=Tato možnost většinou neovlivňuje výkon.

of.options.MIPMAP_TYPE=Typ Mipmapy
of.options.MIPMAP_TYPE.tooltip.1= Vizuální efekty mohou udělat vzdálenější objekty pěknější
of.options.MIPMAP_TYPE.tooltip.2=vyhlazováním a detailními texturami.
of.options.MIPMAP_TYPE.tooltip.3=  Nejbližší - hrubé vyhlazování (nejrychlejší)
of.options.MIPMAP_TYPE.tooltip.4=  Lineární - normální vyhlazování
of.options.MIPMAP_TYPE.tooltip.5=  Bilineární - dobré vyhlazování
of.options.MIPMAP_TYPE.tooltip.6=  Trilineární - nejlepší vyhlazování (nejpomalejší)


of.options.AA_LEVEL=Antialiasing
of.options.AA_LEVEL.tooltip.1=Antialiasing
of.options.AA_LEVEL.tooltip.2= VYPNUTO - (výchozí) žádný Antialiasing (rychlé)
of.options.AA_LEVEL.tooltip.3= 2-16 - vyhlazované hrany a lajny (pomalé)
of.options.AA_LEVEL.tooltip.4=Antialiasing vyhlazuje rozviklané hrany a 
of.options.AA_LEVEL.tooltip.5=přechody ostrých barev.
of.options.AA_LEVEL.tooltip.6=Pokud je zapnuto, výrazně zmenší FPS.
of.options.AA_LEVEL.tooltip.7=Ne všechny úrovně jsou podporované všemi grafickými kartami.
of.options.AA_LEVEL.tooltip.8=Efektivní po RESTARTU!

of.options.AF_LEVEL=Antizotropní Filtrování
of.options.AF_LEVEL.tooltip.1= Antizotropní Filtrování
of.options.AF_LEVEL.tooltip.2= VYPNUTO - (výchozí) standartní detaily textur (rychlé)
of.options.AF_LEVEL.tooltip.3= 2-16 - lepší detaily v mipmapovaných texturách (pomalé)
of.options.AF_LEVEL.tooltip.4= Antizotropní Filtrování zachová všechny detaily v
of.options.AF_LEVEL.tooltip.5=mipmapovaných texturách.
of.options.AF_LEVEL.tooltip.6=Pokud je zapnuto, výrazně sníží FPS..

of.options.CLEAR_WATER=Čistá Voda
of.options.CLEAR_WATER.tooltip.1= Čistá Voda
of.options.CLEAR_WATER.tooltip.2=  ZAPNUTO - čistá, průhledná voda
of.options.CLEAR_WATER.tooltip.3=  VYPNUTO - výchozí voda

of.options.RANDOM_MOBS=Náhodní Mobové
of.options.RANDOM_MOBS.tooltip.1= Náhodní Mobové
of.options.RANDOM_MOBS.tooltip.2=  VYPNUTO - žádní náhodní mobové, rychlejší
of.options.RANDOM_MOBS.tooltip.3=  ZAPNUTO - náhodní mobové, pomalejší
of.options.RANDOM_MOBS.tooltip.4=Funkce náhodní mobové používá náhodně textury pro moby ve hře.
of.options.RANDOM_MOBS.tooltip.5=Vyžaduje balíček textur, který má více textur mobů.

of.options.BETTER_GRASS=Lepší Trávník
of.options.BETTER_GRASS.tooltip.1=Lepší Trávník
of.options.BETTER_GRASS.tooltip.2=  VYPNUTO - výchozí strana trávníku, rychlejší
of.options.BETTER_GRASS.tooltip.3=  Rychlá - plná strana trávníku, pomalejší
of.options.BETTER_GRASS.tooltip.4=  Pěkná - dynamická strana trávníku, nepomalejší

of.options.BETTER_SNOW=Lepší Sníh
of.options.BETTER_SNOW.tooltip.1=Lepší sníh
of.options.BETTER_SNOW.tooltip.2=  VYPNUTO - výchozí sníh, rychlejší
of.options.BETTER_SNOW.tooltip.3=  ZAPNUTO - lepší sníh, pomalejší
of.options.BETTER_SNOW.tooltip.4=Zobrazuje sníh pod průhlednými bloky (plot, vysoká tráva)
of.options.BETTER_SNOW.tooltip.5=když sousedí se sněhovými bloky.

of.options.CUSTOM_FONTS=Vlastní Písmo
of.options.CUSTOM_FONTS.tooltip.1= Vlastní Písmo
of.options.CUSTOM_FONTS.tooltip.2=  ZAPNUTO - používá vlastní písmo (výchozí), pomalejší
of.options.CUSTOM_FONTS.tooltip.3=  VYPNUTO - používá výchozí písmo, rychlejší
of.options.CUSTOM_FONTS.tooltip.4=Vlastní písmo záleží na vybraném
of.options.CUSTOM_FONTS.tooltip.5=balíčku textur.

of.options.CUSTOM_COLORS=Vlastní Barvy
of.options.CUSTOM_COLORS.tooltip.1= Vlastní Barvy
of.options.CUSTOM_COLORS.tooltip.2=  ZAPNUTO - používá vlastní barvy (výchozí), pomalejší
of.options.CUSTOM_COLORS.tooltip.3=  VYPNUTO - používá výchozí barvy, rychlejší
of.options.CUSTOM_COLORS.tooltip.4=Vlastní barvy záleží na vybraném
of.options.CUSTOM_COLORS.tooltip.5=balíčku textur.

of.options.SWAMP_COLORS=Barvy v Bažinách
of.options.SWAMP_COLORS.tooltip.1= Barvy v Bažinách
of.options.SWAMP_COLORS.tooltip.2=  ZAPNUTO - používá barvy v bažinách (výchozí), pomalejší
of.options.SWAMP_COLORS.tooltip.3=  VYPNUTO - nepoužívá barvy v bažinách, rychlejší
of.options.SWAMP_COLORS.tooltip.4=Barvy v bažinách ovlivňují trávník, listy, lijány a vodu.

of.options.SMOOTH_BIOMES=Vyhlazené Biomy
of.options.SMOOTH_BIOMES.tooltip.1=Vyhlazené Biomy
of.options.SMOOTH_BIOMES.tooltip.2=  ZAPNUTO - vyhlazování hranic biomů (výchozí), pomalejší
of.options.SMOOTH_BIOMES.tooltip.3=  VYPNUTO - žádné vyhlazování hranic biomů, rychlejší.
of.options.SMOOTH_BIOMES.tooltip.4=Vyhlazování hranic biomů je dáno změnou a
of.options.SMOOTH_BIOMES.tooltip.5=průměru všech sousedících bloků.
of.options.SMOOTH_BIOMES.tooltip.6=Ovlivňuje trávník, listí, lijány a vodu.

of.options.CONNECTED_TEXTURES=Spojené Textury
of.options.CONNECTED_TEXTURES.tooltip.1=Spojené Textury
of.options.CONNECTED_TEXTURES.tooltip.2=  VYPNUTO - žádné spojené textury (výchozí), rychlejší
of.options.CONNECTED_TEXTURES.tooltip.3=  Rychlá - rychle spojené textury
of.options.CONNECTED_TEXTURES.tooltip.4=  Pěkná - pěkně spojené textury
of.options.CONNECTED_TEXTURES.tooltip.5=Spojené textury spojují textury skla,,
of.options.CONNECTED_TEXTURES.tooltip.6=pískovce a knihoven když jsou
of.options.CONNECTED_TEXTURES.tooltip.7=vedle sebe. Spojené textury záleží
of.options.CONNECTED_TEXTURES.tooltip.8=na vybraném balíčku textur.

of.options.NATURAL_TEXTURES=Naturální Textury
of.options.NATURAL_TEXTURES.tooltip.1=Naturální Textury
of.options.NATURAL_TEXTURES.tooltip.2=  VYPNUTO - žádné naturální textury, rychlejší
of.options.NATURAL_TEXTURES.tooltip.3=  ZAPNUTO - používá naturální textury
of.options.NATURAL_TEXTURES.tooltip.4=Naturální textury odstraňují vzor
of.options.NATURAL_TEXTURES.tooltip.5=vytvořený opakováním bloků stejných typů.
of.options.NATURAL_TEXTURES.tooltip.6=Používá otočené a převrácené základy
of.options.NATURAL_TEXTURES.tooltip.7=textury bloků. Nastavení pro naturální textury
of.options.NATURAL_TEXTURES.tooltip.8=je ovlivňováno vybraným balíčkem textur.

of.options.CUSTOM_SKY=Vlastní Obloha
of.options.CUSTOM_SKY.tooltip.1=Vlastní Obloha
of.options.CUSTOM_SKY.tooltip.2=  ZAPNUTO - používá vlastní textury oblohy (výchozí), pomalejší
of.options.CUSTOM_SKY.tooltip.3=  VYPNUTO - výchozí obloha, rychlejší
of.options.CUSTOM_SKY.tooltip.4=Vlastní textura oblohy je ovlivňována vybraným
of.options.CUSTOM_SKY.tooltip.5=balíčkem textur.

of.options.CUSTOM_ITEMS=Vlastní Itemy
of.options.CUSTOM_ITEMS.tooltip.1=Vlastní Itemy
of.options.CUSTOM_ITEMS.tooltip.2=  ZAPNUTO - vlastní textury itemů (výchozí), pomalejší
of.options.CUSTOM_ITEMS.tooltip.3=  VYPNUTO - výchozí textury itemů, rychlejší
of.options.CUSTOM_ITEMS.tooltip.4=Vlastní itemy záleží na vybraném
of.options.CUSTOM_ITEMS.tooltip.5=balíčku textur.

# Detaily

of.options.CLOUDS=Mraky
of.options.CLOUDS.tooltip.1=Mraky
of.options.CLOUDS.tooltip.2=  Výchozí - z nastavení Grafiky
of.options.CLOUDS.tooltip.3=  Rychlá - nižší kvalita, rychlejší
of.options.CLOUDS.tooltip.4=  Pěkná - vyšší kvalita, pěknější
of.options.CLOUDS.tooltip.5=  VYPNUTO - žádné mraky, nejrychlejší
of.options.CLOUDS.tooltip.6=Rychlé mraky jsou 2D.
of.options.CLOUDS.tooltip.7=Pěkné mraky jsou 3D.

of.options.CLOUD_HEIGHT=Výška Mraků
of.options.CLOUD_HEIGHT.tooltip.1=Výška Mraků
of.options.CLOUD_HEIGHT.tooltip.2=  VYPNUTO - výchozí výška
of.options.CLOUD_HEIGHT.tooltip.3=  100%% - nad limitem stavění

of.options.TREES=Stromy
of.options.TREES.tooltip.1=Stromy
of.options.TREES.tooltip.2=  Výchozí - z nastavení Grafiky
of.options.TREES.tooltip.3=  Rychlá - nejnižší kvalita, nejrychlejší
of.options.TREES.tooltip.4=  Chytrá - vyšší kvalita, rychlé
of.options.TREES.tooltip.5=  Pěkná - nejvyšší kvalita, nejpomalejší
of.options.TREES.tooltip.6=Rychlá stromy mají průhledné listí.
of.options.TREES.tooltip.7=Pěkné a Chytré stromy mají průhledné listí.

of.options.RAIN=Sníh a Déšť
of.options.RAIN.tooltip.1=Sníh a Déšť
of.options.RAIN.tooltip.2=  Výchozí - z nastavení Grafiky
of.options.RAIN.tooltip.3=  Rychlá - lehký sníh/déšť, rychlejší
of.options.RAIN.tooltip.4=  Pěkná - velký sníh/déšť, pomalejší
of.options.RAIN.tooltip.5=  VYPNUTO - žádný sníh/déšť, nejrychlejší
of.options.RAIN.tooltip.6=Pokud je déšť vypnutý, jeho zvuky stále
of.options.RAIN.tooltip.7=hrají.

of.options.SKY=Obloha
of.options.SKY.tooltip.1=Obloha
of.options.SKY.tooltip.2=  ZAPNUTO - obloha je viditelná, pomalejší
of.options.SKY.tooltip.3=  VYPNUTO - obloha nejde vidět, rychlejší
of.options.SKY.tooltip.4=Pokud je obloha vypnutá, měsíc a slunce půjdou stále vidět.

of.options.STARS=Hvězdy
of.options.STARS.tooltip.1=Hvězdy
of.options.STARS.tooltip.2=  ZAPNUTO - hvězdy jsou viditelné, pomalejší
of.options.STARS.tooltip.3=  VYPNUTO - hvězdy nejdou vidět, rychlejší

of.options.SUN_MOON=Slunce a Měsíc
of.options.SUN_MOON.tooltip.1=Slunce a Měsíc
of.options.SUN_MOON.tooltip.2=  ZAPNUTO - slunce a měsíc lze vidět (výchozí)
of.options.SUN_MOON.tooltip.3=  VYPNUTO - slunce a měsíc nelze vidět, rychlejší

of.options.SHOW_CAPES=Zobrazovat Kápě
of.options.SHOW_CAPES.tooltip.1=Zobrazovat Kápě
of.options.SHOW_CAPES.tooltip.2=  ZAPNUTO - zobrazovat kápě hráčů (výchozí)
of.options.SHOW_CAPES.tooltip.3=  VYPNUTO - nezobrazovat kápě hráčů

of.options.TRANSLUCENT_BLOCKS=Průsvitné Bloky
of.options.TRANSLUCENT_BLOCKS.tooltip.1=Průsvitné Bloky
of.options.TRANSLUCENT_BLOCKS.tooltip.2=  Pěkná - pěkné mixování bloků (výchozí)
of.options.TRANSLUCENT_BLOCKS.tooltip.3=  Rychlá - rychlé mixování bloků (rychlejší)
of.options.TRANSLUCENT_BLOCKS.tooltip.4=Ovládání mixování bloků zajišťuje blokům
of.options.TRANSLUCENT_BLOCKS.tooltip.5=s rozfílnou barvou (barevné sklo, voda, led)
of.options.TRANSLUCENT_BLOCKS.tooltip.6=odstranit vzduch mezi nimi.

of.options.HELD_ITEM_TOOLTIPS=Popisek k Drženému Itemu
of.options.HELD_ITEM_TOOLTIPS.tooltip.1=Popisek k Drženému Itemu
of.options.HELD_ITEM_TOOLTIPS.tooltip.2=  ZAPNUTO - zobrazovat popisky (výchozí)
of.options.HELD_ITEM_TOOLTIPS.tooltip.3=  VYPNUTO - nezobrazovat popisky

of.options.DROPPED_ITEMS=Vyhozené Itemy
of.options.DROPPED_ITEMS.tooltip.1=Vyhozené Itemy
of.options.DROPPED_ITEMS.tooltip.2=  Výchozí - podle nastavení Grafiky
of.options.DROPPED_ITEMS.tooltip.3=  Rychlá - vyhozené itemy ve 2D, rychlejší
of.options.DROPPED_ITEMS.tooltip.4=  Pěkná - vyhozené itemy ve 3D, pomalejší

options.entityShadows.tooltip.1=Stíny Entit
options.entityShadows.tooltip.2=  ZAPNUTO - zobrazovat stíny entit
options.entityShadows.tooltip.3=  VYPNUTO - nezobrazovat stíny entit

of.options.VIGNETTE=Ztmavení
of.options.VIGNETTE.tooltip.1=Vizuální efekt, který ztmaví okraje obrazovky.
of.options.VIGNETTE.tooltip.2=  Výchozí - záleží na nastavení Grafiky (výchozí)
of.options.VIGNETTE.tooltip.3=  Rychlá - ztmavení vypnuto (rychlejší)
of.options.VIGNETTE.tooltip.4=  Pěkná - ztmavení zapnuto (pomalejší)
of.options.VIGNETTE.tooltip.5=Ztmavení může mít veliký vliv na FPS,
of.options.VIGNETTE.tooltip.6=speciálně při hraní ve fullscreenu.
of.options.VIGNETTE.tooltip.7=Efekt ztmavení je velmi jemný a dá se bezpečně
of.options.VIGNETTE.tooltip.8=vypnout.

of.options.DYNAMIC_FOV=Dynamické FOV
of.options.DYNAMIC_FOV.tooltip.1=Dynamické FOV
of.options.DYNAMIC_FOV.tooltip.2=  ZAPNUTO - zapne dynamické FOV (výchozí)
of.options.DYNAMIC_FOV.tooltip.3=  VYPNUTO - vypne dynamické FOV
of.options.DYNAMIC_FOV.tooltip.4=Mění pole pohledu (FOV) při létání, sprintování 
of.options.DYNAMIC_FOV.tooltip.5=nebo při natahování luku.
 
of.options.DYNAMIC_LIGHTS=Dynamické Světla
of.options.DYNAMIC_LIGHTS.tooltip.1=Dynamické Světla
of.options.DYNAMIC_LIGHTS.tooltip.2=  VYPNUTO - žádná dynamícká světla (výchozí)
of.options.DYNAMIC_LIGHTS.tooltip.3=  Rychlá - rychlá dynamická světla (aktualizace každých 500ms)
of.options.DYNAMIC_LIGHTS.tooltip.4=  Pěkná - pěkná dynamická světla (aktualizovano vzdy)
of.options.DYNAMIC_LIGHTS.tooltip.5=Pokud je zapnuto a v ruce, na zemi nebo v ruce
of.options.DYNAMIC_LIGHTS.tooltip.6=jiného hráče je držen svítící item (louč, světlit, atd.)
of.options.DYNAMIC_LIGHTS.tooltip.7=tak se osvětlí vše kolem

# Výkon

of.options.SMOOTH_FPS=Vyhlazené FPS
of.options.SMOOTH_FPS.tooltip.1=Stabilizuje FPS velikým nátlakem na grafický adaptér
of.options.SMOOTH_FPS.tooltip.2=  VYPNUTO - žádná stabilizace, FPS mohou kolísat
of.options.SMOOTH_FPS.tooltip.3=  ZAPNUTO - stabilizace FPS
of.options.SMOOTH_FPS.tooltip.4=Tato možnost záleží na grafickém adaptéru a jeho efekt
of.options.SMOOTH_FPS.tooltip.5=není vždy vidět.

of.options.SMOOTH_WORLD=Vyhlazený Svět
of.options.SMOOTH_WORLD.tooltip.1=Odstraní lagy způsobené interním serverem.
of.options.SMOOTH_WORLD.tooltip.2=  VYPNUTO - žádná stabilizace, FPS mohou kolísat
of.options.SMOOTH_WORLD.tooltip.3=  ZAPNUTO - stabilizace FPS
of.options.SMOOTH_WORLD.tooltip.4=Stabilizuje FPS rozdělením nsčítání světa.
of.options.SMOOTH_WORLD.tooltip.5=Funguje jen na lokálních světech (hra pro jednoho hráče).

of.options.FAST_RENDER=Rychlý Render
of.options.FAST_RENDER.tooltip.1=Rychlý Render
of.options.FAST_RENDER.tooltip.2= VYPNUTO - standardní render
of.options.FAST_RENDER.tooltip.3= ZAPNUTO - vyvážený render (rychlejší)
of.options.FAST_RENDER.tooltip.4=Používáním vyváženěho renderovacího algoritmu se může snížít
of.options.FAST_RENDER.tooltip.5=využití GPU, což může zvýšit FPS.

of.options.FAST_MATH=Rychlá Matematika
of.options.FAST_MATH.tooltip.1=Rychlá Matematika
of.options.FAST_MATH.tooltip.2= VYPNUTO - standardní matematika
of.options.FAST_MATH.tooltip.3= ZAPNUTO - rychlá matematika
of.options.FAST_MATH.tooltip.4=Používá vyvážené sin() a cos() funkce, což může
of.options.FAST_MATH.tooltip.5=lépe šetřit CPU a zvýšit FPS.

of.options.CHUNK_UPDATES=Načítání Chunků
of.options.CHUNK_UPDATES.tooltip.1=Načítání Chunků
of.options.CHUNK_UPDATES.tooltip.2= 1 - pomalejší načítání světa, vyšší FPS (výchozí)
of.options.CHUNK_UPDATES.tooltip.3= 3 - rychlejší načítání světa, nižší FPS
of.options.CHUNK_UPDATES.tooltip.4= 5 - nejrychlejší načítání světa, nejnižší FPS
of.options.CHUNK_UPDATES.tooltip.5=Číslo chnků načtených za 1 FPS,
of.options.CHUNK_UPDATES.tooltip.6=vyšší hodnoty mohou FPS snížit.

of.options.CHUNK_UPDATES_DYNAMIC=Dynamické Načítání
of.options.CHUNK_UPDATES_DYNAMIC.tooltip.1=Dynamické načítání chunků
of.options.CHUNK_UPDATES_DYNAMIC.tooltip.2= VYPNUTO - (výchozí) standardní počet chunků na FPS
of.options.CHUNK_UPDATES_DYNAMIC.tooltip.3= ZAPNUTO - více chunků, když se hráč nehýbe
of.options.CHUNK_UPDATES_DYNAMIC.tooltip.4=Dynamické načítání načte více chunků
of.options.CHUNK_UPDATES_DYNAMIC.tooltip.5=když se hráč nehýbe, svět se načte rychleji.

of.options.LAZY_CHUNK_LOADING=Líné Načítání Chunků
of.options.LAZY_CHUNK_LOADING.tooltip.1=Pomalé načítání chunků
of.options.LAZY_CHUNK_LOADING.tooltip.2= VYPNUTO - výchozí načítání serverových chunků
of.options.LAZY_CHUNK_LOADING.tooltip.3= ZAPNUTO - pomalé načítání serverových chunků (plynulejší)
of.options.LAZY_CHUNK_LOADING.tooltip.4=Udělá plynulejší načítání chunků na integrovaném serveru
of.options.LAZY_CHUNK_LOADING.tooltip.5=jejich rozdělováním na několik tiků.
of.options.LAZY_CHUNK_LOADING.tooltip.6=Pokud je VYPNUTO, některé části světa se nenačtou správně.
of.options.LAZY_CHUNK_LOADING.tooltip.7=Efektivní pouze pro lokální světy a 1-jádrové CPU.

# Animace

of.options.animation.allOn=Vše ZAPNUTO
of.options.animation.allOff=Vše VYPNUTO
of.options.animation.dynamic=Dynamické

of.options.ANIMATED_WATER=Animovaná Voda
of.options.ANIMATED_LAVA=Animovaná Láva
of.options.ANIMATED_FIRE=Animovaný Oheň
of.options.ANIMATED_PORTAL=Animovaný Portál
of.options.ANIMATED_REDSTONE=Animovaný Redstone
of.options.ANIMATED_EXPLOSION=Animované Exploze
of.options.ANIMATED_FLAME=Animovaný Požár
of.options.ANIMATED_SMOKE=Animovaný Kouř
of.options.VOID_PARTICLES=Částice Voidu
of.options.WATER_PARTICLES=Částice Vody
of.options.RAIN_SPLASH=Částice Deště
of.options.PORTAL_PARTICLES=Částice Portálu
of.options.POTION_PARTICLES=Částice Lektvarů
of.options.DRIPPING_WATER_LAVA=Tekoucí Voda/Láva
of.options.ANIMATED_TERRAIN=Animovaný Terén
of.options.ANIMATED_TEXTURES=Animované Textury
of.options.FIREWORK_PARTICLES=Částice Rachejtle

# Ostatní

of.options.LAGOMETER=Lagometer
of.options.LAGOMETER.tooltip.1=Zobrazí lagometer na ladící obrazovce (F3).
of.options.LAGOMETER.tooltip.2=* Oranžová - Sbírka zbytečné paměti
of.options.LAGOMETER.tooltip.3=* Světle Modrá - Tik
of.options.LAGOMETER.tooltip.4=* Modrá - Plánované soubory
of.options.LAGOMETER.tooltip.5=* Fialová - Načítání chunků
of.options.LAGOMETER.tooltip.6=* Červená - Přednačtené chunky
of.options.LAGOMETER.tooltip.7=* Žlutá - Kontrola viditelnosti
of.options.LAGOMETER.tooltip.8=* Zelená - Načítání terénu

of.options.PROFILER=Ladící Profil
of.options.PROFILER.tooltip.1=Ladící Profil
of.options.PROFILER.tooltip.2=  ZAPNUTO - ladící profil je aktivní, pomalejší
of.options.PROFILER.tooltip.3=  VYPNUTO - ladící profil je neaktivní, rychlejší
of.options.PROFILER.tooltip.4=Ladící profil sbírá a zobrazuje informace když
of.options.PROFILER.tooltip.5=je otevřena ladící obrazovka (F3)

of.options.WEATHER=Počasí
of.options.WEATHER.tooltip.1=Počasí
of.options.WEATHER.tooltip.2=  ZAPNUTO - počasí je aktivní, pomalejší
of.options.WEATHER.tooltip.3=  VYPNUTO - počasí je neaktivní, rychlejší
of.options.WEATHER.tooltip.4=Počasí ovládá deště, sněžení a bouřky.
of.options.WEATHER.tooltip.5=Ovládání počasí je možné pouze pro lokální světy.

of.options.time.dayOnly=Pouze Den
of.options.time.nightOnly=Pouze Noc

of.options.TIME=Čas
of.options.TIME.tooltip.1=Čas
of.options.TIME.tooltip.2= Výchozí - normální denní/noční cyklus
of.options.TIME.tooltip.3= Pouze Den - pouze den
of.options.TIME.tooltip.4= Pouze Noc - pouze noc
of.options.TIME.tooltip.5=Nastavení času je efektivní jen v KREATIVNíM módu
of.options.TIME.tooltip.6=a pro lokální světy.

options.fullscreen.tooltip.1=Fullscreen
options.fullscreen.tooltip.2=  ZAPNUTO - použít celoobrázkový mód
options.fullscreen.tooltip.3=  VYPNUTO - použít mód v okně
options.fullscreen.tooltip.4=Fullscreen mód může být rychlejší než
options.fullscreen.tooltip.5=mód v okně, záleží na GPU.

of.options.FULLSCREEN_MODE=Fullscreen Mód
of.options.FULLSCREEN_MODE.tooltip.1=Celoobrázkový mód
of.options.FULLSCREEN_MODE.tooltip.2=  Výchozí - používá hlavní rozlišení, pomalejší
of.options.FULLSCREEN_MODE.tooltip.3=  WxH - používá vlastní rozlišení, může být rychlejší
of.options.FULLSCREEN_MODE.tooltip.4=Vybrané rozlišení je používáno ve fullscreenu (F11).
of.options.FULLSCREEN_MODE.tooltip.5=Nižší rozlišení mohou být rychlejší.

of.options.SHOW_FPS=Zobrazit FPS
of.options.SHOW_FPS.tooltip.1=Kompaktně zobrazí informace o FPS a renderu
of.options.SHOW_FPS.tooltip.2=  C: - načítání chunků
of.options.SHOW_FPS.tooltip.3=  E: - načtené entity + blokové entity
of.options.SHOW_FPS.tooltip.4=  U: - přednačtené chunky
of.options.SHOW_FPS.tooltip.5=Informace o FPS se zobrazí jen,
of.options.SHOW_FPS.tooltip.6=když je ladící obrazovka (F3) zneviditelněná.

of.options.save.default=Výchozí (2s)
of.options.save.20s=20s
of.options.save.3min=3min
of.options.save.30min=30min

of.options.AUTOSAVE_TICKS=Auto-ukládání
of.options.AUTOSAVE_TICKS.tooltip.1=Interval auto-ukládání
of.options.AUTOSAVE_TICKS.tooltip.2=Výchozí interval auto-ukládání (2s) se NEDOPORUčUJE
of.options.AUTOSAVE_TICKS.tooltip.3=Auto-ukládání způsobuje slavné sekací Smrti (Lag Spikes of Death).

options.anaglyph.tooltip.1=3D mód používá červeno-modré 3D brýle.

minecraft_minecraft_optifine_lang_de_DE.lang

# Contributors of German localization #
#   ThexXTURBOXx (Collaborator of Reforged) 2016-2-29 ---- 2016-3-3
#   RoiEXLab 2016-3-8
#   violine1101 (German Minecraft Wiki admin) 2016-4-4 ---- 2016-5-18

# General
of.general.ambiguous=Unklar
of.general.custom=Anderes
of.general.from=Von
of.general.id=ID
of.general.restart=Neustart
of.general.smart=Fein

# Message
of.message.aa.shaders1=Antialiasing ist nicht mit Shader-Effekten kompatibel.
of.message.aa.shaders2=Bitte deaktiviere Shader-Effekte, um diese Einstellung zu aktivieren.

of.message.af.shaders1=Anistropische Filterung ist nicht mit Shader-Effekten kompatibel.
of.message.af.shaders2=Bitte deaktiviere Shader-Effekte, um diese Einstellung zu aktivieren.

of.message.fr.shaders1=Schnelles Rendern ist nicht mit Shader-Effekten kompatibel.
of.message.fr.shaders2=Bitte deaktiviere Shader-Effekte, um diese Einstellung zu aktivieren.

of.message.shaders.aa1=Antialiasing ist nicht mit Shader-Effekten kompatibel. 
of.message.shaders.aa2=Bitte deaktiviere Qualität -> Antialiasing und starte das Spiel neu.

of.message.shaders.af1=Anistropische Filterung ist nicht mit Shader-Effekten kompatibel.
of.message.shaders.af2=Bitte deaktiviere Qualität -> Anistropische Filterung.

of.message.shaders.fr1=Schnelles Rendern ist nicht mit Shader-Effekten kompatibel.
of.message.shaders.fr2=Bitte deaktiviere Leistung -> Schnelles Rendern.

of.message.newVersion=Eine neue Version von §eOptiFine§f ist verfügbar: §e%s§f
of.message.java64Bit=Du kannst die §e64-bit-Version von Java§f installieren, um die Leistung zu verbessern
of.message.openglError=§eOpenGL-Fehler§f: %s (%s)

of.message.shaders.loading=Lade Shader-Effekte: %s

of.message.other.reset=Alle Videoeinstellungen auf die Standardwerte zurücksetzen?
 
# Video settings

options.graphics.tooltip.1=Grafikmodus
options.graphics.tooltip.2=  Schnell - Schlechtere Qualität, schneller
options.graphics.tooltip.3=  Schön   - Höhere Qualität, langsamer
options.graphics.tooltip.4=Verändert das Aussehen der Wolken, Blätter, Grasblöcke,
options.graphics.tooltip.5=Schatten und von Wasser.

of.options.renderDistance.extreme=Extrem

options.renderDistance.tooltip.1=Sichtweite
options.renderDistance.tooltip.2=  2 Mini - 32m (am schnellsten)
options.renderDistance.tooltip.3=  4 Klein - 64m (schnell)
options.renderDistance.tooltip.4=  8 Normal - 128m
options.renderDistance.tooltip.5=  16 Weit - 256m (langsam)
options.renderDistance.tooltip.6=  32 Extrem - 512m (am langsamsten!)
options.renderDistance.tooltip.7=Die extreme Sichtweite ist sehr ressourcenaufwendig!
options.renderDistance.tooltip.8=Werte über 16 funktionieren nur im Einzelspielermodus.

options.ao.tooltip.1=Weiche Beleuchtung
options.ao.tooltip.2=  Aus - Keine weiche Beleuchtung (schnell)
options.ao.tooltip.3=  Minimum - Einfache weiche Beleuchtung (langsam)
options.ao.tooltip.4=  Maximum - Komplexe weiche Beleuchtung (am langsamsten)

options.framerateLimit.tooltip.1=Maximale Bildrate
options.framerateLimit.tooltip.2=  V-Sync - Auf Monitor-Bildrate begrenzen (60, 30, 20)
options.framerateLimit.tooltip.3=  5-255 - Auf eingestellte Bildrate begrenzen
options.framerateLimit.tooltip.4=  Unendlich - Keine Begrenzung (am schnellsten)
options.framerateLimit.tooltip.5=Die Bildrate grenzt die FPS ein, sogar wenn
options.framerateLimit.tooltip.6=die Begrenzung nicht erreicht ist.
of.options.framerateLimit.vsync=V-Sync

of.options.AO_LEVEL=Schattenhelligkeit
of.options.AO_LEVEL.tooltip.1=Schattenhelligkeit
of.options.AO_LEVEL.tooltip.2=  Aus - Keine Schatten
of.options.AO_LEVEL.tooltip.3=  50%% - Helle Schatten
of.options.AO_LEVEL.tooltip.4=  100%% - Dunkle Schatten

options.viewBobbing.tooltip.1=Gehbewegung
options.viewBobbing.tooltip.2=Wenn Mipmaps verwendet werden, deaktiviere diese
options.viewBobbing.tooltip.3=Einstellung für bessere Leitung.

options.guiScale.tooltip.1=GUI-Größe
options.guiScale.tooltip.2=Ein kleineres GUI ist eventuell schneller.

options.vbo.tooltip.1=Vertexbufferobjekte
options.vbo.tooltip.2=Benutzt ein alternatives Rendermodell, das normalerweise
options.vbo.tooltip.3=schneller (5-10%%) als das Standard-Rendermodell ist.

options.gamma.tooltip.1=Erhöht die Helligkeit dunkler Objekte
options.gamma.tooltip.2=  Düster - Standardhelligkeit
options.gamma.tooltip.3=  1-99%% - veränderlich
options.gamma.tooltip.4=  Hell - Maximale Helligkeit für dunkle Objekte
options.gamma.tooltip.5=Diese Einstellungen ändern nicht die Helligkeit von ganz
options.gamma.tooltip.6=schwarzen Objekten

options.anaglyph.tooltip.1=3D-Modus
options.anaglyph.tooltip.2=Kann nur mit einer Rot-Cyan-Brille benutzt werden.
options.anaglyph.tooltip.3=Aktiviert einen stereoskopischen 3D-Effekt durch
options.anaglyph.tooltip.4=Verwenden unterschiedlicher Farben für jedes Auge.

options.blockAlternatives.tooltip.1=Blockvarianten
options.blockAlternatives.tooltip.2=Benutzt alternative Blockmodelle für einige Blöcke.
options.blockAlternatives.tooltip.3=Hängt vom ausgewählten Ressourcenpaket ab.

of.options.FOG_FANCY=Nebel
of.options.FOG_FANCY.tooltip.1=Nebel
of.options.FOG_FANCY.tooltip.2=  Schnell - Schneller Nebel
of.options.FOG_FANCY.tooltip.3=  Schön - Langsamer Nebel, sieht besser aus
of.options.FOG_FANCY.tooltip.4=  Aus - Kein Nebel, am schnellsten
of.options.FOG_FANCY.tooltip.5=Der schöne Nebel ist nur verfügbar, wenn er von der
of.options.FOG_FANCY.tooltip.6=Grafikkarte unterstützt wird.

of.options.FOG_START=Nebelstart
of.options.FOG_START.tooltip.1=Nebelstart
of.options.FOG_START.tooltip.2=  0.2 - Der Nebel startet nahe beim Spieler
of.options.FOG_START.tooltip.3=  0.8 - Der Nebel startet weit weg vom Spieler
of.options.FOG_START.tooltip.4=Diese Einstellung beeinflusst normalerweise nicht die
of.options.FOG_START.tooltip.5=Leistung.

of.options.CHUNK_LOADING=Chunkladen
of.options.CHUNK_LOADING.tooltip.1=Chunkladen
of.options.CHUNK_LOADING.tooltip.2=  Standard - Instabile FPS, wenn Chunks geladen werden
of.options.CHUNK_LOADING.tooltip.3=  Weich - Stabile FPS
of.options.CHUNK_LOADING.tooltip.4=  Multi-Core - Stabile FPS, 3x schnelleres Weltladen
of.options.CHUNK_LOADING.tooltip.5=Weich und Multi-Core entfernen Ruckler und
of.options.CHUNK_LOADING.tooltip.6=Standbilder, welche durch Chunkladen verursacht werden.
of.options.CHUNK_LOADING.tooltip.7=Multi-Core kann das Weltladen 3x schneller machen und
of.options.CHUNK_LOADING.tooltip.8=die FPS erhöhen, indem es einen zweiten CPU-Kern benutzt.
of.options.chunkLoading.smooth=Weich
of.options.chunkLoading.multiCore=Multi-Core

of.options.shaders=Shader-Effekte ...
of.options.shadersTitle=Shader-Effekte

of.options.shaders.packNone=Aus
of.options.shaders.packDefault=(Interner Shader-Effekt)

of.options.shaders.ANTIALIASING=Antialiasing
of.options.shaders.NORMAL_MAP=Normale Karte
of.options.shaders.SPECULAR_MAP=Spiegelnde Karte
of.options.shaders.RENDER_RES_MUL=Renderqualität
of.options.shaders.SHADOW_RES_MUL=Schattenqualität
of.options.shaders.HAND_DEPTH_MUL=Handtiefe
of.options.shaders.CLOUD_SHADOW=Wolkenschatten
of.options.shaders.OLD_HAND_LIGHT=Alte Handbel.
of.options.shaders.OLD_LIGHTING=Alte Beleuchtung
of.options.shaders.SHADER_PACK=Shaderpaket

of.options.shaders.shadersFolder=Shader-Effekt-Ordner
of.options.shaders.shaderOptions=Shadereinstellung ...

of.options.shaderOptionsTitle=Shader-Effekte

of.options.quality=Qualität ...
of.options.qualityTitle=Qualitätseinstellungen

of.options.details=Details ...
of.options.detailsTitle=Detaileinstellungen

of.options.performance=Leistung ...
of.options.performanceTitle=Leistungseinstellungen

of.options.animations=Animationen ...
of.options.animationsTitle=Animationseinstellungen

of.options.other=Sonstiges ...
of.options.otherTitle=Andere Einstellungen

of.options.other.reset=Grafikeinstellungen zurücksetzen ...

of.shaders.profile=Profil

# Quality

of.options.mipmap.bilinear=Bilinear
of.options.mipmap.linear=Linear
of.options.mipmap.nearest=Am nächsten
of.options.mipmap.trilinear=Trilinear

options.mipmapLevels.tooltip.1=Visueller Effekt, der weit entfernte Objekte besser aus-
options.mipmapLevels.tooltip.2=sehen lässt, indem Texturdetails verringert werden
options.mipmapLevels.tooltip.3=  Aus - Keine Verringerung von Details
options.mipmapLevels.tooltip.4=  1 - Minimale Verringerung von Details
options.mipmapLevels.tooltip.5=  4 - Maximale Verringerung von Details
options.mipmapLevels.tooltip.6=Diese Einstellung beeinflusst normalerweise nicht die
options.mipmapLevels.tooltip.7=Leistung.

of.options.MIPMAP_TYPE=Mipmap-Typ
of.options.MIPMAP_TYPE.tooltip.1=Visueller Effekt, der weit entfernte Objekte besser aus-
of.options.MIPMAP_TYPE.tooltip.2=sehen lässt, indem Texturdetails verringert werden
of.options.MIPMAP_TYPE.tooltip.3=  Am nächsten - Grobe Verringerung (am schnellsten)
of.options.MIPMAP_TYPE.tooltip.4=  Linear - Normale Verringerung
of.options.MIPMAP_TYPE.tooltip.5=  Bilinear - Feine Verringerung
of.options.MIPMAP_TYPE.tooltip.6=  Trilinear - Feinste Verringerung (am langsamsten)


of.options.AA_LEVEL=Antialiasing
of.options.AA_LEVEL.tooltip.1=Antialiasing
of.options.AA_LEVEL.tooltip.2= Aus - (Standard) Kein Antialiasing (schneller)
of.options.AA_LEVEL.tooltip.3= 2-16 - Antialiasierte Linien und Ecken (langsamer)
of.options.AA_LEVEL.tooltip.4=Das Antialiasing weicht gezackte Linien ab und schärft
of.options.AA_LEVEL.tooltip.5=Farbübergänge. Wenn aktiviert, kann es die Bildrate
of.options.AA_LEVEL.tooltip.6=erheblich beeinträchtigen.
of.options.AA_LEVEL.tooltip.7=Nicht alle Stufen werden von allen Grafikkarten unterstützt.
of.options.AA_LEVEL.tooltip.8=Änderung wird erst nach einem Neustart effektiv!

of.options.AF_LEVEL=Anisotropische Filterung
of.options.AF_LEVEL.tooltip.1=Anisotropische Filterung
of.options.AF_LEVEL.tooltip.2= Aus - (Standard) Standard-Texturdetails (schneller)
of.options.AF_LEVEL.tooltip.3= 2-16 - Feinere Details in Texturen (langsamer)
of.options.AF_LEVEL.tooltip.4=Die anisotropische Filterung stellt Details in Texturen,
of.options.AF_LEVEL.tooltip.5=die durch Mipmap ihre Details verloren haben, wieder her.
of.options.AF_LEVEL.tooltip.6=Wenn aktiviert, kann es die FPS erheblich verringern.

of.options.CLEAR_WATER=Klares Wasser
of.options.CLEAR_WATER.tooltip.1=Klares Wasser
of.options.CLEAR_WATER.tooltip.2=  An - Klares, transparentes Wasser
of.options.CLEAR_WATER.tooltip.3=  Aus - Normales Wasser

of.options.RANDOM_MOBS=Kreaturvarianten
of.options.RANDOM_MOBS.tooltip.1=Kreaturvarianten
of.options.RANDOM_MOBS.tooltip.2=  Aus - Keine Kreaturvarianten, schneller
of.options.RANDOM_MOBS.tooltip.3=  An - Keine Kreaturvarianten, langsamer
of.options.RANDOM_MOBS.tooltip.4=Die gleichen Kreaturen können unterschiedliche Texturen
of.options.RANDOM_MOBS.tooltip.5=haben. Dies benötigt ein Ressourcenpaket mit entspre-
of.options.RANDOM_MOBS.tooltip.6=chenden Texturen.

of.options.BETTER_GRASS=Besseres Gras
of.options.BETTER_GRASS.tooltip.1=Besseres Gras
of.options.BETTER_GRASS.tooltip.2=  Aus - Standard-Grasseitentextur, am schnellsten
of.options.BETTER_GRASS.tooltip.3=  Schnell - Volle Grasseitentextur, langsamer
of.options.BETTER_GRASS.tooltip.4=  Schön - Dynamische Grasseitentextur, am langsamsten

of.options.BETTER_SNOW=Besserer Schnee
of.options.BETTER_SNOW.tooltip.1=Besserer Schnee
of.options.BETTER_SNOW.tooltip.2=  Aus - Normaler Schnee, schneller
of.options.BETTER_SNOW.tooltip.3=  An - Besserer Schnee, langsamer
of.options.BETTER_SNOW.tooltip.4=Setzt Schnee unter transparente Blöcke (wie Zäune
of.options.BETTER_SNOW.tooltip.5=oder hohes Gras), wenn sie an Schneeblöcke grenzen.

of.options.CUSTOM_FONTS=Schriftartressourcen
of.options.CUSTOM_FONTS.tooltip.1=Schriftarteressourcen
of.options.CUSTOM_FONTS.tooltip.2=  AN - Ressourcenpaket-Schriftart (Standard), langsamer
of.options.CUSTOM_FONTS.tooltip.3=  AUS - Standardschriftart, schneller
of.options.CUSTOM_FONTS.tooltip.4=Die Schriftart wird aus den aktivierten Ressourcenpaketen
of.options.CUSTOM_FONTS.tooltip.5=geladen

of.options.CUSTOM_COLORS=Farbressourcen
of.options.CUSTOM_COLORS.tooltip.1=Farbressourcen
of.options.CUSTOM_COLORS.tooltip.2=  An - Ressourcenpaket-Farben (Standard), langsamer
of.options.CUSTOM_COLORS.tooltip.3=  Aus - Standardfarben, schneller
of.options.CUSTOM_COLORS.tooltip.4=Die Farben werden aus den aktivierten Ressourcenpaketen
of.options.CUSTOM_COLORS.tooltip.5=geladen.

of.options.SWAMP_COLORS=Sumpffarben
of.options.SWAMP_COLORS.tooltip.1=Sumpffarben
of.options.SWAMP_COLORS.tooltip.2=  An - Färbt den Sumpf dunkler (Standard), langsamer
of.options.SWAMP_COLORS.tooltip.3=  Aus - Färbt den Sumpf in normalen Farben, schneller
of.options.SWAMP_COLORS.tooltip.4=Die Sumpffarben betreffen Gras, Laub, Ranken und
of.options.SWAMP_COLORS.tooltip.5=Wasser.

of.options.SMOOTH_BIOMES=Biomübergänge
of.options.SMOOTH_BIOMES.tooltip.1=Biomübergänge
of.options.SMOOTH_BIOMES.tooltip.2=  An - Farbübergänge an Biomgrenzen (Standard), langsamer
of.options.SMOOTH_BIOMES.tooltip.3=  Aus - Keine Farbübergänge an Biomgrenzen, schneller
of.options.SMOOTH_BIOMES.tooltip.4=Die Farbübergänge werden durch Probennahme und
of.options.SMOOTH_BIOMES.tooltip.5=Durchschnittsberechnung der Farben der umliegenden
of.options.SMOOTH_BIOMES.tooltip.6=Blöcke berechnet. Betroffen sind Gras, Laub, Ranken und
of.options.SMOOTH_BIOMES.tooltip.7=Wasser.

of.options.CONNECTED_TEXTURES=Verbundene Texturen
of.options.CONNECTED_TEXTURES.tooltip.1=Verbundene Texturen
of.options.CONNECTED_TEXTURES.tooltip.2=  Aus - Keine verbundenen Texturen (Standard)
of.options.CONNECTED_TEXTURES.tooltip.3=  Schnell - Schnelle verbundene Texturen
of.options.CONNECTED_TEXTURES.tooltip.4=  Schöne - Schöne verbundene Texturen
of.options.CONNECTED_TEXTURES.tooltip.5=Verbundene Texturen verbinden die Texturen von Glas,
of.options.CONNECTED_TEXTURES.tooltip.6=Sandstein und Bücherregalen, wenn sie nebeneinander
of.options.CONNECTED_TEXTURES.tooltip.7=platziert werden. Die verbundenen Texturen werden aus
of.options.CONNECTED_TEXTURES.tooltip.8=den aktivierten Ressourcenpaketen geladen.

of.options.NATURAL_TEXTURES=Natürliche Texturen
of.options.NATURAL_TEXTURES.tooltip.1=Natürliche Texturen
of.options.NATURAL_TEXTURES.tooltip.2=  Aus - Keine natürlichen Texturen (Standard)
of.options.NATURAL_TEXTURES.tooltip.3=  An - Benutzt natürliche Texturen
of.options.NATURAL_TEXTURES.tooltip.4=Natürliche Texturen entfernen die rasterartige Anordnung,
of.options.NATURAL_TEXTURES.tooltip.5=erzeugt durch Platzieren von gleichen Blöcken. Dies be-
of.options.NATURAL_TEXTURES.tooltip.6=nutzt gedrehte und umgekehrte Varianten der Standard-
of.options.NATURAL_TEXTURES.tooltip.7=Blocktextur. Die Einstellungen für die natürlichen Texturen
of.options.NATURAL_TEXTURES.tooltip.8=werden aus den aktivierten Ressourcenpaketen geladen.

of.options.CUSTOM_SKY=Himmeltexturen
of.options.CUSTOM_SKY.tooltip.1=Himmeltexturen
of.options.CUSTOM_SKY.tooltip.2=  An - Ressourcenpaket-Himmeltexturen (Standard), langsam
of.options.CUSTOM_SKY.tooltip.3=  AUS - Standardhimmel, schneller
of.options.CUSTOM_SKY.tooltip.4=Die Himmeltexturen werden aus den aktivierten
of.options.CUSTOM_SKY.tooltip.5=Ressourcenpaketen geladen.

of.options.CUSTOM_ITEMS=Gegenstandstexturen
of.options.CUSTOM_ITEMS.tooltip.1=Gegenstandstexturen
of.options.CUSTOM_ITEMS.tooltip.2=  An - Ressourcenpaket-G.texturen (Standard), langsam
of.options.CUSTOM_ITEMS.tooltip.3=  Aus - Standard-Gegenstandstexturen, schneller
of.options.CUSTOM_ITEMS.tooltip.4=Die Gegenstandstexturen werden aus den aktivierten
of.options.CUSTOM_ITEMS.tooltip.5=Ressourcenpaketen geladen.

# Details

of.options.CLOUDS=Wolken
of.options.CLOUDS.tooltip.1=Wolken
of.options.CLOUDS.tooltip.2=  Standard - Wie Grafikmodus
of.options.CLOUDS.tooltip.3=  Schnell - Schlechtere Qualität, schneller
of.options.CLOUDS.tooltip.4=  Schön - Höhere Qualität, langsamer
of.options.CLOUDS.tooltip.5=  Aus - Keine Wolken, am schnellsten
of.options.CLOUDS.tooltip.6=Schnelle Wolken werden zweidimensional dargestellt.
of.options.CLOUDS.tooltip.7=Schöne Wolken werden dreidimensional dargestellt.

of.options.CLOUD_HEIGHT=Wolkenhöhe
of.options.CLOUD_HEIGHT.tooltip.1=Wolkenhöhe
of.options.CLOUD_HEIGHT.tooltip.2=  Aus - Standardhöhe
of.options.CLOUD_HEIGHT.tooltip.3=  100%% - Über der maximalen Welthöhe

of.options.TREES=Bäume
of.options.TREES.tooltip.1=Bäume
of.options.TREES.tooltip.2=  Standard - Wie Grafikmodus
of.options.TREES.tooltip.3=  Schnell - Schlechtere Qualität, schneller
of.options.TREES.tooltip.4=  Fein - Hohe Qualität, schnell
of.options.TREES.tooltip.5=  Schön - Höchste Qualität, langsamer
of.options.TREES.tooltip.6=Schnelle Bäume haben solide Blätter.
of.options.TREES.tooltip.7=Schöne Bäume haben teilweise transparente Blätter.

of.options.RAIN=Regen & Schnee
of.options.RAIN.tooltip.1=Regen & Schnee
of.options.RAIN.tooltip.2=  Standard - Wie Grafikmodus
of.options.RAIN.tooltip.3=  Schnell - Leichter Regen/Schnee, schneller
of.options.RAIN.tooltip.4=  Schön - Starker Regen/Schnee, langsamer
of.options.RAIN.tooltip.5=  Aus - Kein Regen/Schnee, am schnellsten
of.options.RAIN.tooltip.6=Wenn diese Einstellung deaktiviert ist, sind die Regen-
of.options.RAIN.tooltip.7=geräusche und -partikel dennoch zu hören bzw. zu sehen.

of.options.SKY=Himmel
of.options.SKY.tooltip.1=Himmel
of.options.SKY.tooltip.2=  An - Himmel ist sichtbar, langsamer
of.options.SKY.tooltip.3=  Aus - Himmel ist nicht sichtbar, schneller
of.options.SKY.tooltip.4=Wenn dies deaktiviert ist, sind Mond und Sonne dennoch
of.options.SKY.tooltip.5=sichtbar.

of.options.STARS=Sterne
of.options.STARS.tooltip.1=Sterne
of.options.STARS.tooltip.2=  An - Sterne sind sichtbar, langsamer
of.options.STARS.tooltip.3=  Aus - Sterne ist nicht sichtbar, schneller

of.options.SUN_MOON=Sonne & Mond
of.options.SUN_MOON.tooltip.1=Sonne & Mond
of.options.SUN_MOON.tooltip.2=  An - Sonne und Mond sind sichtbar (Standard)
of.options.SUN_MOON.tooltip.3=  Aus - Sonne und Mond sind nicht sichtbar (schneller)

of.options.SHOW_CAPES=Umhänge
of.options.SHOW_CAPES.tooltip.1=Umhänge
of.options.SHOW_CAPES.tooltip.2=  An - Umhänge werden dargestellt (Standard)
of.options.SHOW_CAPES.tooltip.3=  Aus - Umhänge werden nicht dargestellt

of.options.TRANSLUCENT_BLOCKS=Blocktransparenz
of.options.TRANSLUCENT_BLOCKS.tooltip.1=Blocktransparenz
of.options.TRANSLUCENT_BLOCKS.tooltip.2=  Schön - Korrekte Farbmischung (Standard)
of.options.TRANSLUCENT_BLOCKS.tooltip.3=  Schnell - Schnelle Farbmischung (schnell)
of.options.TRANSLUCENT_BLOCKS.tooltip.4=Kontrolliert die Farbmischung von transparenten Blöcken
of.options.TRANSLUCENT_BLOCKS.tooltip.5=mit verschiedenen Farben (Gefärbtes Glas, Wasser, Eis),
of.options.TRANSLUCENT_BLOCKS.tooltip.6=wenn sie hintereinander mit Luft dazwischen platziert
of.options.TRANSLUCENT_BLOCKS.tooltip.7=werden.

of.options.HELD_ITEM_TOOLTIPS=Gegenstandsbeschr.
of.options.HELD_ITEM_TOOLTIPS.tooltip.1=Gegenstandsbeschreibung
of.options.HELD_ITEM_TOOLTIPS.tooltip.2=  An - Zeige Gegenstandsbeschreibung (Standard)
of.options.HELD_ITEM_TOOLTIPS.tooltip.3=  Aus - Zeige keine Gegenstandsbeschreibung
of.options.HELD_ITEM_TOOLTIPS.tooltip.4=Wird über der Schnellzugriffsleiste angezeigt.

of.options.DROPPED_ITEMS=Gegenstände
of.options.DROPPED_ITEMS.tooltip.1=Liegende Gegenstände
of.options.DROPPED_ITEMS.tooltip.2=  Standard - Wie Grafikmodus
of.options.DROPPED_ITEMS.tooltip.3=  Schnell - Zweidimensionale Animation, schneller
of.options.DROPPED_ITEMS.tooltip.4=  Schön - Dreidimensionale Animation, langsamer

options.entityShadows.tooltip.1=Objektschatten
options.entityShadows.tooltip.2=  An - Zeige Objektschatten
options.entityShadows.tooltip.3=  Aus - Zeige keine Objektschatten

of.options.VIGNETTE=Vignette
of.options.VIGNETTE.tooltip.1=Visueller Effekt, der die Bildschirmecken abdunkelt
of.options.VIGNETTE.tooltip.2=  Standard - Wie Grafikmodus (Standard)
of.options.VIGNETTE.tooltip.3=  Schnell - Vignette deaktiviert (schneller)
of.options.VIGNETTE.tooltip.4=  Schön - Vignette aktiviert (langsamer)
of.options.VIGNETTE.tooltip.5=Die Vignette kann sich extrem auf die Leistung auswirken,
of.options.VIGNETTE.tooltip.6=besonders im Vollbildschirmmodus.
of.options.VIGNETTE.tooltip.7=Der Vignetteneffekt ist fast unmerklich und kann sicher
of.options.VIGNETTE.tooltip.8=deaktiviert werden.

of.options.DYNAMIC_FOV=Dynamisches Sichtfeld
of.options.DYNAMIC_FOV.tooltip.1=Dynamisches Sichtfeld
of.options.DYNAMIC_FOV.tooltip.2=  An - Dynamisches Sichtfeld aktivieren (Standard)
of.options.DYNAMIC_FOV.tooltip.3=  Aus - Dynamisches Sichtfeld ausschalten
of.options.DYNAMIC_FOV.tooltip.4=Ändert das Sichtfeld beim Fliegen, Sprinten oder beim
of.options.DYNAMIC_FOV.tooltip.5=Spannen eines Bogens.

# Performance

of.options.SMOOTH_FPS=Stabile Bildrate
of.options.SMOOTH_FPS.tooltip.1=Stabilisiert Bildrate, indem Grafiktreiberpuffer genutzt werden
of.options.SMOOTH_FPS.tooltip.2=  Aus - Keine Stabilisierung, Bildrate könnte schwanken
of.options.SMOOTH_FPS.tooltip.3=  Am - Stabilisierung der Bildrate
of.options.SMOOTH_FPS.tooltip.4=Diese Einstellung ist abhängig vom Grafikkartentreiber.
of.options.SMOOTH_FPS.tooltip.5=Eine Wirkung ist nicht immer spürbar.

of.options.SMOOTH_WORLD=Weltstabilisierung
of.options.SMOOTH_WORLD.tooltip.1=Entfernt durch den internen Server verursache starke Lags
of.options.SMOOTH_WORLD.tooltip.2=  Aus - Keine Stabilisierung, Bildrate könnte schwanken
of.options.SMOOTH_WORLD.tooltip.3=  An - Weltstabilisierung aktiviert
of.options.SMOOTH_WORLD.tooltip.4=Stabilisiert die Bildrate, indem der interne Serverlade-
of.options.SMOOTH_WORLD.tooltip.5=vorgang aufgeteilt wird.
of.options.SMOOTH_WORLD.tooltip=6=Funktioniert nur im Einzelspielermodus.

of.options.FAST_RENDER=Schnelles Rendern
of.options.FAST_RENDER.tooltip.1=Schnelles Rendern
of.options.FAST_RENDER.tooltip.2=  Aus - Standard-Rendern (Standard)
of.options.FAST_RENDER.tooltip.3=  An - Optimiertes Rendern (schneller)
of.options.FAST_RENDER.tooltip.4=Benutzt optimierte Renderalgorithmen, die die GPU
of.options.FAST_RENDER.tooltip.5=Auslastung verringern und die Leistung erheblich steigern.

of.options.FAST_MATH=Schnelle Mathematik
of.options.FAST_MATH.tooltip.1=Schnelle Mathematik
of.options.FAST_MATH.tooltip.2=  Aus - Standard-Mathematik (Standard)
of.options.FAST_MATH.tooltip.3=  An - Schnellere Mathematik
of.options.FAST_MATH.tooltip.4=Benutzt optimierte Sinus- und Kosinusfunktionen, die den
of.options.FAST_MATH.tooltip.5=CPU-Zwischenspeicher besser nutzen und die Leistung
of.options.FAST_MATH.tooltip.6=steigern.

of.options.CHUNK_UPDATES=Chunk-Aktualisierungen
of.options.CHUNK_UPDATES.tooltip.1=Chunk-Aktualisierungen
of.options.CHUNK_UPDATES.tooltip.2=  1 - Langsameres Weltladen, höhere Bildrate (Standard)
of.options.CHUNK_UPDATES.tooltip.3=  3 - Schnelleres Weltladen, niedrigere Bildrate
of.options.CHUNK_UPDATES.tooltip.4=  5 - Schnellstes Weltladen, niedrigste Bildrate
of.options.CHUNK_UPDATES.tooltip.5=Zahl an Chunk-Aktualisierungen pro gerendertem Bild.
of.options.CHUNK_UPDATES.tooltip.6=Höhere Werte könnten die Bildrate destabilisieren.

of.options.CHUNK_UPDATES_DYNAMIC=Dyn. Aktualisierungen
of.options.CHUNK_UPDATES_DYNAMIC.tooltip.1=Dynamische Chunk-Aktualisierungen
of.options.CHUNK_UPDATES_DYNAMIC.tooltip.2=  Aus - (Standard) Normale Chunk-Aktualisierungen
of.options.CHUNK_UPDATES_DYNAMIC.tooltip.3=  An - Mehr Chunk-Aktualisierungen
of.options.CHUNK_UPDATES_DYNAMIC.tooltip.4=Wenn diese Einstellung aktiviert ist, werden mehr Chunk-
of.options.CHUNK_UPDATES_DYNAMIC.tooltip.5=Aktualisierungen ausgeführt, während der Spieler still
of.options.CHUNK_UPDATES_DYNAMIC.tooltip.6=steht, um die Welt schneller zu laden.

of.options.LAZY_CHUNK_LOADING=Träges Chunkladen
of.options.LAZY_CHUNK_LOADING.tooltip.1=Träges Chunkladen
of.options.LAZY_CHUNK_LOADING.tooltip.2=  Aus - Standard-Server-Chunkladen
of.options.LAZY_CHUNK_LOADING.tooltip.3=  An - Träges Server-Chunkladen (flüssiger)
of.options.LAZY_CHUNK_LOADING.tooltip.4=Server-Chunkladen wird flüssiger, indem die Chunks über
of.options.LAZY_CHUNK_LOADING.tooltip.5=ein paar Ticks hinweg geladen werden. Deaktiviere dies,
of.options.LAZY_CHUNK_LOADING.tooltip.6=wenn Teile der Welt nicht korrekt geladen werden.
of.options.LAZY_CHUNK_LOADING.tooltip.7=Nur für Einzelspielermodus und Ein-Kern-CPUs effektiv.

# Animations

of.options.animation.allOn=Alle an
of.options.animation.allOff=Alle aus
of.options.animation.dynamic=Dynamisch

of.options.ANIMATED_WATER=Animiertes Wasser
of.options.ANIMATED_LAVA=Animierte Lava
of.options.ANIMATED_FIRE=Animiertes Feuer
of.options.ANIMATED_PORTAL=Animierte Portale
of.options.ANIMATED_REDSTONE=Animiertes Redstone
of.options.ANIMATED_EXPLOSION=Animierte Explosion
of.options.ANIMATED_FLAME=Animierte Flammen
of.options.ANIMATED_SMOKE=Animierter Rauch
of.options.VOID_PARTICLES=Leerepartikel
of.options.WATER_PARTICLES=Wasserpartikel
of.options.RAIN_SPLASH=Regengeplätscher
of.options.PORTAL_PARTICLES=Portalpartikel
of.options.POTION_PARTICLES=Trankpartikel
of.options.DRIPPING_WATER_LAVA=Wasser- & Lavatropfen
of.options.ANIMATED_TERRAIN=Animiertes Gelände
of.options.ANIMATED_TEXTURES=Animierte Texturen
of.options.FIREWORK_PARTICLES=Feuerwerkpartikel

# Other

of.options.LAGOMETER=Lagometer
of.options.LAGOMETER.tooltip.1=Zeigt das Lagometer auf dem Debugbildschirm (F3).
of.options.LAGOMETER.tooltip.2=* Orange - Speichermüllsammlung
of.options.LAGOMETER.tooltip.3=* Cyan - Tick
of.options.LAGOMETER.tooltip.4=* Blau - Geplante Ausführungen
of.options.LAGOMETER.tooltip.5=* Lila - Chunks hochladen
of.options.LAGOMETER.tooltip.6=* Rot - Chunkaktualisierungen
of.options.LAGOMETER.tooltip.7=* Gelb - Sichtbarkeitstest
of.options.LAGOMETER.tooltip.8=* Grün - Gelände rendern

of.options.PROFILER=Debug-Diagramm
of.options.PROFILER.tooltip.1=Debug-Diagramm
of.options.PROFILER.tooltip.2=  An - Debug-Diagramm ist aktiviert, langsamer
of.options.PROFILER.tooltip.3=  Aus - Debug-Diagramm ist nicht aktiviert, schneller
of.options.PROFILER.tooltip.4=Das Debug-Diagramm sammelt und stellt Debuginforma-
of.options.PROFILER.tooltip.5=tionen dar, wenn der Debugbildschirm geöffnet ist (F3).

of.options.WEATHER=Wetter
of.options.WEATHER.tooltip.1=Wetter
of.options.WEATHER.tooltip.2=  An - Wetter ist aktiv, langsamer
of.options.WEATHER.tooltip.3=  Aus - Wetter ist nicht aktiv, schneller
of.options.WEATHER.tooltip.4=Das Wetter kontrolliert Regen, Schnee und Gewitter.
of.options.WEATHER.tooltip.5=Wetterkontrolle ist nur im Einzelspielermodus möglich.

of.options.time.dayOnly=Nur Tag
of.options.time.nightOnly=Nur Nacht

of.options.TIME=Zeit
of.options.TIME.tooltip.1=Zeit
of.options.TIME.tooltip.2= Standard - Normaler Tag-Nacht-Zyklus
of.options.TIME.tooltip.3= Nur Tag - Nur Tag
of.options.TIME.tooltip.4= Nur Nacht - Nur Nacht
of.options.TIME.tooltip.5=Diese Einstellung ist nur im Kreativmodus und
of.options.TIME.tooltip.6=im Einzelspielermodus wirksam.

options.fullscreen.tooltip.1=Vollbildschirm
options.fullscreen.tooltip.2=  An - Benutze Vollbildschirmmodus
options.fullscreen.tooltip.3=  Aus - Benutze Fenstermodus
options.fullscreen.tooltip.4=Der Vollbildschirmmodus könnte schneller oder langsamer
options.fullscreen.tooltip.5=als der Fenstermodus sein, das kommt auf die Grafik-
options.fullscreen.tooltip.6=karte an.

of.options.FULLSCREEN_MODE=Vollbild-Auflösung
of.options.FULLSCREEN_MODE.tooltip.1=Vollbild-Auflösung
of.options.FULLSCREEN_MODE.tooltip.2=  Standard - Benutze Bildschirmauflösung, langsamer
of.options.FULLSCREEN_MODE.tooltip.3=  WxH - Benutze andere Auflösung, könnte schneller sein
of.options.FULLSCREEN_MODE.tooltip.4=Die ausgewählte Auflösung wird im Vollbildschirmmodus
of.options.FULLSCREEN_MODE.tooltip.5=verwendet (F11). Kleinere Auflösungen sollten generell
of.options.FULLSCREEN_MODE.tooltip.5=schneller sein.

of.options.SHOW_FPS=Bildrate anzeigen
of.options.SHOW_FPS.tooltip.1=Zeige kurze Bildrate- und Render-Informationen
of.options.SHOW_FPS.tooltip.2=  C: - Chunkrenderer
of.options.SHOW_FPS.tooltip.3=  E: - Objektrenderer + Blockrenderer
of.options.SHOW_FPS.tooltip.4=  U: - Chunk-Aktualisierungen
of.options.SHOW_FPS.tooltip.5=Die Bildrate-Informationen werden nur gezeigt, wenn der
of.options.SHOW_FPS.tooltip.6=Debugbildschirm (F3) sichtbar ist.

of.options.save.default=Standard (2s)
of.options.save.20s=20s
of.options.save.3min=3min
of.options.save.30min=30min

of.options.AUTOSAVE_TICKS=Autospeichern
of.options.AUTOSAVE_TICKS.tooltip.1=Autospeicherintervall
of.options.AUTOSAVE_TICKS.tooltip.2=Normales Autospeicherintervall (2s) ist NICHT EMPFOHLEN.
of.options.AUTOSAVE_TICKS.tooltip.3=Autospeichern verursacht den berühmten Lag des Todes.

minecraft_minecraft_optifine_lang_en_US.lang

# General
of.general.ambiguous=ambiguous
of.general.custom=Custom
of.general.from=From
of.general.id=Id
of.general.restart=restart
of.general.smart=Smart

# Keys
of.key.zoom=Zoom

# Message
of.message.aa.shaders1=Antialiasing is not compatible with Shaders.
of.message.aa.shaders2=Please disable Shaders to enable this option.

of.message.af.shaders1=Anisotropic Filtering is not compatible with Shaders.
of.message.af.shaders2=Please disable Shaders to enable this option.

of.message.fr.shaders1=Fast Render is not compatible with Shaders.
of.message.fr.shaders2=Please disable Shaders to enable this option.

of.message.shaders.aa1=Shaders are not compatible with Antialiasing. 
of.message.shaders.aa2=Please set Quality -> Antialiasing to OFF and restart the game.

of.message.shaders.af1=Shaders are not compatible with Anisotropic Filtering.
of.message.shaders.af2=Please set Quality -> Anisotropic Filtering to OFF. 

of.message.shaders.fr1=Shaders are not compatible with Fast Render.
of.message.shaders.fr2=Please set Performance -> Fast Render to OFF.

of.message.newVersion=A new §eOptiFine§f version is available: §e%s§f
of.message.java64Bit=You can install §e64-bit Java§f to increase performance
of.message.openglError=§eOpenGL Error§f: %s (%s)

of.message.shaders.loading=Loading shaders: %s

of.message.other.reset=Reset all video settings to their default values?
 
# Video settings

options.graphics.tooltip.1=Visual quality
options.graphics.tooltip.2=  Fast  - lower quality, faster
options.graphics.tooltip.3=  Fancy - higher quality, slower
options.graphics.tooltip.4=Changes the appearance of clouds, leaves, water,
options.graphics.tooltip.5=shadows and grass sides.

of.options.renderDistance.extreme=Extreme

options.renderDistance.tooltip.1=Visible distance
options.renderDistance.tooltip.2=  2 Tiny - 32m (fastest)
options.renderDistance.tooltip.3=  4 Short - 64m (faster)
options.renderDistance.tooltip.4=  8 Normal - 128m
options.renderDistance.tooltip.5=  16 Far - 256m (slower)
options.renderDistance.tooltip.6=  32 Extreme - 512m (slowest!)
options.renderDistance.tooltip.7=The Extreme view distance is very resource demanding!
options.renderDistance.tooltip.8=Values over 16 Far are only effective in local worlds.

options.ao.tooltip.1=Smooth lighting
options.ao.tooltip.2=  OFF - no smooth lighting (faster)
options.ao.tooltip.3=  Minimum - simple smooth lighting (slower)
options.ao.tooltip.4=  Maximum - complex smooth lighting (slowest)

options.framerateLimit.tooltip.1=Max framerate
options.framerateLimit.tooltip.2=  VSync - limit to monitor framerate (60, 30, 20)
options.framerateLimit.tooltip.3=  5-255 - variable
options.framerateLimit.tooltip.4=  Unlimited - no limit (fastest)
options.framerateLimit.tooltip.5=The framerate limit decreases the FPS even if
options.framerateLimit.tooltip.6=the limit value is not reached.
of.options.framerateLimit.vsync=VSync

of.options.AO_LEVEL=Smooth Lighting Level
of.options.AO_LEVEL.tooltip.1=Smooth lighting level
of.options.AO_LEVEL.tooltip.2=  OFF - no shadows
of.options.AO_LEVEL.tooltip.3=  50%% - light shadows
of.options.AO_LEVEL.tooltip.4=  100%% - dark shadows

options.viewBobbing.tooltip.1=More realistic movement.
options.viewBobbing.tooltip.2=When using mipmaps set it to OFF for best results.

options.guiScale.tooltip.1=GUI Scale
options.guiScale.tooltip.2=Smaller GUI might be faster

options.vbo.tooltip.1=Vertex Buffer Objects
options.vbo.tooltip.2=Uses an alternative rendering model which is usually
options.vbo.tooltip.3=faster (5-10%%) than the default rendering.

options.gamma.tooltip.1=Changes the brightness of darker objects
options.gamma.tooltip.2=  Moody - standard brightness
options.gamma.tooltip.3=  1-99%% - variable
options.gamma.tooltip.4=  Bright - maximum brightness for darker objects
options.gamma.tooltip.5=This options does not change the brightness of 
options.gamma.tooltip.6=fully black objects

options.anaglyph.tooltip.1=3D Anaglyph
options.anaglyph.tooltip.2=Enables a stereoscopic 3D effect using different colors
options.anaglyph.tooltip.3=for each eye.
options.anaglyph.tooltip.4=Requires red-cyan glasses for proper viewing.

options.blockAlternatives.tooltip.1=Alternate Blocks
options.blockAlternatives.tooltip.2=Uses alternative block models for some blocks.
options.blockAlternatives.tooltip.3=Depends on the selected resource pack.

of.options.FOG_FANCY=Fog
of.options.FOG_FANCY.tooltip.1=Fog type
of.options.FOG_FANCY.tooltip.2=  Fast - faster fog
of.options.FOG_FANCY.tooltip.3=  Fancy - slower fog, looks better
of.options.FOG_FANCY.tooltip.4=  OFF - no fog, fastest
of.options.FOG_FANCY.tooltip.5=The fancy fog is available only if it is supported by the 
of.options.FOG_FANCY.tooltip.6=graphic card.

of.options.FOG_START=Fog Start
of.options.FOG_START.tooltip.1=Fog start
of.options.FOG_START.tooltip.2=  0.2 - the fog starts near the player
of.options.FOG_START.tooltip.3=  0.8 - the fog starts far from the player
of.options.FOG_START.tooltip.4=This option usually does not affect the performance.

of.options.CHUNK_LOADING=Chunk Loading
of.options.CHUNK_LOADING.tooltip.1=Chunk Loading
of.options.CHUNK_LOADING.tooltip.2=  Default - unstable FPS when loading chunks
of.options.CHUNK_LOADING.tooltip.3=  Smooth - stable FPS
of.options.CHUNK_LOADING.tooltip.4=  Multi-Core - stable FPS, 3x faster world loading
of.options.CHUNK_LOADING.tooltip.5=Smooth and Multi-Core remove the stuttering and 
of.options.CHUNK_LOADING.tooltip.6=freezes caused by chunk loading.
of.options.CHUNK_LOADING.tooltip.7=Multi-Core can speed up 3x the world loading and
of.options.CHUNK_LOADING.tooltip.8=increase FPS by using a second CPU core.
of.options.chunkLoading.smooth=Smooth
of.options.chunkLoading.multiCore=Multi-Core

of.options.shaders=Shaders...
of.options.shadersTitle=Shaders

of.options.shaders.packNone=OFF
of.options.shaders.packDefault=(internal)

of.options.shaders.ANTIALIASING=Antialiasing
of.options.shaders.NORMAL_MAP=Normal Map
of.options.shaders.SPECULAR_MAP=Specular Map
of.options.shaders.RENDER_RES_MUL=Render Quality
of.options.shaders.SHADOW_RES_MUL=Shadow Quality
of.options.shaders.HAND_DEPTH_MUL=Hand Depth
of.options.shaders.CLOUD_SHADOW=Cloud Shadow
of.options.shaders.OLD_HAND_LIGHT=Old Hand Light
of.options.shaders.OLD_LIGHTING=Old Lighting
of.options.shaders.SHADER_PACK=Shader Pack

of.options.shaders.shadersFolder=Shaders Folder
of.options.shaders.shaderOptions=Shader Options...

of.options.shaderOptionsTitle=Shader Options

of.options.quality=Quality...
of.options.qualityTitle=Quality Settings

of.options.details=Details...
of.options.detailsTitle=Detail Settings

of.options.performance=Performance...
of.options.performanceTitle=Performance Settings

of.options.animations=Animations...
of.options.animationsTitle=Animation Settings

of.options.other=Other...
of.options.otherTitle=Other Settings

of.options.other.reset=Reset Video Settings...

of.shaders.profile=Profile

# Quality

of.options.mipmap.bilinear=Bilinear
of.options.mipmap.linear=Linear
of.options.mipmap.nearest=Nearest
of.options.mipmap.trilinear=Trilinear

options.mipmapLevels.tooltip.1=Visual effect which makes distant objects look better
options.mipmapLevels.tooltip.2=by smoothing the texture details
options.mipmapLevels.tooltip.3=  OFF - no smoothing
options.mipmapLevels.tooltip.4=  1 - minimum smoothing
options.mipmapLevels.tooltip.5=  4 - maximum smoothing
options.mipmapLevels.tooltip.6=This option usually does not affect the performance.

of.options.MIPMAP_TYPE=Mipmap Type
of.options.MIPMAP_TYPE.tooltip.1=Visual effect which makes distant objects look better
of.options.MIPMAP_TYPE.tooltip.2=by smoothing the texture details
of.options.MIPMAP_TYPE.tooltip.3=  Nearest - rough smoothing (fastest)
of.options.MIPMAP_TYPE.tooltip.4=  Linear - normal smoothing
of.options.MIPMAP_TYPE.tooltip.5=  Bilinear - fine smoothing
of.options.MIPMAP_TYPE.tooltip.6=  Trilinear - finest smoothing (slowest)


of.options.AA_LEVEL=Antialiasing
of.options.AA_LEVEL.tooltip.1=Antialiasing
of.options.AA_LEVEL.tooltip.2= OFF - (default) no antialiasing (faster)
of.options.AA_LEVEL.tooltip.3= 2-16 - antialiased lines and edges (slower)
of.options.AA_LEVEL.tooltip.4=The Antialiasing smooths jagged lines and 
of.options.AA_LEVEL.tooltip.5=sharp color transitions.
of.options.AA_LEVEL.tooltip.6=When enabled it may substantially decrease the FPS.
of.options.AA_LEVEL.tooltip.7=Not all levels are supported by all graphics cards.
of.options.AA_LEVEL.tooltip.8=Effective after a RESTART!

of.options.AF_LEVEL=Anisotropic Filtering
of.options.AF_LEVEL.tooltip.1=Anisotropic Filtering
of.options.AF_LEVEL.tooltip.2= OFF - (default) standard texture detail (faster)
of.options.AF_LEVEL.tooltip.3= 2-16 - finer details in mipmapped textures (slower)
of.options.AF_LEVEL.tooltip.4=The Anisotropic Filtering restores details in
of.options.AF_LEVEL.tooltip.5=mipmapped textures.
of.options.AF_LEVEL.tooltip.6=When enabled it may substantially decrease the FPS.

of.options.CLEAR_WATER=Clear Water
of.options.CLEAR_WATER.tooltip.1=Clear Water
of.options.CLEAR_WATER.tooltip.2=  ON - clear, transparent water
of.options.CLEAR_WATER.tooltip.3=  OFF - default water

of.options.RANDOM_MOBS=Random Mobs
of.options.RANDOM_MOBS.tooltip.1=Random Mobs
of.options.RANDOM_MOBS.tooltip.2=  OFF - no random mobs, faster
of.options.RANDOM_MOBS.tooltip.3=  ON - random mobs, slower
of.options.RANDOM_MOBS.tooltip.4=Random mobs uses random textures for the game creatures.
of.options.RANDOM_MOBS.tooltip.5=It needs a texture pack which has multiple mob textures.

of.options.BETTER_GRASS=Better Grass
of.options.BETTER_GRASS.tooltip.1=Better Grass
of.options.BETTER_GRASS.tooltip.2=  OFF - default side grass texture, fastest
of.options.BETTER_GRASS.tooltip.3=  Fast - full side grass texture, slower
of.options.BETTER_GRASS.tooltip.4=  Fancy - dynamic side grass texture, slowest

of.options.BETTER_SNOW=Better Snow
of.options.BETTER_SNOW.tooltip.1=Better Snow
of.options.BETTER_SNOW.tooltip.2=  OFF - default snow, faster
of.options.BETTER_SNOW.tooltip.3=  ON - better snow, slower
of.options.BETTER_SNOW.tooltip.4=Shows snow under transparent blocks (fence, tall grass)
of.options.BETTER_SNOW.tooltip.5=when bordering with snow blocks

of.options.CUSTOM_FONTS=Custom Fonts
of.options.CUSTOM_FONTS.tooltip.1=Custom Fonts
of.options.CUSTOM_FONTS.tooltip.2=  ON - uses custom fonts (default), slower
of.options.CUSTOM_FONTS.tooltip.3=  OFF - uses default font, faster
of.options.CUSTOM_FONTS.tooltip.4=The custom fonts are supplied by the current
of.options.CUSTOM_FONTS.tooltip.5=texture pack

of.options.CUSTOM_COLORS=Custom Colors
of.options.CUSTOM_COLORS.tooltip.1=Custom Colors
of.options.CUSTOM_COLORS.tooltip.2=  ON - uses custom colors (default), slower
of.options.CUSTOM_COLORS.tooltip.3=  OFF - uses default colors, faster
of.options.CUSTOM_COLORS.tooltip.4=The custom colors are supplied by the current
of.options.CUSTOM_COLORS.tooltip.5=texture pack

of.options.SWAMP_COLORS=Swamp Colors
of.options.SWAMP_COLORS.tooltip.1=Swamp Colors
of.options.SWAMP_COLORS.tooltip.2=  ON - use swamp colors (default), slower
of.options.SWAMP_COLORS.tooltip.3=  OFF - do not use swamp colors, faster
of.options.SWAMP_COLORS.tooltip.4=The swamp colors affect grass, leaves, vines and water.

of.options.SMOOTH_BIOMES=Smooth Biomes
of.options.SMOOTH_BIOMES.tooltip.1=Smooth Biomes
of.options.SMOOTH_BIOMES.tooltip.2=  ON - smoothing of biome borders (default), slower
of.options.SMOOTH_BIOMES.tooltip.3=  OFF - no smoothing of biome borders, faster
of.options.SMOOTH_BIOMES.tooltip.4=The smoothing of biome borders is done by sampling and
of.options.SMOOTH_BIOMES.tooltip.5=averaging the color of all surrounding blocks.
of.options.SMOOTH_BIOMES.tooltip.6=Affected are grass, leaves, vines and water.

of.options.CONNECTED_TEXTURES=Connected Textures
of.options.CONNECTED_TEXTURES.tooltip.1=Connected Textures
of.options.CONNECTED_TEXTURES.tooltip.2=  OFF - no connected textures (default)
of.options.CONNECTED_TEXTURES.tooltip.3=  Fast - fast connected textures
of.options.CONNECTED_TEXTURES.tooltip.4=  Fancy - fancy connected textures
of.options.CONNECTED_TEXTURES.tooltip.5=Connected textures joins the textures of glass,
of.options.CONNECTED_TEXTURES.tooltip.6=sandstone and bookshelves when placed next to
of.options.CONNECTED_TEXTURES.tooltip.7=each other. The connected textures are supplied
of.options.CONNECTED_TEXTURES.tooltip.8=by the current texture pack.

of.options.NATURAL_TEXTURES=Natural Textures
of.options.NATURAL_TEXTURES.tooltip.1=Natural Textures
of.options.NATURAL_TEXTURES.tooltip.2=  OFF - no natural textures (default)
of.options.NATURAL_TEXTURES.tooltip.3=  ON - use natural textures
of.options.NATURAL_TEXTURES.tooltip.4=Natural textures remove the gridlike pattern
of.options.NATURAL_TEXTURES.tooltip.5=created by repeating blocks of the same type.
of.options.NATURAL_TEXTURES.tooltip.6=It uses rotated and flipped variants of the base
of.options.NATURAL_TEXTURES.tooltip.7=block texture. The configuration for the natural
of.options.NATURAL_TEXTURES.tooltip.8=textures is supplied by the current texture pack

of.options.CUSTOM_SKY=Custom Sky
of.options.CUSTOM_SKY.tooltip.1=Custom Sky
of.options.CUSTOM_SKY.tooltip.2=  ON - custom sky textures (default), slow
of.options.CUSTOM_SKY.tooltip.3=  OFF - default sky, faster
of.options.CUSTOM_SKY.tooltip.4=The custom sky textures are supplied by the current
of.options.CUSTOM_SKY.tooltip.5=texture pack

of.options.CUSTOM_ITEMS=Custom Items
of.options.CUSTOM_ITEMS.tooltip.1=Custom Items
of.options.CUSTOM_ITEMS.tooltip.2=  ON - custom item textures (default), slow
of.options.CUSTOM_ITEMS.tooltip.3=  OFF - default item textures, faster
of.options.CUSTOM_ITEMS.tooltip.4=The custom item textures are supplied by the current
of.options.CUSTOM_ITEMS.tooltip.5=texture pack

# Details

of.options.CLOUDS=Clouds
of.options.CLOUDS.tooltip.1=Clouds
of.options.CLOUDS.tooltip.2=  Default - as set by setting Graphics
of.options.CLOUDS.tooltip.3=  Fast - lower quality, faster
of.options.CLOUDS.tooltip.4=  Fancy - higher quality, slower
of.options.CLOUDS.tooltip.5=  OFF - no clouds, fastest
of.options.CLOUDS.tooltip.6=Fast clouds are rendered 2D.
of.options.CLOUDS.tooltip.7=Fancy clouds are rendered 3D.

of.options.CLOUD_HEIGHT=Cloud Height
of.options.CLOUD_HEIGHT.tooltip.1=Cloud Height
of.options.CLOUD_HEIGHT.tooltip.2=  OFF - default height
of.options.CLOUD_HEIGHT.tooltip.3=  100%% - above world height limit

of.options.TREES=Trees
of.options.TREES.tooltip.1=Trees
of.options.TREES.tooltip.2=  Default - as set by setting Graphics
of.options.TREES.tooltip.3=  Fast - lower quality, faster
of.options.TREES.tooltip.4=  Smart - higher quality, fast
of.options.TREES.tooltip.5=  Fancy - highest quality, slower
of.options.TREES.tooltip.6=Fast trees have opaque leaves.
of.options.TREES.tooltip.7=Fancy and smart trees have transparent leaves.

of.options.RAIN=Rain & Snow
of.options.RAIN.tooltip.1=Rain & Snow
of.options.RAIN.tooltip.2=  Default - as set by setting Graphics
of.options.RAIN.tooltip.3=  Fast  - light rain/snow, faster
of.options.RAIN.tooltip.4=  Fancy - heavy rain/snow, slower
of.options.RAIN.tooltip.5=  OFF - no rain/snow, fastest
of.options.RAIN.tooltip.6=When rain is OFF the splashes and rain sounds
of.options.RAIN.tooltip.7=are still active.

of.options.SKY=Sky
of.options.SKY.tooltip.1=Sky
of.options.SKY.tooltip.2=  ON - sky is visible, slower
of.options.SKY.tooltip.3=  OFF  - sky is not visible, faster
of.options.SKY.tooltip.4=When sky is OFF the moon and sun are still visible.

of.options.STARS=Stars
of.options.STARS.tooltip.1=Stars
of.options.STARS.tooltip.2=  ON - stars are visible, slower
of.options.STARS.tooltip.3=  OFF  - stars are not visible, faster

of.options.SUN_MOON=Sun & Moon
of.options.SUN_MOON.tooltip.1=Sun & Moon
of.options.SUN_MOON.tooltip.2=  ON - sun and moon are visible (default)
of.options.SUN_MOON.tooltip.3=  OFF  - sun and moon are not visible (faster)

of.options.SHOW_CAPES=Show Capes
of.options.SHOW_CAPES.tooltip.1=Show Capes
of.options.SHOW_CAPES.tooltip.2=  ON - show player capes (default)
of.options.SHOW_CAPES.tooltip.3=  OFF - do not show player capes

of.options.TRANSLUCENT_BLOCKS=Translucent Blocks
of.options.TRANSLUCENT_BLOCKS.tooltip.1=Translucent Blocks
of.options.TRANSLUCENT_BLOCKS.tooltip.2=  Fancy - correct color blending (default)
of.options.TRANSLUCENT_BLOCKS.tooltip.3=  Fast - fast color blending (faster)
of.options.TRANSLUCENT_BLOCKS.tooltip.4=Controls the color blending of translucent blocks
of.options.TRANSLUCENT_BLOCKS.tooltip.5=with different color (stained glass, water, ice)
of.options.TRANSLUCENT_BLOCKS.tooltip.6=when placed behind each other with air between them.

of.options.HELD_ITEM_TOOLTIPS=Held Item Tooltips
of.options.HELD_ITEM_TOOLTIPS.tooltip.1=Held item tooltips
of.options.HELD_ITEM_TOOLTIPS.tooltip.2=  ON - show tooltips for held items (default)
of.options.HELD_ITEM_TOOLTIPS.tooltip.3=  OFF - do not show tooltips for held items

of.options.DROPPED_ITEMS=Dropped Items
of.options.DROPPED_ITEMS.tooltip.1=Dropped Items
of.options.DROPPED_ITEMS.tooltip.2=  Default - as set by setting Graphics
of.options.DROPPED_ITEMS.tooltip.3=  Fast - 2D dropped items, faster
of.options.DROPPED_ITEMS.tooltip.4=  Fancy - 3D dropped items, slower

options.entityShadows.tooltip.1=Entity Shadows
options.entityShadows.tooltip.2=  ON - show entity shadows
options.entityShadows.tooltip.3=  OFF - do not show entity shadows

of.options.VIGNETTE=Vignette
of.options.VIGNETTE.tooltip.1=Visual effect which slightly darkens the screen corners
of.options.VIGNETTE.tooltip.2=  Default - as set by the setting Graphics (default)
of.options.VIGNETTE.tooltip.3=  Fast - vignette disabled (faster)
of.options.VIGNETTE.tooltip.4=  Fancy - vignette enabled (slower)
of.options.VIGNETTE.tooltip.5=The vignette may have a significant effect on the FPS,
of.options.VIGNETTE.tooltip.6=especially when playing fullscreen.
of.options.VIGNETTE.tooltip.7=The vignette effect is very subtle and can safely
of.options.VIGNETTE.tooltip.8=be disabled

of.options.DYNAMIC_FOV=Dynamic FOV
of.options.DYNAMIC_FOV.tooltip.1=Dynamic FOV
of.options.DYNAMIC_FOV.tooltip.2=  ON - enable dynamic FOV (default)
of.options.DYNAMIC_FOV.tooltip.3=  OFF - disable dynamic FOV
of.options.DYNAMIC_FOV.tooltip.4=Changes the field of view (FOV) when flying, sprinting 
of.options.DYNAMIC_FOV.tooltip.5=or pulling a bow.

of.options.DYNAMIC_LIGHTS=Dynamic Lights
of.options.DYNAMIC_LIGHTS.tooltip.1=Dynamic Lights
of.options.DYNAMIC_LIGHTS.tooltip.2=  OFF - no dynamic lights (default)
of.options.DYNAMIC_LIGHTS.tooltip.3=  Fast - fast dynamic lights (updated every 500ms)
of.options.DYNAMIC_LIGHTS.tooltip.4=  Fancy - fancy dynamic lights (updated in real-time)
of.options.DYNAMIC_LIGHTS.tooltip.5=Enables light emitting items (torch, glowstone, etc.)
of.options.DYNAMIC_LIGHTS.tooltip.6=to illuminate everything around them when held in hand,
of.options.DYNAMIC_LIGHTS.tooltip.7=equipped by other player or dropped on the ground

# Performance

of.options.SMOOTH_FPS=Smooth FPS
of.options.SMOOTH_FPS.tooltip.1=Stabilizes FPS by flushing the graphic driver buffers
of.options.SMOOTH_FPS.tooltip.2=  OFF - no stabilization, FPS may fluctuate
of.options.SMOOTH_FPS.tooltip.3=  ON - FPS stabilization
of.options.SMOOTH_FPS.tooltip.4=This option is graphics driver dependant and its effect
of.options.SMOOTH_FPS.tooltip.5=is not always visible

of.options.SMOOTH_WORLD=Smooth World
of.options.SMOOTH_WORLD.tooltip.1=Removes lag spikes caused by the internal server.
of.options.SMOOTH_WORLD.tooltip.2=  OFF - no stabilization, FPS may fluctuate
of.options.SMOOTH_WORLD.tooltip.3=  ON - FPS stabilization
of.options.SMOOTH_WORLD.tooltip.4=Stabilizes FPS by distributing the internal server load.
of.options.SMOOTH_WORLD.tooltip.5=Effective only for local worlds (single player).

of.options.FAST_RENDER=Fast Render
of.options.FAST_RENDER.tooltip.1=Fast Render
of.options.FAST_RENDER.tooltip.2= OFF - standard rendering (default)
of.options.FAST_RENDER.tooltip.3= ON - optimized rendering (faster)
of.options.FAST_RENDER.tooltip.4=Uses optimized rendering algorithm which decreases
of.options.FAST_RENDER.tooltip.5=the GPU load and may substantionally increase the FPS.

of.options.FAST_MATH=Fast Math
of.options.FAST_MATH.tooltip.1=Fast Math
of.options.FAST_MATH.tooltip.2= OFF - standard math (default)
of.options.FAST_MATH.tooltip.3= ON - faster math
of.options.FAST_MATH.tooltip.4=Uses optimized sin() and cos() functions which can
of.options.FAST_MATH.tooltip.5=better utilize the CPU cache and increase the FPS.

of.options.CHUNK_UPDATES=Chunk Updates
of.options.CHUNK_UPDATES.tooltip.1=Chunk updates
of.options.CHUNK_UPDATES.tooltip.2= 1 - slower world loading, higher FPS (default)
of.options.CHUNK_UPDATES.tooltip.3= 3 - faster world loading, lower FPS
of.options.CHUNK_UPDATES.tooltip.4= 5 - fastest world loading, lowest FPS
of.options.CHUNK_UPDATES.tooltip.5=Number of chunk updates per rendered frame,
of.options.CHUNK_UPDATES.tooltip.6=higher values may destabilize the framerate.

of.options.CHUNK_UPDATES_DYNAMIC=Dynamic Updates
of.options.CHUNK_UPDATES_DYNAMIC.tooltip.1=Dynamic chunk updates
of.options.CHUNK_UPDATES_DYNAMIC.tooltip.2= OFF - (default) standard chunk updates per frame
of.options.CHUNK_UPDATES_DYNAMIC.tooltip.3= ON - more updates while the player is standing still
of.options.CHUNK_UPDATES_DYNAMIC.tooltip.4=Dynamic updates force more chunk updates while
of.options.CHUNK_UPDATES_DYNAMIC.tooltip.5=the player is standing still to load the world faster.

of.options.LAZY_CHUNK_LOADING=Lazy Chunk Loading
of.options.LAZY_CHUNK_LOADING.tooltip.1=Lazy Chunk Loading
of.options.LAZY_CHUNK_LOADING.tooltip.2= OFF - default server chunk loading
of.options.LAZY_CHUNK_LOADING.tooltip.3= ON - lazy server chunk loading (smoother)
of.options.LAZY_CHUNK_LOADING.tooltip.4=Smooths the integrated server chunk loading by
of.options.LAZY_CHUNK_LOADING.tooltip.5=distributing the chunks over several ticks.
of.options.LAZY_CHUNK_LOADING.tooltip.6=Turn it OFF if parts of the world do not load correctly.
of.options.LAZY_CHUNK_LOADING.tooltip.7=Effective only for local worlds and single-core CPU.

# Animations

of.options.animation.allOn=All ON
of.options.animation.allOff=All OFF
of.options.animation.dynamic=Dynamic

of.options.ANIMATED_WATER=Water Animated
of.options.ANIMATED_LAVA=Lava Animated
of.options.ANIMATED_FIRE=Fire Animated
of.options.ANIMATED_PORTAL=Portal Animated
of.options.ANIMATED_REDSTONE=Redstone Animated
of.options.ANIMATED_EXPLOSION=Explosion Animated
of.options.ANIMATED_FLAME=Flame Animated
of.options.ANIMATED_SMOKE=Smoke Animated
of.options.VOID_PARTICLES=Void Particles
of.options.WATER_PARTICLES=Water Particles
of.options.RAIN_SPLASH=Rain Splash
of.options.PORTAL_PARTICLES=Portal Particles
of.options.POTION_PARTICLES=Potion Particles
of.options.DRIPPING_WATER_LAVA=Dripping Water/Lava
of.options.ANIMATED_TERRAIN=Terrain Animated
of.options.ANIMATED_TEXTURES=Textures Animated
of.options.FIREWORK_PARTICLES=Firework Particles

# Other

of.options.LAGOMETER=Lagometer
of.options.LAGOMETER.tooltip.1=Shows the lagometer on the debug screen (F3).
of.options.LAGOMETER.tooltip.2=* Orange - Memory garbage collection
of.options.LAGOMETER.tooltip.3=* Cyan - Tick
of.options.LAGOMETER.tooltip.4=* Blue - Scheduled executables
of.options.LAGOMETER.tooltip.5=* Purple - Chunk upload
of.options.LAGOMETER.tooltip.6=* Red - Chunk updates
of.options.LAGOMETER.tooltip.7=* Yellow - Visibility check
of.options.LAGOMETER.tooltip.8=* Green - Render terrain

of.options.PROFILER=Debug Profiler
of.options.PROFILER.tooltip.1=Debug Profiler
of.options.PROFILER.tooltip.2=  ON - debug profiler is active, slower
of.options.PROFILER.tooltip.3=  OFF - debug profiler is not active, faster
of.options.PROFILER.tooltip.4=The debug profiler collects and shows debug information
of.options.PROFILER.tooltip.5=when the debug screen is open (F3)

of.options.WEATHER=Weather
of.options.WEATHER.tooltip.1=Weather
of.options.WEATHER.tooltip.2=  ON - weather is active, slower
of.options.WEATHER.tooltip.3=  OFF - weather is not active, faster
of.options.WEATHER.tooltip.4=The weather controls rain, snow and thunderstorms.
of.options.WEATHER.tooltip.5=Weather control is only possible for local worlds.

of.options.time.dayOnly=Day Only
of.options.time.nightOnly=Night Only

of.options.TIME=Time
of.options.TIME.tooltip.1=Time
of.options.TIME.tooltip.2= Default - normal day/night cycles
of.options.TIME.tooltip.3= Day Only - day only
of.options.TIME.tooltip.4= Night Only - night only
of.options.TIME.tooltip.5=The time setting is only effective in CREATIVE mode
of.options.TIME.tooltip.6=and for local worlds.

options.fullscreen.tooltip.1=Fullscreen
options.fullscreen.tooltip.2=  ON - use fullscreen mode
options.fullscreen.tooltip.3=  OFF - use window mode
options.fullscreen.tooltip.4=Fullscreen mode may be faster or slower than
options.fullscreen.tooltip.5=window mode, depending on the graphics card.

of.options.FULLSCREEN_MODE=Fullscreen Mode
of.options.FULLSCREEN_MODE.tooltip.1=Fullscreen mode
of.options.FULLSCREEN_MODE.tooltip.2=  Default - use desktop screen resolution, slower
of.options.FULLSCREEN_MODE.tooltip.3=  WxH - use custom screen resolution, may be faster
of.options.FULLSCREEN_MODE.tooltip.4=The selected resolution is used in fullscreen mode (F11).
of.options.FULLSCREEN_MODE.tooltip.5=Lower resolutions should generally be faster.

of.options.SHOW_FPS=Show FPS
of.options.SHOW_FPS.tooltip.1=Shows compact FPS and render information
of.options.SHOW_FPS.tooltip.2=  C: - chunk renderers
of.options.SHOW_FPS.tooltip.3=  E: - rendered entities + block entities
of.options.SHOW_FPS.tooltip.4=  U: - chunk updates
of.options.SHOW_FPS.tooltip.5=The compact FPS information is only shown when the
of.options.SHOW_FPS.tooltip.6=debug screen is not visible.

of.options.save.default=Default (2s)
of.options.save.20s=20s
of.options.save.3min=3min
of.options.save.30min=30min

of.options.AUTOSAVE_TICKS=Autosave
of.options.AUTOSAVE_TICKS.tooltip.1=Autosave interval
of.options.AUTOSAVE_TICKS.tooltip.2=Default autosave interval (2s) is NOT RECOMMENDED.
of.options.AUTOSAVE_TICKS.tooltip.3=Autosave causes the famous Lag Spike of Death.

options.anaglyph.tooltip.1=3D mode used with red-cyan 3D glasses.

minecraft_minecraft_optifine_lang_es_MX.lang

# General
of.general.ambiguous=ambiguo
of.general.custom=Personalizado
of.general.from=De
of.general.id=ID
of.general.restart=reiniciar
of.general.smart=Dinámico

# Message
of.message.aa.shaders1=El anti-aliasing no es compatible con Shaders.
of.message.aa.shaders2=Desactiva Shaders para habilitar esta opción.

of.message.af.shaders1=El filtrado anisotrópico no es compatible con Shaders.
of.message.af.shaders2=Desactiva Shaders para habilitar esta opción.

of.message.fr.shaders1=El renderizado rápido no es compatible con Shaders.
of.message.fr.shaders2=Desactiva Shaders para habilitar esta opción.

of.message.shaders.aa1=Shaders no es compatible con el anti-aliasing activo.
of.message.shaders.aa2=Desactiva la opción ‘anti-aliasing’ en el menú ‘calidad’ y reinicia el juego.

of.message.shaders.af1=Shaders no es compatible con el filtrado anisótropico activo.
of.message.shaders.af2=Desactiva la opción ‘filtrado antisotrópico’ en el menú ‘calidad’.

of.message.shaders.fr1=Shaders no es compatible con el renderizado rapido activo.
of.message.shaders.fr2=Desactiva la opción ‘renderizado rapido' en el menú ‘rendimiento’.

of.message.newVersion=§fUna nueva versión de §eOptiFine §festá disponible: §e%s§f
of.message.java64Bit=§fPrueba instalar §eJava versión de 64bits §fpara incrementar el rendimiento.
of.message.openglError=§eError de OpenGL§f: %s (%s)

of.message.shaders.loading=Cargando shaders: %s

of.message.other.reset=¿Quieres reiniciar la configuración de video a los valores de inicio?

# Video settings

options.graphics.tooltip.1=Calidad visual.
options.graphics.tooltip.2=  Rápida - Mayor velocidad.
options.graphics.tooltip.3=  Detallada - Mejor apariencia.
options.graphics.tooltip.4=Cambia la apariencia de nubes, hojas, agua,
options.graphics.tooltip.5=sombras y bloques con pasto.

of.options.renderDistance.extreme=Extremo

options.renderDistance.tooltip.1=Distancia de renderizado.
options.renderDistance.tooltip.2=  2 Mínimo - 32 bloques. (más rápido)
options.renderDistance.tooltip.3=  4 Corto - 64 bloques.
options.renderDistance.tooltip.4=  8 Normal - 128 bloques.
options.renderDistance.tooltip.5=  16 Lejano - 256 bloques.
options.renderDistance.tooltip.6=  32 Extremo - 512 bloques. (más lento)
options.renderDistance.tooltip.7=La distancia de renderizado extrema demanda más recursos.
options.renderDistance.tooltip.8=Valores sobre de 16 solo son efectivos en mundos locales.

options.ao.tooltip.1=Iluminación suave.
options.ao.tooltip.2=  NO - Sin suavizado de iluminación. (rápido)
options.ao.tooltip.3=  Mínima - Simple, rudo, inceirto. (lento)
options.ao.tooltip.4=  Máxima - Agradable, uniforme, neto. (más lento)

options.framerateLimit.tooltip.1=Restricción de FPS.
options.framerateLimit.tooltip.2=  VSync - Reduce los FPS a 60, 30 o 20.
options.framerateLimit.tooltip.3=  5-255 - Cambiante.
options.framerateLimit.tooltip.4=  Ilimitados - Excento, sin límites.
options.framerateLimit.tooltip.5=Los cuadros por segundo son reducidos aun si el
options.framerateLimit.tooltip.6=límite no es alcanzado.
of.options.framerateLimit.vsync=VSync

of.options.AO_LEVEL=Suavizado de iluminación
of.options.AO_LEVEL.tooltip.1=Nivel de iluminación suave.
of.options.AO_LEVEL.tooltip.2=  NO - Sin sombras.
of.options.AO_LEVEL.tooltip.3=  50%% - Sombras claras.
of.options.AO_LEVEL.tooltip.4=  100%% - Sombras oscuras.

options.viewBobbing.tooltip.1=Movimiento de la cámara al caminar. Más realista.
options.viewBobbing.tooltip.2=Para mejores resultados, desactivar cundo utilice mipmaps.

options.guiScale.tooltip.1=Escala de interfaz.
options.guiScale.tooltip.2=Entre más pequeño podría ser más rápido.

options.vbo.tooltip.1=Vertex Buffer Objects (OpenGL).
options.vbo.tooltip.2=Utiliza un modelo alternativo de renderizado que incrementa
options.vbo.tooltip.3=la velocidad de 5 a 10%% que el renderizado habitual.

options.gamma.tooltip.1=Incrementa el brillo en objetos oscuros.
options.gamma.tooltip.2=  Moderado - Brillo por defecto.
options.gamma.tooltip.3=  Claro - Máximo brillo.
options.gamma.tooltip.4=Esta opción no afecta el brillo de objetos
options.gamma.tooltip.5=completamente oscurecidos.

options.anaglyph.tooltip.1=Anaglifo 3D.
options.anaglyph.tooltip.2=Habilita un efecto estereoscópico 3D con diferente color
options.anaglyph.tooltip.3=para cada ojo.
options.anaglyph.tooltip.4=Requiere de lentes 3D rojo-azul para una vista apropiada.

options.blockAlternatives.tooltip.1=Bloques alternativos.
options.blockAlternatives.tooltip.2=Usa modelos alternativos en algunos bloques.
options.blockAlternatives.tooltip.3=Depende del paquete de texturas seleccionado.

of.options.FOG_FANCY=Neblina
of.options.FOG_FANCY.tooltip.1=Tipo de neblina.
of.options.FOG_FANCY.tooltip.2=  NO - Sin neblina, rápido.
of.options.FOG_FANCY.tooltip.3=  Rápida - Neblina ligera.
of.options.FOG_FANCY.tooltip.4=  Detallada - Neblina lenta, se ve mejor.
of.options.FOG_FANCY.tooltip.5=La neblina detallada solo está disponible si su tarjeta
of.options.FOG_FANCY.tooltip.6=de video lo soporta.

of.options.FOG_START=Distancia de neblina
of.options.FOG_START.tooltip.1=Donde empieza a verse la neblina.
of.options.FOG_START.tooltip.2=  0.2 - Desde cerca del jugador.
of.options.FOG_START.tooltip.3=  0.8 - Desde lejos del jugador.
of.options.FOG_START.tooltip.4=Esta opción normalmente no afecta el rendimiento.

of.options.CHUNK_LOADING=Carga de Chunks
of.options.CHUNK_LOADING.tooltip.1=Opción de carga de los pedazos del mapa (chunks).
of.options.CHUNK_LOADING.tooltip.2=  Normal - Cuadros por segundo (FPS) inestables al cargar chunks.
of.options.CHUNK_LOADING.tooltip.3=  Agradable - FPS constantes.
of.options.CHUNK_LOADING.tooltip.4=  Multi-Core - FPS invariables y acelera la carga de los mapas.
of.options.CHUNK_LOADING.tooltip.5=Las opciónes de Agradable y Multi-Core estabilizan y evitan que el juego
of.options.CHUNK_LOADING.tooltip.6=se trabe al cargar chunks.
of.options.CHUNK_LOADING.tooltip.7=Multi-Core aumenta hasta tres veces la velocidad de carga de los mapas
of.options.CHUNK_LOADING.tooltip.8=y también aumenta los FPS ocupando un segundo núcleo del procesador.
of.options.chunkLoading.smooth=Agradable
of.options.chunkLoading.multiCore=Multi-Core

of.options.shaders=Shaders...
of.options.shadersTitle=Shaders

of.options.shaders.packNone=NINGUNO
of.options.shaders.packDefault=(interno)

of.options.shaders.ANTIALIASING=Anti-aliasing
of.options.shaders.NORMAL_MAP=Mapa normal
of.options.shaders.SPECULAR_MAP=Mapa espectacular
of.options.shaders.RENDER_RES_MUL=Rendimiento
of.options.shaders.SHADOW_RES_MUL=Sombras
of.options.shaders.HAND_DEPTH_MUL=Profundidad
of.options.shaders.CLOUD_SHADOW=Sombra de nubes
of.options.shaders.OLD_LIGHTING=Iluminación vieja
of.options.shaders.SHADER_PACK=Paquete de shader

of.options.shaders.shadersFolder=Folder de Shaders
of.options.shaders.shaderOptions=Opciones del Shader...

of.options.shaderOptionsTitle=Opciones del Shader

of.options.quality=Calidad...
of.options.qualityTitle=Configurar calidad.

of.options.details=Detalles...
of.options.detailsTitle=Configurar detalles.

of.options.performance=Rendimiento...
of.options.performanceTitle=Configuración del rendimiento.

of.options.animations=Animaciones...
of.options.animationsTitle=Configuraciones de animaciones.

of.options.other=Otro...
of.options.otherTitle=Otras configuraciones

of.options.other.reset=Reiniciar la configuracion de video...

of.shaders.profile=Perfil

# Quality

of.options.mipmap.bilinear=Bilinial
of.options.mipmap.linear=Lineal
of.options.mipmap.nearest=Más cercano
of.options.mipmap.trilinear=Trilineal

options.mipmapLevels.tooltip.1=Efecto visual que mejora la apariencia de objetos lejanos
options.mipmapLevels.tooltip.2=suavizando los detalles de la textura al redimensionarla.
options.mipmapLevels.tooltip.3=  NO - Sin suavizar.
options.mipmapLevels.tooltip.4=  1 – Suavizado mínimo.
options.mipmapLevels.tooltip.5=  4 – Suavizado máximo.
options.mipmapLevels.tooltip.6=Esta opción no suele afectar el rendimiento.

of.options.MIPMAP_TYPE=Tipo de mipmap
of.options.MIPMAP_TYPE.tooltip.1=Efecto visual que mejora la apariencia de objetos lejanos
of.options.MIPMAP_TYPE.tooltip.2=suavizando los detalles de la textura.
of.options.MIPMAP_TYPE.tooltip.3=  Más cercano - Suavizado mínimo. (más rápido)
of.options.MIPMAP_TYPE.tooltip.4=  Lineal – Suavizado bajo.
of.options.MIPMAP_TYPE.tooltip.5=  Bilineal – Suavizado alto.
of.options.MIPMAP_TYPE.tooltip.6=  Trilineal – Suavizado máximo. (más lento)


of.options.AA_LEVEL=Anti-aliasing
of.options.AA_LEVEL.tooltip.1=Anti-aliasing.
of.options.AA_LEVEL.tooltip.2=  NO - Por defecto. (rápido)
of.options.AA_LEVEL.tooltip.3=  2-16 – Líneas y esquinas más definidas. (lento)
of.options.AA_LEVEL.tooltip.4=El antialiasing mejora y define los bordes de las líneas
of.options.AA_LEVEL.tooltip.5=y las profundas trancisiones de color.
of.options.AA_LEVEL.tooltip.6=Esta opción puede sustancialemnte disminuir los FPS.
of.options.AA_LEVEL.tooltip.7=No todos los niveles son soportados por todas las tarjetas de video.
of.options.AA_LEVEL.tooltip.8=Los cambios serán efectivos al reinicio.

of.options.AF_LEVEL=Filtro anisotrópico
of.options.AF_LEVEL.tooltip.1=Filtrado anisotrópico.
of.options.AF_LEVEL.tooltip.2=  NO - Por defecto. Sin efectos. (rápido)
of.options.AF_LEVEL.tooltip.3=  2-16 – Detalles más finos en texturas con mipmap. (lento)
of.options.AF_LEVEL.tooltip.4=El filtro anisotrópico reafirma detalles en texturas
of.options.AF_LEVEL.tooltip.5=que usan mipmap.
of.options.AF_LEVEL.tooltip.6=Esta opción puede disminuir los FPS.

of.options.CLEAR_WATER=Claridad del agua
of.options.CLEAR_WATER.tooltip.1=Al sumergirse en ella.
of.options.CLEAR_WATER.tooltip.2=  NO – Agua normal.
of.options.CLEAR_WATER.tooltip.3=  SÍ – Agua más transparente.

of.options.RANDOM_MOBS=Mobs aleatorios
of.options.RANDOM_MOBS.tooltip.1=Mobs aleaotrios.
of.options.RANDOM_MOBS.tooltip.2=  NO – Sin skins aleatorios de mobs. (rápido)
of.options.RANDOM_MOBS.tooltip.3=  SÍ – Skins de mobs aleatorios. (lento)
of.options.RANDOM_MOBS.tooltip.4=Esta opción habilita el uso de skins aleatorias para mobs por
of.options.RANDOM_MOBS.tooltip.5=lo que requiere de un paquete de texturas que los contenga.

of.options.BETTER_GRASS=Pasto bonito
of.options.BETTER_GRASS.tooltip.1=Modifica como se ven los lados de los bloques de tierra con pasto.
of.options.BETTER_GRASS.tooltip.2=  NO – Predeterminada. (rápido)
of.options.BETTER_GRASS.tooltip.3=  Rápida – Todos los lados se ven de pasto.
of.options.BETTER_GRASS.tooltip.4=  Detallada – Textura dinámica de pasto en los lados. (lento)

of.options.BETTER_SNOW=Mejora de nieve
of.options.BETTER_SNOW.tooltip.1=Nieve especial.
of.options.BETTER_SNOW.tooltip.2=  NO – Nieve por defecto. (rápido)
of.options.BETTER_SNOW.tooltip.3=  SÍ – Mejora la nieve. (lento)
of.options.BETTER_SNOW.tooltip.4=Muestra nieve debajo de los bloques transparentes como vallas,
of.options.BETTER_SNOW.tooltip.5=pasto alto, cuando su base está rodeada por bloques de nieve.

of.options.CUSTOM_FONTS=Fuentes personalizadas
of.options.CUSTOM_FONTS.tooltip.1=Cambia la tipografía del texto.
of.options.CUSTOM_FONTS.tooltip.2=  NO – Utiliza la fuente de letra por defecto. (rápido)
of.options.CUSTOM_FONTS.tooltip.3=  SÍ – Usar fuentes de letra personalizadas. (lento)
of.options.CUSTOM_FONTS.tooltip.4=Esta opción utiliza la fuente de letra que contenga el
of.options.CUSTOM_FONTS.tooltip.5=paquete de texturas seleccionado.

of.options.CUSTOM_COLORS=Colores personalizadas
of.options.CUSTOM_COLORS.tooltip.1=Cambia los colores.
of.options.CUSTOM_COLORS.tooltip.2=  NO - Por defecto. (rápido)
of.options.CUSTOM_COLORS.tooltip.3=  SÍ – Utiliza otros colores. (lento)
of.options.CUSTOM_COLORS.tooltip.4=Esta opción emplea los colores que disponga del
of.options.CUSTOM_COLORS.tooltip.5=paquete de texturas seleccionado.

of.options.SWAMP_COLORS=Colores pantanosos
of.options.SWAMP_COLORS.tooltip.1=Colores pantanosos.
of.options.SWAMP_COLORS.tooltip.2=  NO – No usa colores pantanosos. (rápido)
of.options.SWAMP_COLORS.tooltip.3=  SÍ - Usa colores pantanosos. (lento)
of.options.SWAMP_COLORS.tooltip.4=Esta opción afecta los colores del pasto, lianas, hojas y agua.

of.options.SMOOTH_BIOMES=Biomas suavizados
of.options.SMOOTH_BIOMES.tooltip.1=Cambio entre biomas moderado y suavizado.
of.options.SMOOTH_BIOMES.tooltip.2=  NO – Sin suavizado. (rápido)
of.options.SMOOTH_BIOMES.tooltip.3=  SÍ – Suavizado. (lento)
of.options.SMOOTH_BIOMES.tooltip.4=El suavizado de las fronteras de los biomas colindantes se realiza
of.options.SMOOTH_BIOMES.tooltip.5=combinando y contemplando el color de los bloques de alrededor.
of.options.SMOOTH_BIOMES.tooltip.6=Solo afecta a hojas, pastos, lianas y agua.

of.options.CONNECTED_TEXTURES=Texturas conectadas
of.options.CONNECTED_TEXTURES.tooltip.1=Textruas conectadas.
of.options.CONNECTED_TEXTURES.tooltip.2=  NO – Sin texturas conectadas. Por defecto.
of.options.CONNECTED_TEXTURES.tooltip.3=  Rápido – Texturas conectadas rápidas.
of.options.CONNECTED_TEXTURES.tooltip.4=  Detallada – Texturas conectadas finas.
of.options.CONNECTED_TEXTURES.tooltip.5=Es la forma en la que la textura de los bloques de cristal,
of.options.CONNECTED_TEXTURES.tooltip.6=arena, librerías, se conectan entre sí cuando son puestas
of.options.CONNECTED_TEXTURES.tooltip.7=junto a otras del mismo. Las texturas como se unen
of.options.CONNECTED_TEXTURES.tooltip.8=depende del paquete de texturas seleccionado.

of.options.NATURAL_TEXTURES=Texturas naturales
of.options.NATURAL_TEXTURES.tooltip.1=Apariencia normal y natural de la textura.
of.options.NATURAL_TEXTURES.tooltip.2=  NO – Sin texturas mejoradas. Por defecto.
of.options.NATURAL_TEXTURES.tooltip.3=  SÍ – Mejora la textura.
of.options.NATURAL_TEXTURES.tooltip.4=Esta opción evita que se tenga una visión repetitiva
of.options.NATURAL_TEXTURES.tooltip.5=de los bloques al juntar bloques del mismo tipo.
of.options.NATURAL_TEXTURES.tooltip.6=Usa variantes en el giro y la rotacón de la textura del
of.options.NATURAL_TEXTURES.tooltip.7=bloque. La configuración del ajuste depende del paquete
of.options.NATURAL_TEXTURES.tooltip.8=de texturas seleccionado.

of.options.CUSTOM_SKY=Cielo personalizado
of.options.CUSTOM_SKY.tooltip.1=Cielo personalizado.
of.options.CUSTOM_SKY.tooltip.2=  NO – Cielo predeterminado. (rápido)
of.options.CUSTOM_SKY.tooltip.3=  SÍ – Texturas del cielo personalizadas. Por defecto. (lento)
of.options.CUSTOM_SKY.tooltip.4=La textura para el cielo personalizado es obtenida del
of.options.CUSTOM_SKY.tooltip.5=paquete de texturas seleccionado.

of.options.CUSTOM_ITEMS=Obejetos personalizados
of.options.CUSTOM_ITEMS.tooltip.1=Usa texturas para los objetos.
of.options.CUSTOM_ITEMS.tooltip.2=  NO – Texturas de objetos predeterminadas. (rápido)
of.options.CUSTOM_ITEMS.tooltip.3=  SÍ – Texturas de objetos personalizadas. Por defecto. (lento)
of.options.CUSTOM_ITEMS.tooltip.4=Las texturas de los objetos personalizados se obtienen del
of.options.CUSTOM_ITEMS.tooltip.5=paquete de texturas seleccionado.

# Details

of.options.CLOUDS=Nube
of.options.CLOUDS.tooltip.1=Como se ven las nubes.
of.options.CLOUDS.tooltip.2=  NO - Sin nubes. (más rápido)
of.options.CLOUDS.tooltip.3=  Normal - Establecido en la configuración de calidad visual.
of.options.CLOUDS.tooltip.4=  Rápida - Menor calidad. (rápido)
of.options.CLOUDS.tooltip.5=  Detallada - Alta calidad. (lento)
of.options.CLOUDS.tooltip.6=Las nubes con menor calidad son renderizadas en 2D.
of.options.CLOUDS.tooltip.7=Las nubes con calidad alta son renderizadas en 3D.

of.options.CLOUD_HEIGHT=Altitud de nube
of.options.CLOUD_HEIGHT.tooltip.1=Que tan arriba se muestran las nubes.
of.options.CLOUD_HEIGHT.tooltip.2=  NO - Altitud por defecto.
of.options.CLOUD_HEIGHT.tooltip.3=  100%% - Por encima del límite de altitud.

of.options.TREES=Árboles
of.options.TREES.tooltip.1=Como se ven las hojas de los árboles.
of.options.TREES.tooltip.2=  Normal - Establecido en la configuración de calidad visual.
of.options.TREES.tooltip.3=  Rápida - Menor calidad. (más rápido)
of.options.TREES.tooltip.4=  Dinámico - Mayor calidad.
of.options.TREES.tooltip.5=  Detallada - Calidad alta. (más lento)
of.options.TREES.tooltip.6=Los árboles con menor calidad tienen las hojas opacas.
of.options.TREES.tooltip.7=Los árboles con mayor calidad o dinámicos tienen hojas transparentes.

of.options.RAIN=Nieve y lluvia
of.options.RAIN.tooltip.1=Lluvia y nieve.
of.options.RAIN.tooltip.2=  NO - Sin nieve o lluvia. (más rápido)
of.options.RAIN.tooltip.3=  Normal - Establecido en la configuración de calidad visual.
of.options.RAIN.tooltip.4=  Rápida - Lluvia y nive ligera. (rápido)
of.options.RAIN.tooltip.5=  Detallada - Lluvia y nieve pesada. (lento)
of.options.RAIN.tooltip.6=Esta opción no afecta a las salpicaduras o al ruido de la
of.options.RAIN.tooltip.7=lluvia que se siguen mostrando.

of.options.SKY=Cielo
of.options.SKY.tooltip.1=Cielo.
of.options.SKY.tooltip.2=  NO - No se ve el cielo. (rápido)
of.options.SKY.tooltip.3=  SÍ - Se ve el cielo. (lento)
of.options.SKY.tooltip.4=Si se desactiva, el sol y la luna aun pueden estar visibles.

of.options.STARS=Estrellas
of.options.STARS.tooltip.1=Visibilidad de estrellas del cielo nocturno.
of.options.STARS.tooltip.2=  NO - Las estrellas no son visibles. (rápido)
of.options.STARS.tooltip.3=  SÍ - Las estrellas son visibles. (lento)

of.options.SUN_MOON=Sol y luna
of.options.SUN_MOON.tooltip.1=Visibilidad de la luna y del sol.
of.options.SUN_MOON.tooltip.2=  NO - El sol y la luna no son visibles. (más rápido)
of.options.SUN_MOON.tooltip.3=  SÍ - El sol y la luna son visibles. Por defecto.

of.options.SHOW_CAPES=Mostrar capas
of.options.SHOW_CAPES.tooltip.1=Muestra las capas en los jugadores.
of.options.SHOW_CAPES.tooltip.2=  NO - No mostrar la capa de los jugadores.
of.options.SHOW_CAPES.tooltip.3=  SÍ - Mostrar la capa de los jugadores. Por defecto.

of.options.TRANSLUCENT_BLOCKS=Bloque translúcido
of.options.TRANSLUCENT_BLOCKS.tooltip.1=Bloques con transparencia.
of.options.TRANSLUCENT_BLOCKS.tooltip.2=  Normal - Establecido en la configuración de calidad visual.
of.options.TRANSLUCENT_BLOCKS.tooltip.3=  Rápida - Mezcla de colores ligera. (rápido)
of.options.TRANSLUCENT_BLOCKS.tooltip.4=  Detallada - Corrección definida de colores. (lento)
of.options.TRANSLUCENT_BLOCKS.tooltip.5=Controla el cambio de color entre bloques translúcidos (cristal
of.options.TRANSLUCENT_BLOCKS.tooltip.6=teñido, agua, hielo) cuando son puestos separados por aire.

of.options.HELD_ITEM_TOOLTIPS=Item en mano
of.options.HELD_ITEM_TOOLTIPS.tooltip.1=Muestra información encima del hotbar al cambiar de item en mano.
of.options.HELD_ITEM_TOOLTIPS.tooltip.2=  NO - No muestra información.
of.options.HELD_ITEM_TOOLTIPS.tooltip.3=  SÍ - Muestra información. Por defecto.

of.options.DROPPED_ITEMS=Items caídos
of.options.DROPPED_ITEMS.tooltip.1=Afecta como se ven los items.
of.options.DROPPED_ITEMS.tooltip.2=  Normal - Establecido en la configuración de calidad visual.
of.options.DROPPED_ITEMS.tooltip.3=  Rápida - Los items caídos se ven en 2D. (rápido)
of.options.DROPPED_ITEMS.tooltip.4=  Detallada - Los items caídos se ven en 3D. (lento)

options.entityShadows.tooltip.1=Sombra de entidades (mobs, jugadores, etcétera).
options.entityShadows.tooltip.2=  NO - No muestra sombras de entidades.
options.entityShadows.tooltip.3=  SÍ - Muestra sombras de entidades.

of.options.VIGNETTE=Viñeta
of.options.VIGNETTE.tooltip.1=Efecto visual, ligeramente oscurece las esquinas en la pantalla.
of.options.VIGNETTE.tooltip.2=  Normal - Establecido en la configuración de calidad visual.
of.options.VIGNETTE.tooltip.3=  Rápida - Efecto desactivado. (rápido)
of.options.VIGNETTE.tooltip.4=  Detallda - Efecto activado. (lento)
of.options.VIGNETTE.tooltip.5=Esta opción puede tener un impacto significativo en los FPS,
of.options.VIGNETTE.tooltip.6=especialmente cuando juega en pantalla completa.
of.options.VIGNETTE.tooltip.7=Este efecto es liviano por lo que puede ser desactivado
of.options.VIGNETTE.tooltip.8=con seguridad en cualquier momento.

# Performance

of.options.SMOOTH_FPS=Estabilizar FPS
of.options.SMOOTH_FPS.tooltip.1=Fija los FPS nivelando el buffer del driver de video.
of.options.SMOOTH_FPS.tooltip.2=  NO - Sin estabilización. FPS cambiantes.
of.options.SMOOTH_FPS.tooltip.3=  SÍ - Estabilización de FPS.
of.options.SMOOTH_FPS.tooltip.4=Esta opción depende del controlador de la tarjeta de gráficos.
of.options.SMOOTH_FPS.tooltip.5=Su efecto podría no siempre ser notorio.

of.options.SMOOTH_WORLD=Carga ágil
of.options.SMOOTH_WORLD.tooltip.1=Disminuye el lag repentino causado por el servidor interno.
of.options.SMOOTH_WORLD.tooltip.2=  NO - Sin estabilización. FPS variantes.
of.options.SMOOTH_WORLD.tooltip.3=  SÍ - Estabiliza los FPS.
of.options.SMOOTH_WORLD.tooltip.4=Estabiliza los FPS, dividiendo la carga del servidor interno.
of.options.SMOOTH_WORLD.tooltip.5=Efectivo solo en mundos locales.

of.options.FAST_RENDER=Renderizado rápido
of.options.FAST_RENDER.tooltip.1=Renderizado rápido.
of.options.FAST_RENDER.tooltip.2=  NO - Renderizado estandard. Por defecto.
of.options.FAST_RENDER.tooltip.3=  SÍ - Renderizado optimizado. (rápido)
of.options.FAST_RENDER.tooltip.4=Utiliza un algoritmo de renderizado optimizado que reduce
of.options.FAST_RENDER.tooltip.5=la carga del GPU, aumentando sustancialmente los FPS.

of.options.FAST_MATH=Matemática avanzada
of.options.FAST_MATH.tooltip.1=Matemática avanzada.
of.options.FAST_MATH.tooltip.2=  NO - Matemática estandard. Por defecto.
of.options.FAST_MATH.tooltip.3=  SÍ - Matemática rápida.
of.options.FAST_MATH.tooltip.4=Utiliza funciones sin() y cos() optimizadas usando
of.options.FAST_MATH.tooltip.5=el cache del CPU e incrementa los FPS.

of.options.CHUNK_UPDATES=Actualizaciones de chunks
of.options.CHUNK_UPDATES.tooltip.1=Carga de chunks del mapa por FPS (cuadros por segundo).
of.options.CHUNK_UPDATES.tooltip.2=  1 - Carga del mundo lenta. Más FPS. Por defecto.
of.options.CHUNK_UPDATES.tooltip.3=  3 - Carga del mundo rápida. Menos FPS.
of.options.CHUNK_UPDATES.tooltip.4=  5 - Carga del mundo más rápida. Menos FPS.
of.options.CHUNK_UPDATES.tooltip.5=Es el número de actualizaciones de los pedazos del mapa renderizados
of.options.CHUNK_UPDATES.tooltip.6=por FPS, valores muy altos pueden desestabilizar los FPS.

of.options.CHUNK_UPDATES_DYNAMIC=Actualizaciones dinámicas
of.options.CHUNK_UPDATES_DYNAMIC.tooltip.1=Actualizaciones dinámicas de chunks.
of.options.CHUNK_UPDATES_DYNAMIC.tooltip.2=  NO - Actualizaciones de chunks por FPS estandar. Por defecto.
of.options.CHUNK_UPDATES_DYNAMIC.tooltip.3=  SÍ - Actualizaciones incluso cuando el jugador no se mueve.
of.options.CHUNK_UPDATES_DYNAMIC.tooltip.4=Esta opción facilita actualizaciones de chunks incluso mientras el
of.options.CHUNK_UPDATES_DYNAMIC.tooltip.5=jugador no se mueve, para cargar el mundo mucho más rápido.

of.options.LAZY_CHUNK_LOADING=Carga retardada
of.options.LAZY_CHUNK_LOADING.tooltip.1=Carga de los pedazos del mapa con retardo.
of.options.LAZY_CHUNK_LOADING.tooltip.2=  NO - Carga de chunks determinada por el servidor.
of.options.LAZY_CHUNK_LOADING.tooltip.3=  SÍ - Carga de chunks lenta. Más atractiva.
of.options.LAZY_CHUNK_LOADING.tooltip.4=Retraza en varios ticks la carga de chunks integrada por el
of.options.LAZY_CHUNK_LOADING.tooltip.5=servidor.
of.options.LAZY_CHUNK_LOADING.tooltip.6=Desactiva esta opción si el mapa no se carga correctamente.
of.options.LAZY_CHUNK_LOADING.tooltip.7=Efectivo solo en mundos locales y con procesadores de 1 solo núcleo.

# Animations

of.options.animation.allOn=Activar todo
of.options.animation.allOff=Desactivar todo
of.options.animation.dynamic=Dinámico

of.options.ANIMATED_WATER=Animación de agua
of.options.ANIMATED_LAVA=Animación de lava
of.options.ANIMATED_FIRE=Animación de fuego
of.options.ANIMATED_PORTAL=Animación del portal
of.options.ANIMATED_REDSTONE=Animación del redstone
of.options.ANIMATED_EXPLOSION=Animación de explosiones
of.options.ANIMATED_FLAME=Animación de fuego
of.options.ANIMATED_SMOKE=Animación de humo
of.options.VOID_PARTICLES=Partículas del Fin
of.options.WATER_PARTICLES=Partículas de agua
of.options.RAIN_SPLASH=Salpicadura de lluvia
of.options.PORTAL_PARTICLES=Partículas de portal
of.options.POTION_PARTICLES=Partículas de pociones
of.options.DRIPPING_WATER_LAVA=Goteo de agua y lava
of.options.ANIMATED_TERRAIN=Animación del terreno
of.options.ANIMATED_TEXTURES=Animación de texturas
of.options.FIREWORK_PARTICLES=Partículas de cohetes

# Other

of.options.LAGOMETER=Medidor de lag
of.options.LAGOMETER.tooltip.1=Muestra una gráfica en la pantalla de depuración (F3).
of.options.LAGOMETER.tooltip.2=* Naranja - Memoria desperdiciada.
of.options.LAGOMETER.tooltip.3=* Cian - Tick.
of.options.LAGOMETER.tooltip.4=* Azul - Tareas programadas.
of.options.LAGOMETER.tooltip.5=* Purpura - Carga de chunks.
of.options.LAGOMETER.tooltip.6=* Rojo - Actualizaciones de chunks.
of.options.LAGOMETER.tooltip.7=* Amarillo - Visibilidad.
of.options.LAGOMETER.tooltip.8=* Verde - Terreno de renderizado.

of.options.PROFILER=Debug
of.options.PROFILER.tooltip.1=Perfil de debug.
of.options.PROFILER.tooltip.2=  NO - Debug desactivado. (rápido)
of.options.PROFILER.tooltip.3=  SÍ - Debug activado. (lento)
of.options.PROFILER.tooltip.4=Recopila información de debug y la muestra en
of.options.PROFILER.tooltip.5=la pantalla de dupuración (F3).

of.options.WEATHER=Clima
of.options.WEATHER.tooltip.1=Clima.
of.options.WEATHER.tooltip.2=  NO - Desactiva el clima. (rápido)
of.options.WEATHER.tooltip.3=  SÍ - Activa el clima. (lento)
of.options.WEATHER.tooltip.4=Esta opción afecta a las lluvias, la nieve y las tormentas.
of.options.WEATHER.tooltip.5=Solo funciona en mundos locales.

of.options.time.dayOnly=Día
of.options.time.nightOnly=Noche

of.options.TIME=Tiempo
of.options.TIME.tooltip.1=Establece el momento del día.
of.options.TIME.tooltip.2=  Normal - Ciclo de dia y noche normal.
of.options.TIME.tooltip.3=  Día - Siempre es de día.
of.options.TIME.tooltip.4=  Noche - Siempre es de noche.
of.options.TIME.tooltip.5=Esta opción solo es efectiva estando en modo creativo
of.options.TIME.tooltip.6=y en mundos locales.

options.fullscreen.tooltip.1=Pantalla completa.
options.fullscreen.tooltip.2=  NO - Modo de ventana.
options.fullscreen.tooltip.3=  SÍ - Modo de pantalla completa.
options.fullscreen.tooltip.4=En pantalla completa funciona más rapido que en modo
options.fullscreen.tooltip.5=de ventana, dependiendo de la tarjeta de video.

of.options.FULLSCREEN_MODE=Resolución
of.options.FULLSCREEN_MODE.tooltip.1=Dimensiones al entrar en modo pantalla completa.
of.options.FULLSCREEN_MODE.tooltip.2=  Default - Se ajusta a la pantalla. (lento)
of.options.FULLSCREEN_MODE.tooltip.3=  Ancho por Altura - Utiliza la resolución personalizada.
of.options.FULLSCREEN_MODE.tooltip.4=La resoulución de pantalla seleccionada es usada al entrar en pantalla
of.options.FULLSCREEN_MODE.tooltip.5=completa. Resouluciónes pequeñas generalmente son más rápidas.

of.options.SHOW_FPS=Medidor de FPS
of.options.SHOW_FPS.tooltip.1=Despliega los FPS, además de otra información, resumida.
of.options.SHOW_FPS.tooltip.2=  C: - Renderizado de chunks.
of.options.SHOW_FPS.tooltip.3=  E: - Entidades y de bloques renderizadas.
of.options.SHOW_FPS.tooltip.4=  U: - Actualizaciones de chunks.
of.options.SHOW_FPS.tooltip.5=La información solo se muestra cuando la pantalla
of.options.SHOW_FPS.tooltip.6=de depuración (F3) no es visible.

of.options.save.default=Predeterminado (2s)
of.options.save.20s=20 s
of.options.save.3min=3 min
of.options.save.30min=30 min

of.options.AUTOSAVE_TICKS=Autoguardado
of.options.AUTOSAVE_TICKS.tooltip.1=Intervalo de autoguardado de mundos locales.
of.options.AUTOSAVE_TICKS.tooltip.2=  Predeterminado - Intervalo por defecto. NO RECOMENDADO.
of.options.AUTOSAVE_TICKS.tooltip.3=Esta función causa el famoso lag de la muerte.

options.anaglyph.tooltip.1=La función de anaglifo 3D requiere de lentes 3D rojo-azul.

minecraft_minecraft_optifine_lang_ja_JP.lang

# Contributors of Japanese localization #
#   takanasayo 2012-12-01 ---- 2013-07-15
#   CrafterKina 2014-01-04 ---- 2016-04-14

# General
of.general.custom=カスタム
of.general.from=から
of.general.id=ID
of.general.restart=再起動
of.general.ambiguous=不明確
of.general.smart=賢い処理

# Message
of.message.aa.shaders1=輪郭のギザギザ軽減処理はシェーダーと共存できません。
of.message.aa.shaders2=このオプションを有効にするには、シェーダを無効にしてください。

of.message.af.shaders1=奥行きのチラツキ抑制処理はシェーダーと共存できません。
of.message.af.shaders2=このオプションを有効にするには、シェーダを無効にしてください。

of.message.fr.shaders1=描画を速くする処理はシェーダーと共存できません。
of.message.fr.shaders1=このオプションを有効にするには、シェーダを無効にしてください。

of.message.shaders.aa1=シェーダーは輪郭のギザギザ軽減処理と共存できません。
of.message.shaders.aa2=クオリティの詳細設定 -> 輪郭のギザギザ軽減 をオフにし、ゲームを再起動してください。

of.message.shaders.af1=シェーダーは奥行きのチラツキ抑制処理と共存できません。
of.message.shaders.af2=クオリティの詳細設定 -> 奥行きのチラツキ抑制 をオフにし、ゲームを再起動してください。

of.message.shaders.fr1=シェーダーは描画を速くする処理と共存できません。
of.message.shaders.fr2=クオリティの詳細設定 -> 描画を速く をオフにし、ゲームを再起動してください。

of.message.newVersion=新しい§eOptiFine§fが公開されました: §e%s§f
of.message.java64Bit=パフォーマンスを高めるために§e64-bit Java§fが利用できます。
of.message.openglError=§eOpenGLエラー§f: %s (%s)

of.message.shaders.loading=シェーダーをロード中: %s

of.message.other.reset=全ての設定を元の状態に戻してもよろしいですか？
 
# Video settings

options.graphics.tooltip.1=グラフィックス
options.graphics.tooltip.2=  処理優先  - 低い品質、 低負荷
options.graphics.tooltip.3=  描画優先 - 高い品質、 高負荷
options.graphics.tooltip.4=葉の透過、アイテムやMobの影、ドロップアイテムの3D描写、
options.graphics.tooltip.5=厚みのある雲、水の2パスレンダリング、といったグラフィック効果を変更します。

of.options.renderDistance.extreme=凄く遠い

options.renderDistance.tooltip.1=描画距離
options.renderDistance.tooltip.2=  2 最短 - 32m先まで描画する (より低負荷)
options.renderDistance.tooltip.3=  4 短い - 64m先まで描画する (低負荷)
options.renderDistance.tooltip.4=  8 普通 - 128m先まで描画する
options.renderDistance.tooltip.5=  16 遠い - 256m先まで描画する (高負荷)
options.renderDistance.tooltip.6=  32 凄く遠い - 512m先まで描画する (超高負荷!)
options.renderDistance.tooltip.7=「凄く遠い」設定は非常に高いグラフィックス性能を要求します!
options.renderDistance.tooltip.8=「遠い」を超える描画距離はシングルのワールドでのみ効果があります。

options.ao.tooltip.1=スムースライティング
options.ao.tooltip.2=  オフ - スムースライティングを使用しない (低負荷)
options.ao.tooltip.3=  最小 - 簡単なスムースライティング (高負荷)
options.ao.tooltip.4=  最大 - 複雑なスムースライティング (より高負荷)

options.framerateLimit.tooltip.1=最大のフレームレート
options.framerateLimit.tooltip.2=  垂直同期 - モニターのフレームレートに合わせる (60, 30, 20)
options.framerateLimit.tooltip.3=  5～255 - フレームレートを設定した値までに制限する
options.framerateLimit.tooltip.4=  無制限 - フレームレートを制限しない (最速)
options.framerateLimit.tooltip.5=たとえ制限に達していなくとも、
options.framerateLimit.tooltip.6=フレームレートを抑制します。
of.options.framerateLimit.vsync=垂直同期

of.options.AO_LEVEL=スムースライティング
of.options.AO_LEVEL.tooltip.1=スムースライティングの程度を調整する
of.options.AO_LEVEL.tooltip.2=  オフ - 影なし
of.options.AO_LEVEL.tooltip.3=  50%% - 明るい影
of.options.AO_LEVEL.tooltip.4=  100%% - 暗い影

options.viewBobbing.tooltip.1=画面の揺れ
options.viewBobbing.tooltip.2=ミップマップをオフにした時に最もよい結果が出ます。

options.guiScale.tooltip.1=GUIの大きさ
options.guiScale.tooltip.2=GUIは小さいほうが処理が速くなるかもしれません。

options.vbo.tooltip.1=Vertex Buffer Objects
options.vbo.tooltip.2=描画方式を新しいものに変更し、
options.vbo.tooltip.3=5～10%%処理を軽くできます。

options.gamma.tooltip.1=暗い物体の明るさの変更
options.gamma.tooltip.2=  暗い - 通常の明るさ
options.gamma.tooltip.3=  1～99%% - 明るさを調整する
options.gamma.tooltip.4=  明るい - 最大の明るさ
options.gamma.tooltip.5=完全に真っ暗な物体の明るさは、
options.gamma.tooltip.6=変更できません。

options.anaglyph.tooltip.1=3Dアナグリフ
options.anaglyph.tooltip.2=それぞれの目に別々の色を使うことで
options.anaglyph.tooltip.3=立体視を可能にする機能を有効にします。
options.anaglyph.tooltip.4=赤青3Dメガネが必要です。 

options.blockAlternatives.tooltip.1=代替ブロック
options.blockAlternatives.tooltip.2=幾つかのブロックで代替モデルを使用します。
options.blockAlternatives.tooltip.3=選択されたリソースパックに依存します。

of.options.FOG_FANCY=霧の種類
of.options.FOG_FANCY.tooltip.1=霧の種類の設定
of.options.FOG_FANCY.tooltip.2=  処理優先 - 低負荷な霧
of.options.FOG_FANCY.tooltip.3=  描画優先 - 高負荷な霧 より良く見える
of.options.FOG_FANCY.tooltip.4=  オフ - 霧なし 最低負荷
of.options.FOG_FANCY.tooltip.5=グラフィックカードが対応している場合のみ
of.options.FOG_FANCY.tooltip.6=美麗な霧を使用できます。

of.options.FOG_START=霧の距離
of.options.FOG_START.tooltip.1=プレイヤーと霧の距離の設定
of.options.FOG_START.tooltip.2=  0.2 - プレイヤーと霧の距離を最も近くする
of.options.FOG_START.tooltip.3=  0.8 - プレイヤーと霧の距離を最も遠くする
of.options.FOG_START.tooltip.4=この設定は大抵の場合パフォーマンスに影響を与えません。

of.options.CHUNK_LOADING=チャンク読込方法
of.options.CHUNK_LOADING.tooltip.1=チャンクの読み込み方法
of.options.CHUNK_LOADING.tooltip.2=  デフォルト - チャンクロード時、FPSは安定しない。
of.options.CHUNK_LOADING.tooltip.3=  滑らか - フレームレート低下を抑制。
of.options.CHUNK_LOADING.tooltip.4=  マルチコア - フレームレートのさらなる安定化 ワールドのロード処理が三倍ほど速くなる。
of.options.CHUNK_LOADING.tooltip.5=滑らかやマルチコアであれば、チャンクロードに起因する
of.options.CHUNK_LOADING.tooltip.6=カクつきとフリーズを除けます。
of.options.CHUNK_LOADING.tooltip.7=マルチコアでは二番目のCPUを用いることでワールドのロード処理が
of.options.CHUNK_LOADING.tooltip.8=三倍ほど速くでき、FPSも改善できます。
of.options.chunkLoading.smooth=滑らか
of.options.chunkLoading.multiCore=マルチコア

of.options.shaders=シェーダーの詳細設定...
of.options.shadersTitle=シェーダーの詳細設定

of.options.shaders.ANTIALIASING=アンチエイリアス処理
of.options.shaders.NORMAL_MAP=法線マッピング
of.options.shaders.SPECULAR_MAP=鏡面反射マッピング
of.options.shaders.RENDER_RES_MUL=描画の品質
of.options.shaders.SHADOW_RES_MUL=影の品質
of.options.shaders.HAND_DEPTH_MUL=手部深度
of.options.shaders.CLOUD_SHADOW=雲の影
of.options.shaders.OLD_HAND_LIGHT=古い手持ち光源
of.options.shaders.OLD_LIGHTING=古いライティング
of.options.shaders.SHADER_PACK=シェーダーパック

of.options.shaders.packNone=OFF
of.options.shaders.packDefault=(internal)

of.options.shaders.shadersFolder=シェーダーのフォルダー
of.options.shaders.shaderOptions=シェーダーのオプション設定...
	
of.options.shaderOptionsTitle=シェーダーのオプション設定

of.options.quality=クオリティの詳細設定...
of.options.qualityTitle=クオリティの詳細設定

of.options.details=グラフィックスの詳細設定...
of.options.detailsTitle=グラフィックスの詳細設定

of.options.performance=パフォーマンスの詳細設定...
of.options.performanceTitle=パフォーマンスの詳細設定

of.options.animations=アニメーションの詳細設定...
of.options.animationsTitle=アニメーションの詳細設定

of.options.other=その他の設定...
of.options.otherTitle=その他の設定

of.options.other.reset=ビデオ設定を初期化する...

of.shaders.profile=プロファイル

# Quality

of.options.mipmap.bilinear=バイリニア補間
of.options.mipmap.linear=線形補間
of.options.mipmap.nearest=ニアレストネイバー補間
of.options.mipmap.trilinear=トライリニア補間

options.mipmapLevels.tooltip.1=遠くの物体における視覚効果を
options.mipmapLevels.tooltip.2=テクスチャのスムージングによって改善します。
options.mipmapLevels.tooltip.3=  オフ - スムージングを行わない
options.mipmapLevels.tooltip.4=  1 - 最小限のスムージング
options.mipmapLevels.tooltip.5=  4 - 最大限のスムージング
options.mipmapLevels.tooltip.6=この設定は大抵の場合パフォーマンスに影響を与えません。

of.options.MIPMAP_TYPE=ミップマップの種類
of.options.MIPMAP_TYPE.tooltip.1=遠くの物体における視覚効果を
of.options.MIPMAP_TYPE.tooltip.2=テクスチャのスムージングによって改善します。
of.options.MIPMAP_TYPE.tooltip.3=  ニアレストネイバー補間 - おおまかなスムージング (低負荷)
of.options.MIPMAP_TYPE.tooltip.4=  線形補間 - 通常のスムージング
of.options.MIPMAP_TYPE.tooltip.5=  バイリニア補間 - 繊細なスムージング
of.options.MIPMAP_TYPE.tooltip.6=  トライリニア補間 - 最高級のスムージング (高負荷)


of.options.AA_LEVEL=輪郭のギザギザ軽減
of.options.AA_LEVEL.tooltip.1=輪郭のギザギザ軽減の設定
of.options.AA_LEVEL.tooltip.2= オフ - (通常) 輪郭のギザギザ軽減を行わない (低負荷)
of.options.AA_LEVEL.tooltip.3= 2-16 - 輪郭のギザギザ軽減を行う (高負荷)
of.options.AA_LEVEL.tooltip.4=輪郭のギザギザやシャープな色の変化に 
of.options.AA_LEVEL.tooltip.5=アンチエイリアスを行います。
of.options.AA_LEVEL.tooltip.6=有効化すると実質的なFPSは下がります。
of.options.AA_LEVEL.tooltip.7=すべてのレベルがすべてのグラフィックカードでサポートされているわけではありません。
of.options.AA_LEVEL.tooltip.8=再起動後に有効化されます!

of.options.AF_LEVEL=異方性フィルタリング
of.options.AF_LEVEL.tooltip.1=異方性フィルタリングの設定
of.options.AF_LEVEL.tooltip.2= オフ - 通常のテクスチャ描画 (低負荷)
of.options.AF_LEVEL.tooltip.3= 2-16 - 滑らかなテクスチャ描画 (高負荷)
of.options.AF_LEVEL.tooltip.4=ミップマップされたテクスチャにおいて、
of.options.AF_LEVEL.tooltip.5=ちらつきを抑えます。
of.options.AF_LEVEL.tooltip.6=有効化すると実質的なFPSは下がります。

of.options.CLEAR_WATER=水の透明度を上げる
of.options.CLEAR_WATER.tooltip.1=水の透明度を上げる設定
of.options.CLEAR_WATER.tooltip.2=  オン - すっきりとした透明な水
of.options.CLEAR_WATER.tooltip.3=  オフ - 普通の水

of.options.RANDOM_MOBS=Random Mobsを有効化
of.options.RANDOM_MOBS.tooltip.1=Random Mobsを有効化する設定
of.options.RANDOM_MOBS.tooltip.2=  オフ - Mobにランダムなテクスチャを適応しない 低負荷
of.options.RANDOM_MOBS.tooltip.3=  オン - Mobにランダムなテクスチャを適応する 高負荷
of.options.RANDOM_MOBS.tooltip.4=Random mobsはランダムなテクスチャをMobに使用します。
of.options.RANDOM_MOBS.tooltip.5=複数のMobテクスチャを含むテクスチャパックが必要です。

of.options.BETTER_GRASS=草ブロックを繋げる
of.options.BETTER_GRASS.tooltip.1=草ブロックを繋げる設定
of.options.BETTER_GRASS.tooltip.2=  オフ - 通常の側面のテクスチャを使用する 低負荷
of.options.BETTER_GRASS.tooltip.3=  処理優先 - 側面も草で覆う 高負荷
of.options.BETTER_GRASS.tooltip.4=  描画優先 - 草ブロックと繋がるように側面を草で覆う 最高負荷

of.options.BETTER_SNOW=設置物の下に雪を表示
of.options.BETTER_SNOW.tooltip.1=設置物の下に雪を表示する設定
of.options.BETTER_SNOW.tooltip.2=  オフ - 通常の雪 低負荷
of.options.BETTER_SNOW.tooltip.3=  オン - 設置物の下でも描画される雪 高負荷
of.options.BETTER_SNOW.tooltip.4=隣接したブロックに雪が積もっているものがあった時に
of.options.BETTER_SNOW.tooltip.5=透過性のあるブロック(フェンス, 背の高い草)の下でも雪を描画します。

of.options.CUSTOM_FONTS=カスタムフォント
of.options.CUSTOM_FONTS.tooltip.1=カスタムフォントについての設定
of.options.CUSTOM_FONTS.tooltip.2=  オン - カスタムフォントを使う (通常) 高負荷
of.options.CUSTOM_FONTS.tooltip.3=  オフ - デフォルトのフォントを使う 低負荷
of.options.CUSTOM_FONTS.tooltip.4=カスタムフォントは現在使用中の
of.options.CUSTOM_FONTS.tooltip.5=テクスチャパックに依存します。

of.options.CUSTOM_COLORS=カスタムカラー
of.options.CUSTOM_COLORS.tooltip.1=カスタムフォントについての設定
of.options.CUSTOM_COLORS.tooltip.2=  オン - カスタムカラーを使う (通常) 高負荷
of.options.CUSTOM_COLORS.tooltip.3=  オフ - デフォルトの色を使う 低負荷
of.options.CUSTOM_COLORS.tooltip.4=カスタムカラーは現在使用中の
of.options.CUSTOM_COLORS.tooltip.5=テクスチャパックに依存します。

of.options.SWAMP_COLORS=湿地帯の色を変える
of.options.SWAMP_COLORS.tooltip.1=湿地帯の色を変える設定
of.options.SWAMP_COLORS.tooltip.2=  オン - 湿地帯色を使う 高負荷
of.options.SWAMP_COLORS.tooltip.3=  オフ - 湿地帯色を使わない 低負荷
of.options.SWAMP_COLORS.tooltip.4=湿地帯色は草, 葉, 蔦, 水に影響を与えます。

of.options.SMOOTH_BIOMES=バイオームを滑らかに表示
of.options.SMOOTH_BIOMES.tooltip.1=バイオームを滑らかに表示する設定
of.options.SMOOTH_BIOMES.tooltip.2=  オン - バイオームの境界を滑らかにする (通常) 高負荷
of.options.SMOOTH_BIOMES.tooltip.3=  オフ - バイオームの境界を滑らかにしない 低負荷
of.options.SMOOTH_BIOMES.tooltip.4=周囲の色の平均をとって
of.options.SMOOTH_BIOMES.tooltip.5=バイオーム間の境界を滑らかにします。
of.options.SMOOTH_BIOMES.tooltip.6=草, 葉, 蔦, 水に影響を与えます。

of.options.CONNECTED_TEXTURES=テクスチャの継ぎ目をなくす
of.options.CONNECTED_TEXTURES.tooltip.1=テクスチャの継ぎ目をなくす設定
of.options.CONNECTED_TEXTURES.tooltip.2=  オフ - テクスチャの継ぎ目をなくさない (通常)
of.options.CONNECTED_TEXTURES.tooltip.3=  処理優先 - 処理優先でテクスチャの継ぎ目をなくす
of.options.CONNECTED_TEXTURES.tooltip.4=  描画優先 - 描画優先でテクスチャの継ぎ目をなくす
of.options.CONNECTED_TEXTURES.tooltip.5=草、砂岩、本棚で隣り合ったものを
of.options.CONNECTED_TEXTURES.tooltip.6=つなぎあわせて表示します。
of.options.CONNECTED_TEXTURES.tooltip.7=つながった状態のテクスチャは現在使用中の
of.options.CONNECTED_TEXTURES.tooltip.8=テクスチャパックに依存します。

of.options.NATURAL_TEXTURES=自然なテクスチャ
of.options.NATURAL_TEXTURES.tooltip.1=自然なテクスチャの設定
of.options.NATURAL_TEXTURES.tooltip.2=  オフ - 自然なテクスチャを使用しない (通常)
of.options.NATURAL_TEXTURES.tooltip.3=  オン - 自然なテクスチャを使用する
of.options.NATURAL_TEXTURES.tooltip.4=ブロックのテクスチャが同じ形を繰り返し、
of.options.NATURAL_TEXTURES.tooltip.5=格子状の模様を形成される現象を除去します。
of.options.NATURAL_TEXTURES.tooltip.6=基となるブロックのテクスチャを回転したり裏返したり
of.options.NATURAL_TEXTURES.tooltip.7=するのに用いられます。自然なテクスチャの設定は
of.options.NATURAL_TEXTURES.tooltip.8=現在使用中のテクスチャパックに依存します。

of.options.CUSTOM_SKY=カスタムスカイ
of.options.CUSTOM_SKY.tooltip.1=カスタムスカイの設定
of.options.CUSTOM_SKY.tooltip.2=  オン - カスタムスカイを使用する (通常) 高負荷
of.options.CUSTOM_SKY.tooltip.3=  オフ - 通常の空 低負荷
of.options.CUSTOM_SKY.tooltip.4=カスタムスカイ用のテクスチャは現在使用中の
of.options.CUSTOM_SKY.tooltip.5=テクスチャパックに依存します。

of.options.CUSTOM_ITEMS=カスタムアイテム
of.options.CUSTOM_ITEMS.tooltip.1=カスタムアイテムの設定
of.options.CUSTOM_ITEMS.tooltip.2=  オン - カスタムアイテムを使用する (通常) 高負荷
of.options.CUSTOM_ITEMS.tooltip.3=  オフ - 通常のアイテムテクスチャを使用する 低負荷
of.options.CUSTOM_ITEMS.tooltip.4=カスタムアイテム用のテクスチャは現在使用中の
of.options.CUSTOM_ITEMS.tooltip.5=テクスチャパックに依存します。

# Details

of.options.CLOUDS=雲の設定
of.options.CLOUDS.tooltip.1=雲の設定
of.options.CLOUDS.tooltip.2=  デフォルト - グラフィックスの設定に合わせる
of.options.CLOUDS.tooltip.3=  処理優先 - 低品質 低負荷
of.options.CLOUDS.tooltip.4=  描画優先 - 高品質 高負荷
of.options.CLOUDS.tooltip.5=  オフ - 雲なし 最低負荷
of.options.CLOUDS.tooltip.6=処理優先の雲は平面的に描画されます。
of.options.CLOUDS.tooltip.7=描画優先の雲は立体的に描画されます。

of.options.CLOUD_HEIGHT=雲の高さ
of.options.CLOUD_HEIGHT.tooltip.1=雲の高さの設定
of.options.CLOUD_HEIGHT.tooltip.2=  オフ - 通常の高さ
of.options.CLOUD_HEIGHT.tooltip.3=  100%% - ワールドの高さ上限

of.options.TREES=木の設定
of.options.TREES.tooltip.1=木の設定
of.options.TREES.tooltip.2=  デフォルト - グラフィックスの設定に合わせる
of.options.TREES.tooltip.3=  処理優先 - 低品質 より低負荷
of.options.TREES.tooltip.4=  賢い処理 - 高品質 低負荷
of.options.TREES.tooltip.5=  描画優先 - 高品質 高負荷
of.options.TREES.tooltip.6=処理優先の木は透過しない葉を持ちます。
of.options.TREES.tooltip.7=描画優先や賢く描画された木は透過する葉を持ちます。

of.options.RAIN=雨と雪の設定
of.options.RAIN.tooltip.1=雨と雪の設定
of.options.RAIN.tooltip.2=  デフォルト - グラフィックスの設定に合わせる
of.options.RAIN.tooltip.3=  処理優先  - 小雨/小雪 低負荷
of.options.RAIN.tooltip.4=  描画優先 - 大雨/大雪 高負荷
of.options.RAIN.tooltip.5=  オフ - 雨や雪を描画しない 最低負荷
of.options.RAIN.tooltip.6=オフにしても地面での雨の飛び散りや雨音
of.options.RAIN.tooltip.7=は有効のままです。

of.options.SKY=空の表示
of.options.SKY.tooltip.1=空の表示の設定
of.options.SKY.tooltip.2=  オン - 空を描画する 高負荷
of.options.SKY.tooltip.3=  オフ  - 空を描画しない 低負荷
of.options.SKY.tooltip.4=OFFにしても太陽や月はそのままです。

of.options.STARS=星の表示
of.options.STARS.tooltip.1=星の表示の設定
of.options.STARS.tooltip.2=  オン - 星を描画する (通常)
of.options.STARS.tooltip.3=  オフ  - 星を描画しない (低負荷)

of.options.SUN_MOON=太陽と月の表示
of.options.SUN_MOON.tooltip.1=太陽と月の表示の設定
of.options.SUN_MOON.tooltip.2=  オン - 太陽と月を描画する (通常)
of.options.SUN_MOON.tooltip.3=  オフ  - 太陽と月を描画しない (低負荷)

of.options.SHOW_CAPES=Optifineマントの表示
of.options.SHOW_CAPES.tooltip.1=Optifineマントの表示の設定
of.options.SHOW_CAPES.tooltip.2=  オン - Optifineマントを表示する (通常)
of.options.SHOW_CAPES.tooltip.3=  オフ - Optifineマントを表示しない

of.options.TRANSLUCENT_BLOCKS=半透明のブロックの設定
of.options.TRANSLUCENT_BLOCKS.tooltip.1=半透明のブロックの設定
of.options.TRANSLUCENT_BLOCKS.tooltip.2=  描画優先 - 完全なカラーブレンド (通常)
of.options.TRANSLUCENT_BLOCKS.tooltip.3=  処理優先 - 速さ重視のカラーブレンド (低負荷)
of.options.TRANSLUCENT_BLOCKS.tooltip.4=違う色を持った半透明ブロック(色付きガラス, 水, 氷)
of.options.TRANSLUCENT_BLOCKS.tooltip.5=が空気を挟んで隣接した際の
of.options.TRANSLUCENT_BLOCKS.tooltip.6=カラーブレンドの設定です。

of.options.HELD_ITEM_TOOLTIPS=持ち替え時アイテム名表示
of.options.HELD_ITEM_TOOLTIPS.tooltip.1=持ち替え時アイテム名表示の設定
of.options.HELD_ITEM_TOOLTIPS.tooltip.2=  オン - 持ち替え時にアイテム名を表示する (通常)
of.options.HELD_ITEM_TOOLTIPS.tooltip.3=  オフ - 持ち替え時にアイテム名を表示しない

of.options.DROPPED_ITEMS=落ちているアイテムの表示
of.options.DROPPED_ITEMS.tooltip.1=落ちているアイテムの表示の設定
of.options.DROPPED_ITEMS.tooltip.2=  デフォルト - グラフィックスの設定に合わせる
of.options.DROPPED_ITEMS.tooltip.3=  処理優先 - 落ちているアイテムを2Dで表示する 低負荷
of.options.DROPPED_ITEMS.tooltip.4=  描画優先 - 落ちているアイテムを3Dで表示する 高負荷

options.entityShadows.tooltip.1=Entityの影の表示の設定
options.entityShadows.tooltip.2=  オン - Entityの影を表示する
options.entityShadows.tooltip.3=  オフ - Entityの影を表示しない

of.options.VIGNETTE=視界端の影の表示の設定
of.options.VIGNETTE.tooltip.1=スクリーンの角にある少し暗くなっている視覚効果
of.options.VIGNETTE.tooltip.2=  デフォルト - グラフィックスの設定に合わせる (通常)
of.options.VIGNETTE.tooltip.3=  処理優先 - 視界端の影を表示しない (低負荷)
of.options.VIGNETTE.tooltip.4=  描画優先 - 視界端の影を表示する (高負荷)
of.options.VIGNETTE.tooltip.5=視界端の影はFPSにとって重要な視覚効果です。
of.options.VIGNETTE.tooltip.6=特にフルスクリーンで遊ぶ際には、
of.options.VIGNETTE.tooltip.7=視界端の影は非常に微かであるため、
of.options.VIGNETTE.tooltip.8=無効にしてもかまいません。

# Performance

of.options.SMOOTH_FPS=FPS安定化処理
of.options.SMOOTH_FPS.tooltip.1=バッファを使ってFPSを安定化する。
of.options.SMOOTH_FPS.tooltip.2=  オフ - 安定化しない。FPSは変動的になるでしょう。
of.options.SMOOTH_FPS.tooltip.3=  オン - 安定化する。
of.options.SMOOTH_FPS.tooltip.4=この設定はグラフィックドライバーに依存し、
of.options.SMOOTH_FPS.tooltip.5=常には有効ではありません。

of.options.SMOOTH_WORLD=サーバー負荷を分散
of.options.SMOOTH_WORLD.tooltip.1=内部サーバーによるラグの除去。
of.options.SMOOTH_WORLD.tooltip.2=  オフ - 安定化しない。FPSは変動的になるでしょう。
of.options.SMOOTH_WORLD.tooltip.3=  オン - 安定化する。
of.options.SMOOTH_WORLD.tooltip.4=内部サーバーロード時安定化。
of.options.SMOOTH_WORLD.tooltip.5=シングルプレイの時のみ効果があります。

of.options.FAST_RENDER=速い描画処理
of.options.FAST_RENDER.tooltip.1=速い描画処理設定
of.options.FAST_RENDER.tooltip.2= オフ - 通常の描画 (通常)
of.options.FAST_RENDER.tooltip.3= オン - 最適化された描画 (低負荷)
of.options.FAST_RENDER.tooltip.4=GPUのロード回数を減らしたアルゴリズムによって
of.options.FAST_RENDER.tooltip.5=実質的なFPSを向上します。

of.options.FAST_MATH=速い計算処理
of.options.FAST_MATH.tooltip.1=速い計算処理設定
of.options.FAST_MATH.tooltip.2= オフ - 通常の処理 (通常)
of.options.FAST_MATH.tooltip.3= オン - 速い処理
of.options.FAST_MATH.tooltip.4=CPUのキャッシュをうまく使った
of.options.FAST_MATH.tooltip.5=FPSを向上させる計算処理を使用します。

of.options.CHUNK_UPDATES=チャンク読込方法
of.options.CHUNK_UPDATES.tooltip.1=チャンク読込方法の設定
of.options.CHUNK_UPDATES.tooltip.2= 1 - 高負荷なチャンク読み込み 高いFPS (通常)
of.options.CHUNK_UPDATES.tooltip.3= 3 - 低負荷めなチャンク読み込み 低めのFPS
of.options.CHUNK_UPDATES.tooltip.4= 5 - 低負荷なチャンク読み込み 低いFPS
of.options.CHUNK_UPDATES.tooltip.5=1フレームごとに行われるチャンク読み込み回数を指定します。
of.options.CHUNK_UPDATES.tooltip.6=高い値はフレームレートの非安定化を招きます。

of.options.CHUNK_UPDATES_DYNAMIC=静止中は読み込み優先
of.options.CHUNK_UPDATES_DYNAMIC.tooltip.1=静止中は読み込み優先設定
of.options.CHUNK_UPDATES_DYNAMIC.tooltip.2= オフ - (通常) 1フレームに通常の回数のチャンク読み込み処理
of.options.CHUNK_UPDATES_DYNAMIC.tooltip.3= オン - 静止中により多くのアップデート処理を行う。
of.options.CHUNK_UPDATES_DYNAMIC.tooltip.4=プレイヤーが静止している時に
of.options.CHUNK_UPDATES_DYNAMIC.tooltip.5=素早くチャンク読み込むようになります。

of.options.LAZY_CHUNK_LOADING=チャンク読み込みを遅延
of.options.LAZY_CHUNK_LOADING.tooltip.1=チャンク読み込みを遅延する設定
of.options.LAZY_CHUNK_LOADING.tooltip.2= オフ - 通常のサーバーチャンク読み込み
of.options.LAZY_CHUNK_LOADING.tooltip.3= オン - 遅延サーバーチャンク読み込み (滑らか)
of.options.LAZY_CHUNK_LOADING.tooltip.4=チャンク読み込み処理を数Tickに分散させることで
of.options.LAZY_CHUNK_LOADING.tooltip.5=総合的にサーバーのチャンク読み込み処理を滑らかにします。
of.options.LAZY_CHUNK_LOADING.tooltip.6=ワールドの一部に欠けが発生するようならOFFにしてください。
of.options.LAZY_CHUNK_LOADING.tooltip.7=シングルプレイヤーでシングルコアCPUの時のみ有効です。

# Animations

of.options.animation.allOn=全てオン
of.options.animation.allOff=全てオフ
of.options.animation.dynamic=動的に

of.options.ANIMATED_WATER=水
of.options.ANIMATED_LAVA=溶岩
of.options.ANIMATED_FIRE=炎
of.options.ANIMATED_PORTAL=ネザーゲート
of.options.ANIMATED_REDSTONE=レッドストーン
of.options.ANIMATED_EXPLOSION=爆発
of.options.ANIMATED_FLAME=松明やかまど
of.options.ANIMATED_SMOKE=煙
of.options.VOID_PARTICLES=岩盤付近の粒子
of.options.WATER_PARTICLES=水中の粒子
of.options.RAIN_SPLASH=雨の水しぶき
of.options.PORTAL_PARTICLES=ネザーゲートの粒子
of.options.POTION_PARTICLES=ポーションの粒子
of.options.DRIPPING_WATER_LAVA=水／溶岩の滴り
of.options.ANIMATED_TERRAIN=Terrainアニメを有効にする
of.options.ANIMATED_TEXTURES=Texturesアニメを有効にする
of.options.FIREWORK_PARTICLES=花火の粒子

# Other

of.options.LAGOMETER=デバッグの棒グラフを表示
of.options.LAGOMETER.tooltip.1=F3デバッグに棒グラフを表示。
of.options.LAGOMETER.tooltip.2=* 橙 - ガベージコレクション
of.options.LAGOMETER.tooltip.3=* 藍 - Tick処理
of.options.LAGOMETER.tooltip.4=* 青 - スケジューリングされた処理
of.options.LAGOMETER.tooltip.5=* 紫 - チャンクアップローディング
of.options.LAGOMETER.tooltip.6=* 赤 - チャンクアップデート
of.options.LAGOMETER.tooltip.7=* 黄 - 描画確認
of.options.LAGOMETER.tooltip.8=* 緑 - 地形描画

of.options.PROFILER=デバッグの円グラフを表示
of.options.PROFILER.tooltip.1=デバッグの円グラフの表示の設定
of.options.PROFILER.tooltip.2=  オン - 円グラフは有効 高負荷
of.options.PROFILER.tooltip.3=  オフ - 円グラフは無効 低負荷
of.options.PROFILER.tooltip.4=デバッグ画面(F3)が開かれている時に
of.options.PROFILER.tooltip.5=デバッグ情報を収集し円グラフ上に表示します。

of.options.WEATHER=天候の有無
of.options.WEATHER.tooltip.1=天候の有無の設定
of.options.WEATHER.tooltip.2=  オン - 天候あり 高負荷
of.options.WEATHER.tooltip.3=  オフ - 天候なし 低負荷
of.options.WEATHER.tooltip.4=天候コントロール機能の有効/無効。
of.options.WEATHER.tooltip.5=シングルプレイでのみ有効。

of.options.time.dayOnly=昼のみ
of.options.time.nightOnly=夜のみ

of.options.TIME=クリエイティブの時刻
of.options.TIME.tooltip.1=クリエイティブの時刻の設定
of.options.TIME.tooltip.2= デフォルト - 通常の昼夜サイクル
of.options.TIME.tooltip.3= 昼のみ - 昼のみ
of.options.TIME.tooltip.4= 夜のみ - 夜のみ
of.options.TIME.tooltip.5=クリエイティブモードで
of.options.TIME.tooltip.6=シングルプレイの時のみ有効。

options.fullscreen.tooltip.1=フルスクリーン
options.fullscreen.tooltip.2=  オン - フルスクリーンモード
options.fullscreen.tooltip.3=  オフ - ウィンドウモード
options.fullscreen.tooltip.4=フルスクリーンではグラフィックカードによって
options.fullscreen.tooltip.5=処理の速い遅いが変わります。

of.options.FULLSCREEN_MODE=フルスクリーンの種類
of.options.FULLSCREEN_MODE.tooltip.1=フルスクリーンの種類の設定
of.options.FULLSCREEN_MODE.tooltip.2=  デフォルト - デスクトップスクリーンの解像度 高負荷
of.options.FULLSCREEN_MODE.tooltip.3=  WxH - カスタム解像度 おそらく低負荷
of.options.FULLSCREEN_MODE.tooltip.4=フルスクリーンモードにて使用される解像度です。
of.options.FULLSCREEN_MODE.tooltip.5=一般的に、低い解像度は速い処理に繋がります。

of.options.SHOW_FPS=FPSを表示
of.options.SHOW_FPS.tooltip.1=コンパクトなFPSと描画情報を表示
of.options.SHOW_FPS.tooltip.2=  C: - チャンク描画
of.options.SHOW_FPS.tooltip.3=  E: - エンティティ描画
of.options.SHOW_FPS.tooltip.4=  U: - チャンクアップデート
of.options.SHOW_FPS.tooltip.5=コンパクトなFPS情報は
of.options.SHOW_FPS.tooltip.6=デバッグ画面が非表示の時のみ表示されます。 

of.options.save.default=デフォルト (2秒)
of.options.save.20s=20秒
of.options.save.3min=3分
of.options.save.30min=30分

of.options.AUTOSAVE_TICKS=オートセーブ
of.options.AUTOSAVE_TICKS.tooltip.1=セーブ間隔
of.options.AUTOSAVE_TICKS.tooltip.2=2秒ごとのセーブは推奨されません。
of.options.AUTOSAVE_TICKS.tooltip.3=オートセーブはラグの原因となります。

options.anaglyph.tooltip.1=3Dモードは赤青メガネとともに使います。

minecraft_Start.java

import net.minecraft.client.main.Main;

import java.util.Arrays;

public class Start
{
    public static void main(String[] args)
    {
        Main.main(concat(new String[] {"--version", "mcp", "--accessToken", "0", "--assetsDir", "assets", "--assetIndex", "1.8", "--userProperties", "{}"}, args));
    }

    public static <T> T[] concat(T[] first, T[] second)
    {
        T[] result = Arrays.copyOf(first, first.length + second.length);
        System.arraycopy(second, 0, result, first.length, second.length);
        return result;
    }
}

minecraft_minecraft_optifine_lang_lb_LU.lang

# Contributors of Luxembourgish localization #
#   Hyperspacemaster ---- 2016-4-6

# General
of.general.ambiguous=onkloer
of.general.custom=Aneres
of.general.from=Vun
of.general.id=ID
of.general.restart=Neistart
of.general.smart=Fein

# Message
of.message.aa.shaders1=Antialiasing ass net kompatibel mat de Shader.
of.message.aa.shaders2=W.e.g. schalt de Shader aus fir des Optioun ze aktivéieren.

of.message.af.shaders1=Anisotropescht Filteren ass net kompatibel mat de Shader.
of.message.af.shaders2=W.e.g. schalt de Shader aus fir des Optioun ze aktivéieren.

of.message.fr.shaders1=Schnellt Renderen ass net kompatibel mat de de Shader.
of.message.fr.shaders2=W.e.g. schalt de Shader aus fir des Optioun ze aktivéieren.

of.message.shaders.aa1=Antialiasing ass net kompatibel mat de Shader .
of.message.shaders.aa2=W.e.g setz Qualitéit -> Antialiasing ob AUS a start däi spill nei.

of.message.shaders.af1=Anisotropescht Filteren ass net kompatibel mat de Shader.
of.message.shaders.af2=W.e.g setz Qualitéit -> Anisotropescht Filteren ob AUS.

of.message.shaders.fr1=Schiet-Effekt si kompatibel mat schnellem Renderen.
of.message.shaders.fr2=W.e.g setz de Performance -> Schnellt Renderen ob AUS.

of.message.newVersion=Eng nei Versioun vun §eOptiFine§f ass verfügbar: §e%s§f
of.message.java64Bit=Du kanns §e64-bit Java§f installéiere fir eng Performance.
of.message.openglError=§eOpenGL Fehler§f: %s (%s)

of.message.shaders.loading=D'Shader gi gelueden: %s

of.message.other.reset=All Videoastellungen zerécksetzen ob hier Standardwäerter?

# Video settings

options.graphics.tooltip.1=Grafikmodus
options.graphics.tooltip.2= Schnell - méi schlecht Qualitéit, méi schnell
options.graphics.tooltip.3= Schéin - héich Qualitéit, méi lues
options.graphics.tooltip.4=Verännert d'Ausgesi vun de Wolleken, Blieder, Grasbléck,
options.graphics.tooltip.5=Schieter a vum Waasser.

of.options.renderDistance.extreme=Extrem

options.renderDistance.tooltip.1=Siichtwéit
options.renderDistance.tooltip.2= 2 Mini - 32m (am schnellsten)
options.renderDistance.tooltip.3= 4 Geréng - 64m (schnell)
options.renderDistance.tooltip.4= 8 Normal - 128m
options.renderDistance.tooltip.5= 16 Wéit - 256m (lues)
options.renderDistance.tooltip.6= 32 Extrem - 512m (am luesten!)
options.renderDistance.tooltip.7=D'extrem Sichtwéit erfuerdert vill Ressource.
options.renderDistance.tooltip.8=D'Wäerter iwwer 16 funktionéieren nëmmen am Singleplayer

options.ao.tooltip.1=Fléissend Beliichtung
options.ao.tooltip.2= Aus - keng fléissend Beliichtung (schnell)
options.ao.tooltip.3= Minimum - einfach fléissend Beliichtung (lues)
options.ao.tooltip.4= Maximum - komplexe fléissend Beliichtung (am luesten)

options.framerateLimit.tooltip.1=Max. FPS
options.framerateLimit.tooltip.2= VSync - limitéiert ob d'Bildfrequenz vum Monitor (60, 30, 20)
options.framerateLimit.tooltip.3= 5-255 - variabel
options.framerateLimit.tooltip.4= Illimitéiert - keng Begrenzung (am schnellsten)
options.framerateLimit.tooltip.5=D'Bildfrequenz grenzt FPS an, souguer
options.framerateLimit.tooltip.6=wann d'Begrenzung net erreecht ass.
of.options.framerateLimit.vsync=V-Sync

of.options.AO_LEVEL=Schiet-Hellegkeet
of.options.AO_LEVEL.tooltip.1=Hellegkeet vun de Schieter
of.options.AO_LEVEL.tooltip.2= Aus - keng Schieter
of.options.AO_LEVEL.tooltip.3= 50%% - hell Schieter
of.options.AO_LEVEL.tooltip.4= 100%% - donkel Schieter

options.viewBobbing.tooltip.1=Realistesch Bewegungen
options.viewBobbing.tooltip.2=Wann Mipmaps genotzt ginn deaktivéiert d'Astellung
options.viewBobbing.tooltip.3=fir eng besser Leeschtung

options.guiScale.tooltip.1=GUI-Gréisst
options.guiScale.tooltip.2=Ee méi klengt GUI ka méi schnell sinn.

options.vbo.tooltip.1=Vertexbufferobjeten
options.vbo.tooltip.2=Benotz een alternative Rendermodel, deen normalerweis
options.vbo.tooltip.3=méi schnell (5-10%%) wei d'Standard-Renderen ass.

options.gamma.tooltip.1=Erhéicht Hellegkeet vun donkelen Objeten
options.gamma.tooltip.2= Aus - Standardhellegkeet
options.gamma.tooltip.3= 100%% - maximal Hellegkeet fir donkel Objeten
options.gamma.tooltip.4=Dës Optioun ännert Hellegkeet vun ganz donkelen
options.gamma.tooltip.5=Objeten net.

options.anaglyph.tooltip.1=3D-Modus
options.anaglyph.tooltip.2=Kann nëmme mat engem Roud-Turquoise-Brëll benotzt ginn.
options.anaglyph.tooltip.3=Aktivéiert ee stereoskopeschen 3D-Effekt duerch
options.anaglyph.tooltip.4=benotze vun ënnerschiddleche Faarwe fir d'Aen.

options.blockAlternatives.tooltip.1=Block Variatiounen
options.blockAlternatives.tooltip.2=Benotz Variatioune fir puer Bléck
options.blockAlternatives.tooltip.3=Hänkt vum ausgewielte Ressourcenpack of.

of.options.FOG_FANCY=Niwwel
of.options.FOG_FANCY.tooltip.1=Niwwel
of.options.FOG_FANCY.tooltip.2= Schnell - schnellen Niwwel
of.options.FOG_FANCY.tooltip.3= Schéin - luesen Niwwel, gesäit besser aus
of.options.FOG_FANCY.tooltip.4= Aus - keen Niwwel, am schnellsten
of.options.FOG_FANCY.tooltip.5=De schéinen Niwwel ass nëmme verfügbar, wann en vun
of.options.FOG_FANCY.tooltip.6=der Grafikkaart ënnerstëtzt gëtt.

of.options.FOG_START=Niwwel Startpunkt
of.options.FOG_START.tooltip.1=Niwwel Startpunkt
of.options.FOG_START.tooltip.2= 0.2 - Niwwel start no beim Spiller
of.options.FOG_START.tooltip.3= 0.8 - Niwwel start weit vum Spiller ewech
of.options.FOG_START.tooltip.4=Dës Optioun beaflosst normalerweis net d'Leeschtung

of.options.CHUNK_LOADING=Chunklueden
of.options.CHUNK_LOADING.tooltip.1=Chunklueden
of.options.CHUNK_LOADING.tooltip.2= Standard - onstabil FPS beim luede vun de Chunks
of.options.CHUNK_LOADING.tooltip.3= Fléissend - stabil FPS
of.options.CHUNK_LOADING.tooltip.4= Multi-Core - stabil FPS, 3x méi schnellt luede vun der Welt
of.options.CHUNK_LOADING.tooltip.5=Fléissend a Multi-Core mécht Ruckler a Standbiller
of.options.CHUNK_LOADING.tooltip.6=fort déi durch d'Luede vun de Chunks verursaacht ginn.
of.options.CHUNK_LOADING.tooltip.7=Multi-Core kann d'Luede vun der Welt bis zu 3x méi schnell
of.options.CHUNK_LOADING.tooltip.8=maachen a FPS erhéijen duerch een zweete CPU-Kär.
of.options.chunkLoading.smooth=Fléissend
of.options.chunkLoading.multiCore=Multi-Core

of.options.shaders=Schieter ...
of.options.shadersTitle=Schieter

of.options.shaders.packNone=Aus
of.options.shaders.packDefault=(intern)

of.options.shaders.ANTIALIASING=Antialiasing
of.options.shaders.NORMAL_MAP=Normal Kaart
of.options.shaders.SPECULAR_MAP=Spiegelnd Kaart
of.options.shaders.RENDER_RES_MUL=Render Qualitéit
of.options.shaders.SHADOW_RES_MUL=Schiet Qualitéit
of.options.shaders.HAND_DEPTH_MUL=Handdéift
of.options.shaders.CLOUD_SHADOW=Wolleke schiet
of.options.shaders.OLD_HAND_LIGHT=Aal Hand Luucht
of.options.shaders.OLD_LIGHTING=Aal Geliichts
of.options.shaders.SHADER_PACK=Shaderpack

of.options.shaders.shadersFolder=Shader-Fichier
of.options.shaders.shaderOptions=Shaderastellungen ...

of.options.shaderOptionsTitle=Shaderastellungen

of.options.quality=Qualitéit ...
of.options.qualityTitle=Qualitéitsastellungen

of.options.details=Detailer ...
of.options.detailsTitle=Detailastellungen

of.options.performance=Performance ...
of.options.performanceTitle=Performanceastellungen

of.options.animations=Animatiounen ...
of.options.animationsTitle=Animatiounsastellungen

of.options.other=Verschiddenes ...
of.options.otherTitle=Veschidden Astellungen

of.options.other.reset=Videoastellungen zerécksetzen ...

of.shaders.profile=Profil

# Quality

of.options.mipmap.bilinear=Bilinear
of.options.mipmap.linear=Linear
of.options.mipmap.nearest=Am noosten
of.options.mipmap.trilinear=Trilinear

options.mipmapLevels.tooltip.1=Visuellen Effekt dee weit entfernten Objete besser
options.mipmapLevels.tooltip.2=ausgesi léisst duerch verréngere vun den Texturdetailer.
options.mipmapLevels.tooltip.3= Aus - keng Verréngerung vun Detailer
options.mipmapLevels.tooltip.4= 1 - minimal Verréngerung vun Detailler
options.mipmapLevels.tooltip.5= 4 - maximal Verréngerung vun Detailler
options.mipmapLevels.tooltip.6=Dës Optioun beaflosst normalerweis d'Performance net.

of.options.MIPMAP_TYPE=Mipmap-Typ
of.options.MIPMAP_TYPE.tooltip.1=Visuellen Effekt dee weit entfernten Objete besser
of.options.MIPMAP_TYPE.tooltip.2=ausgesi léisst duerch verréngern vun den Texturdetailer.
of.options.MIPMAP_TYPE.tooltip.3= Am noosten - graff Verréngerung (am schnellsten)
of.options.MIPMAP_TYPE.tooltip.4= Linear - normal Verréngerung (schnell)
of.options.MIPMAP_TYPE.tooltip.5= Bilinear - fein Verréngerung (lues)
of.options.MIPMAP_TYPE.tooltip.6= Trilinear - feinst Verréngerung (am luesten)

of.options.AA_LEVEL=Antialiasing
of.options.AA_LEVEL.tooltip.1=Antialiasing
of.options.AA_LEVEL.tooltip.2= Aus - (Standard) Keen Antialiasing (méi schnell)
of.options.AA_LEVEL.tooltip.3= 2-16 - antialiséiert Kanten an Ecker (méi lues)
of.options.AA_LEVEL.tooltip.4=Den Antialiasing mécht Kanten a Faarfiwergäng
of.options.AA_LEVEL.tooltip.5=méi fléissend.
of.options.AA_LEVEL.tooltip.6=Wann aktivéiert kënnen deng FPS staark erof goen.
of.options.AA_LEVEL.tooltip.7=Net all Stufe gi vun all Grafikaart ënnerstëtzt
of.options.AA_LEVEL.tooltip.8=Ännerunge sinn ereicht no engem Neistart effektiv!

of.options.AF_LEVEL=Anisotropescht Filteren
of.options.AF_LEVEL.tooltip.1=Anisotropescht Filteren
of.options.AF_LEVEL.tooltip.2= Aus - (Standard) Standard-Texturdetailer (méi schnell)
of.options.AF_LEVEL.tooltip.3= 2-16 - méi fein Texturdetailer (méi lues)
of.options.AF_LEVEL.tooltip.4=D'anisoptropescht Filtere stellt Texturdetailer
of.options.AF_LEVEL.tooltip.5=déi duerch Mipmap verluer gaange sinn erëm hier.
of.options.AF_LEVEL.tooltip.6=Wann aktivéiert kenne FPS staark erof goen.

of.options.CLEAR_WATER=Kloert Waasser
of.options.CLEAR_WATER.tooltip.1=Kloert Waasser
of.options.CLEAR_WATER.tooltip.2= Un - kloer, transparent Waasser
of.options.CLEAR_WATER.tooltip.3= Aus - normaalt Waasser

of.options.RANDOM_MOBS=Zoufälleg Mobs
of.options.RANDOM_MOBS.tooltip.1=Zoufälleg Mobs
of.options.RANDOM_MOBS.tooltip.2= Aus - keng zoufälleg Mobs, méi schnell
of.options.RANDOM_MOBS.tooltip.3= Un - zoufälleg Mobs, méi lues
of.options.RANDOM_MOBS.tooltip.4=Zoufälleg Mobs benotzt zoufälleg Texture fir Kreaturen
of.options.RANDOM_MOBS.tooltip.5=am Spill.
of.options.RANDOM_MOBS.tooltip.6=Et braucht een ee Ressourcepak mat e puer Mobtexturen.

of.options.BETTER_GRASS=Bessert Grass
of.options.BETTER_GRASS.tooltip.1=Bessert Grass
of.options.BETTER_GRASS.tooltip.2= Aus - Standard-Säitentextur vum Gras, am schnellsten
of.options.BETTER_GRASS.tooltip.3= Schnell - komplett Säitentextur vum Gras, lues
of.options.BETTER_GRASS.tooltip.4= Schéin - dynamesch Säitentextur vum Gras, am luesten

of.options.BETTER_SNOW=Bessere Schnéi
of.options.BETTER_SNOW.tooltip.1=Bessere Schnéi
of.options.BETTER_SNOW.tooltip.2= Aus - normale Schnéi, méi schnell
of.options.BETTER_SNOW.tooltip.3= Un - bessere Schnéi, méi lues
of.options.BETTER_SNOW.tooltip.4=Wéist Schnéi ënnert transparente Bléck (Zonk,
of.options.BETTER_SNOW.tooltip.5=héijem Grass) un wann se un Schnéibléck ugrenzen.

of.options.CUSTOM_FONTS=Schrëftressource
of.options.CUSTOM_FONTS.tooltip.1=Schrëftressource
of.options.CUSTOM_FONTS.tooltip.2= Un - Schrëft aus dem Ressourcepak (Standard), méi lues
of.options.CUSTOM_FONTS.tooltip.3= Aus - Standardschrëft, méi schnell
of.options.CUSTOM_FONTS.tooltip.4=D'Schrëft gëtt vum ausgewielte Ressourcepak gelueden
of.options.CUSTOM_FONTS.tooltip.5=

of.options.CUSTOM_COLORS=Faarfressource
of.options.CUSTOM_COLORS.tooltip.1=Faarfressource
of.options.CUSTOM_COLORS.tooltip.2= Un - Faarwen aus dem Ressourcepak (Standard), méi lues
of.options.CUSTOM_COLORS.tooltip.3= Aus - Standardfaarwen, méi schnell
of.options.CUSTOM_COLORS.tooltip.4=Farwe gi vum ausgewielte Ressourcepak gelueden
of.options.CUSTOM_COLORS.tooltip.5=

of.options.SWAMP_COLORS=Sumpffaarwen
of.options.SWAMP_COLORS.tooltip.1=Sumpffaarwen
of.options.SWAMP_COLORS.tooltip.2= Un - Sumpffarwe benotzen (Standard), méi lues
of.options.SWAMP_COLORS.tooltip.3= Aus - Sumpffaarwen nëtt benotzen, méi schnell
of.options.SWAMP_COLORS.tooltip.4=Sumpfaarwe concernéiere Grass, Blieder, Lianen
of.options.SWAMP_COLORS.tooltip.5=a Waasser.

of.options.SMOOTH_BIOMES=Biomeiwwergäng
of.options.SMOOTH_BIOMES.tooltip.1= Biomeiwwergäng
of.options.SMOOTH_BIOMES.tooltip.2= Un - fléissenden Iwwergang (Standard), méi lues
of.options.SMOOTH_BIOMES.tooltip.3= Aus - kee fléissenden Iwwergang, méi schnell
of.options.SMOOTH_BIOMES.tooltip.4=De fléissenden Iwwergang gëtt duerch Prouwen an
of.options.SMOOTH_BIOMES.tooltip.5=Duerchschnëttsfaarfwäerter vun den ugrenzende
of.options.SMOOTH_BIOMES.tooltip.6=Bléck realiséiert
of.options.SMOOTH_BIOMES.tooltip.7=Concernéiert si Grass, Blieder, Lianen a Waasser

of.options.CONNECTED_TEXTURES=Verbonnen Texturen
of.options.CONNECTED_TEXTURES.tooltip.1=Verbonnen Texturen
of.options.CONNECTED_TEXTURES.tooltip.2= Aus - keng verbonnen Texturen (Standard)
of.options.CONNECTED_TEXTURES.tooltip.3= Schnell - schnell verbonnen Texturen
of.options.CONNECTED_TEXTURES.tooltip.4= Schéin - schéi verbonnen Texturen
of.options.CONNECTED_TEXTURES.tooltip.5=Verbonnen Texture verbënnt d'Texture vu Glas,
of.options.CONNECTED_TEXTURES.tooltip.6=Sandsteen a Bicherregaler wann se niewenteneen
of.options.CONNECTED_TEXTURES.tooltip.7=plazéiert ginn. D'verbonnen Texture gi vum
of.options.CONNECTED_TEXTURES.tooltip.8=Ressourcepak gelueden.

of.options.NATURAL_TEXTURES=Natierlech Texturen
of.options.NATURAL_TEXTURES.tooltip.1=Natierlech Texturen
of.options.NATURAL_TEXTURES.tooltip.2= Aus - keng natierlech Texturen (Standard)
of.options.NATURAL_TEXTURES.tooltip.3= Un - benotz natierlech Texturen
of.options.NATURAL_TEXTURES.tooltip.4=Natierlech Texture maachen d'Raster-Unuerdnung
of.options.NATURAL_TEXTURES.tooltip.5=déi duerch widderhuele vum selwechte Block entsti fort.
of.options.NATURAL_TEXTURES.tooltip.6=Et gi rotéiert a gespigelt Variante vun der
of.options.NATURAL_TEXTURES.tooltip.7=Basisblocktextur genotzt. Konfiguratioun fir natierlech
of.options.NATURAL_TEXTURES.tooltip.8=Texture gi vum Ressourcepak gelueden.

of.options.CUSTOM_SKY=Himmeltexturen
of.options.CUSTOM_SKY.tooltip.1=Himmeltexturen
of.options.CUSTOM_SKY.tooltip.2= Un - Himmeltexturen aus dem Ressourcepak (Standard),
of.options.CUSTOM_SKY.tooltip.3=        lues
of.options.CUSTOM_SKY.tooltip.4= Aus - Standardhimmel, méi schnell
of.options.CUSTOM_SKY.tooltip.5=D'Himmeltexture gi vum Ressourcepak gelueden

of.options.CUSTOM_ITEMS=Géigestänntexturen
of.options.CUSTOM_ITEMS.tooltip.1=Géigestänntexturen
of.options.CUSTOM_ITEMS.tooltip.2= Un - Géigestänntexturen aus dem Ressourcepak
of.options.CUSTOM_ITEMS.tooltip.3=       (Standard), lues
of.options.CUSTOM_ITEMS.tooltip.4= Aus - Standard-Géigestänntexturen, méi schnell
of.options.CUSTOM_ITEMS.tooltip.5=Géigestänntexture gi vum Ressourcepak gelueden

# Details

of.options.CLOUDS=Wolleken
of.options.CLOUDS.tooltip.1=Wolleken
of.options.CLOUDS.tooltip.2= Standard - wéi vum Grafikmodus definéiert
of.options.CLOUDS.tooltip.3= Schnell - méi geréng Qualitéit, méi schnell
of.options.CLOUDS.tooltip.4= Schéin - héich Qualitéit, méi lues
of.options.CLOUDS.tooltip.5= Aus - keng Wolleken, am schnellsten
of.options.CLOUDS.tooltip.6=Schnell Wolleke sinn am 2D gerendert.
of.options.CLOUDS.tooltip.7=Schéi Wolleke sinn am 3D gerendert.

of.options.CLOUD_HEIGHT=Wollekenhéicht
of.options.CLOUD_HEIGHT.tooltip.1=Wollekenhéicht
of.options.CLOUD_HEIGHT.tooltip.2= Aus - Standardhéicht
of.options.CLOUD_HEIGHT.tooltip.3= 100%% - iwwert der max. Welt héicht

of.options.TREES=Beem
of.options.TREES.tooltip.1=Beem
of.options.TREES.tooltip.2= Standard - wéi vum Grafikmodus definéiert
of.options.TREES.tooltip.3= Schnell - méi geréng Qualitéit, méi schnell
of.options.TREES.tooltip.4= Fein - méi héich Qualitéit, schnell
of.options.TREES.tooltip.5= Schéin - héchste Qualitéit, méi lues
of.options.TREES.tooltip.6=Schnell Beem hunn onduerchsichteg Blieder
of.options.TREES.tooltip.7=Schéin a fein Beem hunn transparent Blieder.

of.options.RAIN=Reen a Schnéi
of.options.RAIN.tooltip.1=Reen a Schnéi
of.options.RAIN.tooltip.2= Standard - wéi vum Grafikmodus definéiert
of.options.RAIN.tooltip.3= Schnell - liichte Reen/Schnéi, méi schnell
of.options.RAIN.tooltip.4= Schéin - heftege Reen/Schnéi, méi lues
of.options.RAIN.tooltip.5= Aus - keen Reen/Schnéi, schnellst
of.options.RAIN.tooltip.6=Och wann de Reen aus ass, héiert een nach ëmmer
of.options.RAIN.tooltip.7=Geräischer

of.options.SKY=Himmel
of.options.SKY.tooltip.1=Himmel
of.options.SKY.tooltip.2= Un - Himmel siichtbar, méi lues
of.options.SKY.tooltip.3= Aus - Himmel net siichtbar, méi schnell
of.options.SKY.tooltip.4=Och wann den Himmel aus ass, sinn de Mount an d'Sonn
of.options.SKY.tooltip.5=nach ëmmer siichtbar.

of.options.STARS=Stären
of.options.STARS.tooltip.1=Stären
of.options.STARS.tooltip.2= Un - Stäre siichtbar, méi lues
of.options.STARS.tooltip.3= Aus - Stären net siichtbar, méi schnell

of.options.SUN_MOON=Sonn a Mound
of.options.SUN_MOON.tooltip.1=Sonn a Mound
of.options.SUN_MOON.tooltip.2= Un - Sonn a Mound siichtbar (Standard)
of.options.SUN_MOON.tooltip.3= Aus - Sonn a Mound net siichtbar (méi schnell)

of.options.SHOW_CAPES=Emhang weisen
of.options.SHOW_CAPES.tooltip.1=Emhang weisen
of.options.SHOW_CAPES.tooltip.2= Un - weis d'Emhäng vun de Spiller (Standard)
of.options.SHOW_CAPES.tooltip.3= Aus - d'Emhäng vun de Spiller ginn net ugewisen

of.options.TRANSLUCENT_BLOCKS=Blocktransparenz
of.options.TRANSLUCENT_BLOCKS.tooltip.1=Blocktransparenz
of.options.TRANSLUCENT_BLOCKS.tooltip.2= Schéin - korrekt Faarfmëschung (Standard)
of.options.TRANSLUCENT_BLOCKS.tooltip.3= Schnell - schnell Faarfmëschung (méi schnell)
of.options.TRANSLUCENT_BLOCKS.tooltip.4=Kontrolléiert Faarfmëschung vun transparente Bléck
of.options.TRANSLUCENT_BLOCKS.tooltip.5=aus verschiddene Faarwen (gefierfte Glas, Waasser, Äis)
of.options.TRANSLUCENT_BLOCKS.tooltip.6=wann se hannert ënne plazéiert sinn oder Loft
of.options.TRANSLUCENT_BLOCKS.tooltip.7=dertëschent ass.

of.options.HELD_ITEM_TOOLTIPS=Géigestandbeschreiw.
of.options.HELD_ITEM_TOOLTIPS.tooltip.1=Géigestandbeschreiwung
of.options.HELD_ITEM_TOOLTIPS.tooltip.2= Un - weis Géigestandbeschreiwung un (Standard)
of.options.HELD_ITEM_TOOLTIPS.tooltip.3= Aus - weis keng Géigestandbeschreiwung

of.options.DROPPED_ITEMS=Géigenstänn
of.options.DROPPED_ITEMS.tooltip.1=Falengelosse Géigenstänn
of.options.DROPPED_ITEMS.tooltip.2= Standard - wéi vum Grafikmodus definéiert
of.options.DROPPED_ITEMS.tooltip.3= Schnell - 2D falengelosse Géigestänn, méi schnell
of.options.DROPPED_ITEMS.tooltip.4= Schéin - 3D falengelosse Géigestänn, méi lues

options.entityShadows.tooltip.1=Objetschieter
options.entityShadows.tooltip.2= Un - weis Objetschieter un
options.entityShadows.tooltip.3= Aus - keng Objetschieter

of.options.VIGNETTE=Vignette
of.options.VIGNETTE.tooltip.1=Visuellen Effekt deen d'Ecker liicht ofdonkelt
of.options.VIGNETTE.tooltip.2= Standard - wéi vum Grafikmodus definéiert (Standard)
of.options.VIGNETTE.tooltip.3= Schnell - Vignette deaktivéiert (méi schnell)
of.options.VIGNETTE.tooltip.4= Schéin - Vignette aktivéiert (méi lues)
of.options.VIGNETTE.tooltip.5=D'Vignette kann ee staarken Impakt ob d'FPS hunn,
of.options.VIGNETTE.tooltip.6=virun allem wann am Vollbildmodus gespillt gëtt.
of.options.VIGNETTE.tooltip.7=De Vignette Effekt ass relativ geréng a kann dofir
of.options.VIGNETTE.tooltip.8=ouni Problem deaktivéiert ginn.

# Performance

of.options.SMOOTH_FPS=Stabil FPS
of.options.SMOOTH_FPS.tooltip.1=Stabiliséiert FPS duerch eidel maache
of.options.SMOOTH_FPS.tooltip.2=vum Grafikdreiwerpuffer
of.options.SMOOTH_FPS.tooltip.3= Aus - keng Stabilisatioun, FPS kënnen onstabil sinn
of.options.SMOOTH_FPS.tooltip.4= Un - FPS stabiliséiert
of.options.SMOOTH_FPS.tooltip.5=Dës Optioun hängt vun de Grafikdreiwer of an d'Effekter
of.options.SMOOTH_FPS.tooltip.6=sinn net ëmmer siichtbar.

of.options.SMOOTH_WORLD=Welt Stabiliséierung
of.options.SMOOTH_WORLD.tooltip.1=Hellt Lag Spëtzten déi duerch den interne Server
of.options.SMOOTH_WORLD.tooltip.2=verurs

minecraft_minecraft_optifine_lang_pl_PL.lang

minecraft_minecraft_optifine_lang_ru_RU.lang

minecraft_minecraft_optifine_lang_sv_SE.lang

minecraft_minecraft_optifine_lang_uk_UA.lang

minecraft_minecraft_optifine_lang_zh_CN.lang

minecraft_minecraft_optifine_natural.properties

minecraft_minecraft_shaders_post_antialias.json

minecraft_minecraft_shaders_post_art.json

minecraft_minecraft_shaders_post_bits.json

minecraft_minecraft_shaders_post_blobs.json

minecraft_minecraft_shaders_post_blobs2.json

minecraft_minecraft_shaders_post_blur.json

minecraft_minecraft_shaders_post_bumpy.json

minecraft_minecraft_shaders_post_color_convolve.json

minecraft_minecraft_shaders_post_creeper.json

minecraft_minecraft_shaders_post_deconverge.json

minecraft_minecraft_shaders_post_desaturate.json

minecraft_minecraft_shaders_post_entity_outline.json

minecraft_minecraft_shaders_post_flip.json

minecraft_minecraft_shaders_post_fxaa.json

minecraft_minecraft_shaders_post_fxaa_of_2x.json

minecraft_minecraft_shaders_post_fxaa_of_4x.json

minecraft_minecraft_shaders_post_green.json

minecraft_minecraft_shaders_post_invert.json

minecraft_minecraft_shaders_post_notch.json

minecraft_minecraft_shaders_post_ntsc.json

minecraft_minecraft_shaders_post_outline.json

minecraft_minecraft_shaders_post_pencil.json

minecraft_minecraft_shaders_post_phosphor.json

minecraft_minecraft_shaders_post_scan_pincushion.json

minecraft_minecraft_shaders_post_sobel.json

minecraft_minecraft_shaders_post_spider.json

minecraft_minecraft_shaders_post_wobble.json

minecraft_minecraft_shaders_program_antialias.fsh

minecraft_minecraft_shaders_program_antialias.json

minecraft_minecraft_shaders_program_bits.fsh

minecraft_minecraft_shaders_program_bits.json

minecraft_minecraft_shaders_program_blit.fsh

minecraft_minecraft_shaders_program_blit.json

minecraft_minecraft_shaders_program_blit.vsh

minecraft_minecraft_shaders_program_blobs.fsh

minecraft_minecraft_shaders_program_blobs.json

minecraft_minecraft_shaders_program_blobs.vsh

minecraft_minecraft_shaders_program_blobs2.fsh

minecraft_minecraft_shaders_program_blobs2.json

minecraft_minecraft_shaders_program_blur.fsh

minecraft_minecraft_shaders_program_blur.json

minecraft_minecraft_shaders_program_bumpy.fsh

minecraft_minecraft_shaders_program_bumpy.json

minecraft_minecraft_shaders_program_bumpy.vsh

minecraft_minecraft_shaders_program_color_convolve.fsh

minecraft_minecraft_shaders_program_color_convolve.json

minecraft_minecraft_shaders_program_deconverge.fsh

minecraft_minecraft_shaders_program_deconverge.json

minecraft_minecraft_shaders_program_downscale.fsh

minecraft_minecraft_shaders_program_downscale.json

minecraft_minecraft_shaders_program_downscale.vsh

minecraft_minecraft_shaders_program_entity_outline.json

minecraft_minecraft_shaders_program_entity_sobel.fsh

minecraft_minecraft_shaders_program_flip.json

minecraft_minecraft_shaders_program_flip.vsh

minecraft_minecraft_shaders_program_fxaa.fsh

minecraft_minecraft_shaders_program_fxaa.json

minecraft_minecraft_shaders_program_fxaa.vsh

minecraft_minecraft_shaders_program_fxaa_of_2x.fsh

minecraft_minecraft_shaders_program_fxaa_of_2x.json

minecraft_minecraft_shaders_program_fxaa_of_2x.vsh

minecraft_minecraft_shaders_program_fxaa_of_4x.fsh

minecraft_minecraft_shaders_program_fxaa_of_4x.json

minecraft_minecraft_shaders_program_fxaa_of_4x.vsh

minecraft_minecraft_shaders_program_invert.fsh

minecraft_minecraft_shaders_program_invert.json

minecraft_minecraft_shaders_program_invert.vsh

minecraft_minecraft_shaders_program_notch.fsh

minecraft_minecraft_shaders_program_notch.json

minecraft_minecraft_shaders_program_ntsc_decode.fsh

minecraft_minecraft_shaders_program_ntsc_decode.json

minecraft_minecraft_shaders_program_ntsc_encode.fsh

minecraft_minecraft_shaders_program_ntsc_encode.json

minecraft_minecraft_shaders_program_outline.fsh

minecraft_minecraft_shaders_program_outline.json

minecraft_minecraft_shaders_program_outline_combine.fsh

minecraft_minecraft_shaders_program_outline_combine.json

minecraft_minecraft_shaders_program_outline_soft.fsh

minecraft_minecraft_shaders_program_outline_soft.json

minecraft_minecraft_shaders_program_outline_watercolor.fsh