tcr/server/src/main/java/server/Server.java

package server;

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.InetAddress;
import java.security.KeyPair;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.text.SimpleDateFormat;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Queue;
import java.util.Map.Entry;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;

import common.Version;
import common.collect.Lists;
import common.collect.Maps;
import common.color.TextColor;
import common.dimension.Dimension;
import common.dimension.Space;
import common.entity.Entity;
import common.entity.npc.EntityHuman;
import common.entity.npc.EntityNPC;
import common.future.Futures;
import common.future.ListenableFuture;
import common.future.ListenableFutureTask;
import common.future.ThreadFactoryBuilder;
import common.init.Config;
import common.init.EntityRegistry;
import common.init.Registry;
import common.init.UniverseRegistry;
import common.init.Config.ValueType;
import common.log.Log;
import common.net.bootstrap.ServerBootstrap;
import common.net.channel.Channel;
import common.net.channel.ChannelException;
import common.net.channel.ChannelFuture;
import common.net.channel.ChannelFutureListener;
import common.net.channel.ChannelHandler;
import common.net.channel.ChannelInitializer;
import common.net.channel.ChannelOption;
import common.net.channel.nio.NioEventLoopGroup;
import common.net.channel.socket.nio.NioServerSocketChannel;
import common.net.handler.timeout.ReadTimeoutHandler;
import common.net.util.concurrent.Future;
import common.net.util.concurrent.GenericFutureListener;
import common.network.IPlayer;
import common.network.IThreadListener;
import common.network.NetConnection;
import common.network.Packet;
import common.network.PacketDecoder;
import common.network.PacketEncoder;
import common.network.PacketPrepender;
import common.network.PacketSplitter;
import common.network.NetHandler.ThreadQuickExitException;
import common.packet.RPacketEnableCompression;
import common.packet.RPacketLoginSuccess;
import common.packet.SPacketEntityEffect;
import common.packet.SPacketChangeGameState;
import common.packet.SPacketPlayerListItem;
import common.packet.SPacketPlayerAbilities;
import common.packet.SPacketDisconnect;
import common.packet.SPacketHeldItemChange;
import common.packet.SPacketJoinGame;
import common.packet.SPacketRespawn;
import common.packet.SPacketSetExperience;
import common.packet.SPacketSkin;
import common.packet.SPacketTimeUpdate;
import common.packet.SPacketWorld;
import common.potion.PotionEffect;
import common.tags.TagObject;
import common.util.BlockPos;
import common.util.EncryptUtil;
import common.util.ExtMath;
import common.util.LazyLoader;
import common.util.PortalType;
import common.util.Position;
import common.util.Util;
import common.util.WorldPos;
import common.world.World;
import server.biome.GenBiome;
import server.clipboard.ReorderRegistry;
import server.clipboard.RotationRegistry;
import server.command.CommandEnvironment;
import server.command.Executor;
import server.command.FixedExecutor;
import server.network.HandshakeHandler;
import server.network.Player;
import server.network.User;
import server.world.Converter;
import server.world.Region;
import server.world.WorldServer;

public final class Server implements IThreadListener {
	private static final LazyLoader<NioEventLoopGroup> SERVER_NIO_EVENTLOOP = new LazyLoader<NioEventLoopGroup>() {
		protected NioEventLoopGroup load() {
			return new NioEventLoopGroup(0, (new ThreadFactoryBuilder()).setNameFormat("Netty Server IO #%d").setDaemon(true).build());
		}
	};

	private final Thread serverThread = Thread.currentThread();
	private final List<NetConnection> clients = Collections.<NetConnection>synchronizedList(Lists.<NetConnection>newArrayList());
	private final List<Player> players = Lists.<Player>newArrayList();
	private final Map<String, Player> online = Maps.<String, Player>newHashMap();
	private final Map<String, User> users = Maps.newTreeMap();
	private final Queue<FutureTask<?>> queue = new ArrayDeque<FutureTask<?>>();
	private final long[] tickTimes = new long[100];
	private final Map<Integer, WorldServer> dimensions = Maps.newTreeMap();
	private final List<WorldServer> worlds = Lists.<WorldServer>newArrayList();
	private final List<WorldServer> ticked = Lists.<WorldServer>newArrayList();
	private final List<Dimension> unload = Lists.<Dimension>newArrayList();
	private final Map<String, Position> warps = Maps.<String, Position>newTreeMap();
	private final CommandEnvironment scriptEnv = new CommandEnvironment(this);
	private final boolean debug;

	private KeyPair keyPair;
	private WorldServer space;
	private ChannelFuture endpoint;
	
	private boolean running = true;
	private boolean stopped;
	private boolean started;
	private String endMessage = "Server beendet";

	private long currentTime = System.nanoTime() / 1000L;
	private long tpsTarget;
	private long ticksDone;
	private long ticksTodo;
	private long timePassed;
	private long lastSchedule;
	private long lastPoll;
	private long tpsRate;

	private long lastWarning;

	private int saveTimer;
	private int pingTimer;
	private int syncTimer;
	private int perfTimer;
	
	public static void main(String[] args) {
		long time = System.currentTimeMillis();
		Util.checkPlatform();
		Log.init();
		Registry.setup("Server thread");
		Log.SYSTEM.info("Starte " + Version.NAME + " Server Version " + Util.VERSION + " (Protokoll #" + Util.PROTOCOL + ")");
		GenBiome.setAsProvider();
		UniverseRegistry.register();
	    RotationRegistry.register();
	    ReorderRegistry.register();
		boolean debug = System.getProperty("server.debug", null) != null;
		final Server server = new Server(debug);
		Registry.addShutdownHook(new Runnable() {
			public void run() {
				server.stopServer();
			}
		});
		Log.setSync(server);
		server.run(time);
        Region.killIO();
        Log.flushLog();
	}

	public static void saveServerConfig(long time, Server server) {
		TagObject data = new TagObject();
		data.setLong("Time", time);
		data.setLong("LastAccess", System.currentTimeMillis());
		data.setString("Version", Util.VERSION);
		TagObject cfg = new TagObject();
		for(String cvar : Config.VARS.keySet()) {
			Config.Value value = Config.VARS.get(cvar);
			if(!value.noDef || !value.def.equals(value.getValue()))
				cfg.setString(cvar, value.getValue());
		}
		data.setObject("Config", cfg);
		data.setObject("Universe", UniverseRegistry.toTags());
		if(server != null) {
			data.setByteArray("PrivateKey", server.getPrivateKey().getEncoded());
			data.setByteArray("PublicKey", server.getPublicKey().getEncoded());
		}
		File nfile = new File("server.cdt.tmp");
		File lfile = new File("server.cdt");
		try {
			TagObject.writeGZip(data, nfile);
			if(lfile.exists())
				lfile.delete();
			nfile.renameTo(lfile);
		}
		catch(Exception e) {
			Log.IO.error(e, "Fehler beim Schreiben von " + nfile);
		}
	}

	public long loadServerConfig() {
		Config.clear();
	    UniverseRegistry.clear();
		File file = new File("server.cdt");
		if(!file.exists())
			file = new File("server.cdt.tmp");
		if(file.exists()) {
			try {
				TagObject tag = TagObject.readGZip(file);
				TagObject cfg = tag.getObject("Config");
				for(String key : cfg.keySet()) {
					Config.set(key, cfg.getString(key), false);
				}
				UniverseRegistry.fromTags(tag.getObject("Universe"));
				long lastPlayed = tag.getLong("LastAccess");
				String version = tag.hasString("Version") ? tag.getString("Version") : null;
				version = version != null && version.isEmpty() ? "<unbekannt>" : version;
				long time = tag.hasLong("Time") ? tag.getLong("Time") : World.START_TIME;
				Log.IO.info("Version: %s", version);
				Log.IO.info("Weltzeit: %d Ticks / %d Sekunden", time, time / 20L);
				Log.IO.info("Zuletzt geladen: %s", new SimpleDateFormat("dd.MM.yyyy HH:mm:ss").format(new Date(lastPlayed)));
				if(tag.hasByteArray("PrivateKey") && tag.hasByteArray("PublicKey")) {
					PrivateKey key = EncryptUtil.decodePrivateKey(tag.getByteArray("PrivateKey"));
					PublicKey pubkey = EncryptUtil.decodePublicKey(tag.getByteArray("PublicKey"));
					if(key != null && pubkey != null)
						this.keyPair = new KeyPair(pubkey, key);
				}
				return time;
			}
			catch(Exception e) {
				Log.IO.error(e, "Fehler beim Lesen von " + file);
				Config.clear();
			    UniverseRegistry.clear();
			}
		}
		Log.IO.info("Erstelle neue Welt und Konfiguration");
		return World.START_TIME;
	}

	private Server(boolean debug) {
		this.debug = debug;
		Config.setCallback(new Runnable() {
			public void run() {
				for(WorldServer world : Server.this.getWorlds()) {
					world.updatePhysics();
				}
				Server.this.sendPacket(new SPacketWorld(WorldServer.clampGravity(), Config.dayCycle, Config.timeFlow));
			}
		}, "daylightCycle", "timeFlow", "gravity");
		Config.setCallback(new Runnable() {
			public void run() {
				for(WorldServer world : Server.this.getWorlds()) {
					world.updateViewRadius();
				}
			}
		}, "viewDistance");
		Config.setCallback(new Runnable() {
			public void run() {
				Server.this.bind(Config.port);
			}
		}, "port");
		Config.setCallback(new Runnable() {
			public void run() {
				if((!Config.password.isEmpty() && Config.password.length() < 8) || Config.password.length() > IPlayer.MAX_PASS_LENGTH) {
					Log.IO.error("Passwort muss aus 8-" + IPlayer.MAX_PASS_LENGTH + " Zeichen bestehen");
					Config.set("password", "", false);
				}
			}
		}, "password");
	}
	
	public CommandEnvironment getScriptEnvironment() {
		return this.scriptEnv;
	}

	public List<String> getPlayerFilenames() {
		String[] list = this.debug ? null : new File("players").list();
		if(list == null)
			return Lists.newArrayList();
		List<String> names = Lists.newArrayList();
		for(int i = 0; i < list.length; ++i) {
			if(list[i].endsWith(".cdt")) {
				String name = list[i].substring(0, list[i].length() - 4);
				if(IPlayer.isValidUser(name))
					names.add(name);
			}
		}
		return names;
	}
	
	public void saveWorldInfo() {
		if(!this.debug) {
			saveServerConfig(this.space.getDayTime(), this);
			WorldServer.saveWarps(this.warps);
		}
	}
	
	public TagObject loadPlayerData(String user) {
		if(this.debug || !IPlayer.isValidUser(user))
			return null;
		TagObject tag = null;
		try {
			File dat = new File(new File("players"), user + ".cdt");

			if(dat.exists() && dat.isFile()) {
				tag = TagObject.readGZip(dat);
			}
		}
		catch(Exception e) {
			Log.IO.error(e, "Konnte Spielerdaten für " + user + " (offline) nicht laden");
		}
		return tag;
	}

	public void writePlayerData(String user, TagObject tag) {
		if(this.debug || !IPlayer.isValidUser(user))
			return;
		try {
			File tmp = new File(new File("players"), user + ".cdt.tmp");
			File dat = new File(new File("players"), user + ".cdt");
			TagObject.writeGZip(tag, tmp);
			if(dat.exists()) {
				dat.delete();
			}
			tmp.renameTo(dat);
		}
		catch(Exception e) {
			Log.IO.error(e, "Konnte Spielerdaten für " + user + " (offline) nicht speichern");
		}
	}
	
	public Position getOfflinePosition(String user) {
		TagObject tag = this.loadPlayerData(user);
		if(tag == null)
			return null;
		double posX = tag.getDouble("PosX");
		double posY = tag.getDouble("PosY");
		double posZ = tag.getDouble("PosZ");
		float rotYaw = tag.getFloat("Yaw");
		float rotPitch = tag.getFloat("Pitch");
        int dimension = tag.getInt("Dimension");
        return new Position(posX, posY, posZ, rotYaw, rotPitch, dimension);
	}

	public void saveAllWorlds(boolean message) {
		if(this.debug)
			return;
		if(message)
			Log.TICK.info("Speichere Welt");
		this.saveWorldInfo();
		for(WorldServer world : this.worlds) {
			world.saveAllChunks();
		}
	}

	public void unloadWorld(WorldServer world) {
		if(world != this.space)
			this.unloadWorld(world.dimension);
	}
	
	private void unloadWorld(Dimension dim) {
		WorldServer world = this.dimensions.get(dim.getDimensionId());
		if(world != null && world.players.isEmpty()) {
			world.saveAllChunks();
			Region.finishWrite();
			this.worlds.remove(world);
			this.dimensions.remove(dim.getDimensionId());
		}
	}
	
	public boolean setVar(Executor exec, String line) {
		if(line.length() < 1) {
			for(Entry<String, Config.Value> entry : Config.VARS.entrySet()) {
				Config.Value cvar = entry.getValue();
				String v = cvar.getValue();
				String comp = TextColor.YELLOW + entry.getKey() + TextColor.GRAY + " = ";
				if(cvar.noDef && cvar.def.equals(v))
					comp += TextColor.DGRAY + "[ - ]";
				else if(entry.getKey().equals("password") && !v.isEmpty())
					comp += TextColor.NEON + "'****'";
				else if(cvar.type == ValueType.STRING)
					comp += TextColor.NEON + "'" + v + "'";
				else
					comp += ((cvar.type == ValueType.BOOLEAN ? (v.equals("true") ? TextColor.GREEN : TextColor.RED) : TextColor.BLUE)) + v;
				if(!cvar.def.equals(v)) {
					comp += TextColor.GRAY + " (" + (cvar.noDef ? TextColor.DGRAY + "[ - ]" : TextColor.BROWN + cvar.def) + TextColor.GRAY + ")";
				}
				exec.logConsole(comp);
			}
			exec.logConsole(TextColor.GREEN + "SVARs insgesamt registriert: %d", Config.VARS.size());
			return true;
		}
		line = line.trim();
		String[] args = /* line.isEmpty() ? new String[0] : */ line.split(" ", -1);
		if(args.length == 1) {
//		case 0:
//			break;
//		case 1:
			Config.Value cfg = Config.VARS.get(args[0]);
			if(cfg == null)
				return false;
			String v = cfg.getValue();
			String comp = TextColor.YELLOW + args[0] + TextColor.GRAY + " = ";
			if(cfg.noDef && cfg.def.equals(v))
				comp += TextColor.DGRAY + "[ - ]";
			else if(cfg.type == ValueType.STRING)
				comp += TextColor.NEON + "'" + v + "'";
			else
				comp += ((cfg.type == ValueType.BOOLEAN ? (v.equals("true") ? TextColor.GREEN : TextColor.RED) : TextColor.BLUE)) + v;
			if(!cfg.def.equals(v))
				comp += TextColor.GRAY + " (" + (cfg.noDef ? TextColor.DGRAY + "[ - ]" : TextColor.BROWN + cfg.def) + TextColor.GRAY + ")";
			exec.logConsole(comp);
//			break;
//		default:
		}
		else {
			Config.Value cv = Config.VARS.get(args[0]);
			if(cv == null)
				return false;
			String value = args[1];
			if(cv.type == ValueType.STRING && "\"\"".equals(value)) {
				value = "";
			}
//			else if(cv.type == ValueType.BOOLEAN && "toggle".equalsIgnoreCase(value)) {
//				value = "" + !Boolean.parseBoolean(cv.getValue());
//			}
//			else
			if(cv.type == ValueType.BOOLEAN && !"true".equals(value) && !"false".equals(value)) {
				if(!value.equalsIgnoreCase("true") && !value.equalsIgnoreCase("false")) {
					exec.logConsole(TextColor.DRED + "'%s' ist nicht 'true' oder 'false'", value);
					return true;
				}
				value = value.toLowerCase();
			}
			if(cv.type == ValueType.INTEGER) {
				try {
					Integer.parseInt(value);
				}
				catch(NumberFormatException e) {
					exec.logConsole(TextColor.DRED + "'%s' ist keine gültige Zahl", value);
					return true;
				}
			}
			else if(cv.type == ValueType.FLOAT) {
				try {
					Float.parseFloat(value);
				}
				catch(NumberFormatException e) {
					exec.logConsole(TextColor.DRED + "'%s' ist keine gültige Zahl", value);
					return true;
				}
			}
			Config.set(args[0], value, true);
			exec.logConsole(TextColor.YELLOW + "%s" + TextColor.GRAY + " -> " + (cv.noDef && cv.def.equals(cv.getValue()) ? TextColor.DGRAY + "[ - ]" : ((cv.type == ValueType.BOOLEAN ? (cv.getValue().equals("true") ? TextColor.GREEN : TextColor.RED) : (cv.type == ValueType.STRING ? TextColor.NEON : TextColor.BLUE))) + "%s"), args[0], cv.type == ValueType.STRING ? ("'" + cv.getValue() + "'") : cv.getValue());
		}
		return true;
	}
	
	public void run(long time) {
		if(!this.debug) {
			Converter.convert();
			long wtime = this.loadServerConfig();
			if(this.keyPair == null) {
				Log.SYSTEM.info("Generiere neues Schlüsselpaar");
				this.keyPair = EncryptUtil.createKeypair();
			}
			User.loadDatabase(this.users);
//			if(dtime == -1L) // {
//				dtime = World.START_TIME;
////				Config.set("spawnDim", "1", null);
////			}
			this.worlds.add(this.space = new WorldServer(this, wtime,
					Space.INSTANCE, false));
			this.dimensions.put(this.space.dimension.getDimensionId(), this.space);
			new File("players").mkdirs();
//			if(Config.spawnY < 0) {
//				WorldServer world = this.getWorld(Config.spawnDim);
//				world = world == null ? this.space : world;
//				Random rand = new Random(world.getSeed());
//				int x = 0;
//				int z = 0;
//				int count = 0;
//				while(!(world.getGroundAboveSeaLevel(new BlockPos(x, 0, z)) == Blocks.grass)) {
//					if(count == 1000) {
//						SKC.warn("Konnte keine Spawn-Position finden");
//						break;
//					}
//					x += rand.zrange(64) - rand.zrange(64);
//					z += rand.zrange(64) - rand.zrange(64);
//					++count;
//				}
//				Config.set("spawnX", "" + x, null);
//				Config.set("spawnY", "" + world.getSeaLevel(), null);
//				Config.set("spawnZ", "" + z, null);
//				Config.set("spawnYaw", "" + (-180.0f + rand.floatv() * 360.0f), null);
//				Config.set("spawnPitch", "0.0", null);
//			}
		}
		else {
			Log.SYSTEM.info("Generiere temporäres Schlüsselpaar");
			this.keyPair = EncryptUtil.createKeypair();
			Config.clear();
	        UniverseRegistry.clear();
			Config.set("daylightCycle", "false", false);
			Config.set("weatherChanges", "false", false);
			Config.set("mobSpawning", "false", false);
			Config.set("spawnRadius", "0", false);
			this.worlds.add(this.space = new WorldServer(this, World.START_TIME,
					Space.INSTANCE, true));
			this.dimensions.put(this.space.dimension.getDimensionId(), this.space);
		}
		this.setTpsTarget(20.0f);
		if(!this.debug) {
			for(Dimension dim : UniverseRegistry.getDimensions()) {
				if(WorldServer.needsLoading(dim)) {
					this.getWorld(dim.getDimensionId()).loadForcedChunks();
				}
				WorldServer.loadWarps(dim, this.warps);
			}
		}
		if(Config.port >= 0)
			this.bind(Config.port);
		else
			Log.SYSTEM.warn("Kein Port definiert, verwende 'port <1024-32767>' um einen Hosting-Port festzulegen");
		if(Config.accessRequired && Config.password.length() < 8)
			Log.SYSTEM.warn("Kein Passwort definiert, verwende 'password <8-" + IPlayer.MAX_PASS_LENGTH + " Zeichen>' um ein Zugangspasswort festzulegen");
		Thread con = new Thread(new Runnable() {
			private final BufferedReader reader = new BufferedReader(new InputStreamReader(new BufferedInputStream(System.in)));
			
			public void run() {
				while(true) {
					String line;
					try {
						line = this.reader.readLine();
					}
					catch(IOException e) {
						line = null;
					}
					if(line == null)
						break;
					final String cmd = line;
					Server.this.schedule(new Runnable() {
						public void run() {
							FixedExecutor exec = new FixedExecutor(Server.this, "#con", "KONSOLE", null);
							if(!Server.this.setVar(exec, cmd))
								Server.this.scriptEnv.execute(cmd, exec);
						}
					});
				}
			}
		}, "Server console handler");
		con.setDaemon(true);
		con.start();
		Log.SYSTEM.info("Server gestartet in " + String.format("%.1f", (double)(System.currentTimeMillis() - time) / 1000.0) + " Sekunden");
		while(this.running) {
			this.currentTime = System.nanoTime() / 1000L;
			this.timePassed = this.currentTime - this.lastSchedule;
			this.lastSchedule = this.currentTime;
			if(this.timePassed < 0L) {
				Log.TICK.warn("Zeit lief rückwärts! Hat sich die Systemzeit geändert?");
				this.timePassed = 0L;
				this.ticksTodo = 0L;
			}
			if(this.timePassed > 2000000L && this.currentTime - this.lastWarning >= 15000000L) {
				Log.TICK.warn("Kann Server-Tick nicht aufrecht erhalten! Hat sich die Systemzeit geändert, oder ist der Server überlastet? " + 
				"Liege " + (this.timePassed / 1000L) + " ms zurück, überspringe " + ((this.timePassed * this.tpsTarget) / 1000000000L) + " Tick(s)");
				this.timePassed = 0L;
				this.lastWarning = this.currentTime;
				this.ticksTodo = 0L;
			}
			this.ticksTodo += (this.timePassed * this.tpsTarget) / 1000L;
			while(this.ticksTodo >= 1000000L && (System.nanoTime() / 1000L - this.currentTime) < 10000L) {
				this.ticksTodo -= 1000000L;
				this.tick();
				++this.ticksDone;
			}
			if((this.currentTime - this.lastPoll) >= 1000000L) {
				this.tpsRate = (this.ticksDone * 1000000000L) / (this.currentTime - this.lastPoll);
				this.lastPoll = this.currentTime;
				this.ticksDone = 0L;
			}
			this.started = true;
		}
		try {
			this.stopServer();
			this.stopped = true;
		}
		catch(Throwable e) {
			Log.SYSTEM.error(e, "Fehler beim Beenden des Servers");
		}
		finally {
			this.stopped = true;
			Log.SYSTEM.info("Server wurde beendet");
		}
	}
	
	public void preload(WorldServer world, int bx, int bz) {
		int done = 0;
		int total = Config.distance * 2 + 1;
		total *= total;
		Log.TICK.info("Generiere und lade Welt");
//		WorldServer world = this.getWorld(Config.spawnDim);
//		world = world == null ? this.space : world;
		bx = bx >> 4;
		bz = bz >> 4;
		long last = System.currentTimeMillis();
		for(int x = -Config.distance; x <= Config.distance; x++) {
			for(int z = -Config.distance; z <= Config.distance; z++) {
				long time = System.currentTimeMillis();
				if(time - last > 1000L) {
					Log.TICK.info("Bereite Spawnbereich vor" + ": " + (done * 100 / total) + "%");
					last = time;
				}
				++done;
				world.loadChunk(bx + x, bz + z);
			}
		}
	}
	
//	public void resetProgress() {
//		this.setProgress(-1);
//	}
//	
//	public void setDone() {
//		this.setProgress(-2);
//	}

	private void tick() {
//		boolean pause = this.paused;
//		this.paused = this.pause;
//		if(!pause && this.paused) {
//			if(!this.debug)
//				Log.info("Speichere und pausiere Spiel...");
//			this.saveAllPlayerData(true);
//			this.saveAllWorlds(true);
//		}
//		if(this.paused) {
//			synchronized(this.queue) {
//				while(!this.queue.isEmpty()) {
//					FutureTask<?> task = this.queue.poll();
//					try {
//						task.run();
//						task.get();
//					}
//					catch(ExecutionException e1) {
//						if(!(e1.getCause() instanceof ThreadQuickExitException))
//							Log.error("Fehler beim Ausführen von Pause-Task " + task, e1);
//					}
//					catch(InterruptedException e2) {
//						Log.error("Fehler beim Ausführen von Pause-Task " + task, e2);
//					}
//				}
//			}
//			return;
//		}
		long now = System.currentTimeMillis();
		synchronized(this.queue) {
			while(!this.queue.isEmpty()) {
				FutureTask<?> task = this.queue.poll();
				try {
					task.run();
					task.get();
				}
				catch(ExecutionException e1) {
					if(!(e1.getCause() instanceof ThreadQuickExitException))
						Log.SYSTEM.error(e1, "Fehler beim Ausführen von Server-Task " + task); // throw new RuntimeException(e1);
				}
				catch(InterruptedException e2) {
					Log.SYSTEM.error(e2, "Fehler beim Ausführen von Server-Task " + task);
				}
			}
		}
		if(++this.syncTimer == 20) {
			this.sendPacket(new SPacketTimeUpdate(this.space.getDayTime(), this.getInfo()));
			this.syncTimer = 0;
		}
		this.ticked.clear();
		this.ticked.addAll(this.worlds);
		for(WorldServer world : this.ticked) {
			world.tick();
			world.updateEntities();
			world.updateTrackedEntities();
			if(world != this.space && world.shouldUnload())
				this.unload.add(world.dimension);
		}
		for(Dimension dim : this.unload) {
			this.unloadWorld(dim);
		}
		this.networkTick();
		if(++this.pingTimer > 600) {
			this.sendPacket(new SPacketPlayerListItem((List)this.getPlayers()));
			this.pingTimer = 0;
		}
		if(Config.saveInterval > 0 && ++this.saveTimer >= Config.saveInterval) {
			this.saveAllPlayerData(false);
			this.saveAllWorlds(false);
			this.saveTimer = 0;
		}
        Log.flushLog();
		this.tickTimes[this.perfTimer++] = System.currentTimeMillis() - now;
		if(this.perfTimer == 100) {
			this.perfTimer = 0;
		}
	}
	
	public WorldServer getSpace() {
		return this.space;
	}

	public WorldServer getWorld(int dimension) {
		WorldServer world = this.dimensions.get(dimension);
		if(world == null) {
			Dimension dim = UniverseRegistry.getDimension(dimension);
			if(dim == null)
				return null;
			world = new WorldServer(this, this.space.getDayTime(),
	    			dim, this.debug);
			this.worlds.add(world);
			this.dimensions.put(dimension, world);
		}
		return world;
	}
	
	public WorldServer getWorldNoLoad(int dimension) {
		return this.dimensions.get(dimension);
	}

	public WorldServer getWorld(String alias) {
		Dimension dim = UniverseRegistry.getDimension(alias);
		return dim == null ? null : this.getWorld(dim.getDimensionId());
	}
	
	public List<WorldServer> getWorlds() {
		return this.worlds;
	}
	
	public void resetSaveTimer() {
		this.saveTimer = 0;
	}
	
	public long[] getTickTimes() {
		return this.tickTimes;
	}

	public float getAverageTps() {
	    long total = 0L;
	    for(int z = 0; z < this.tickTimes.length; z++) {
	        total += this.tickTimes[z];
	    }
	    return (float)total / (float)this.tickTimes.length;
	}

	public long getLastTick() {
		return this.tickTimes[this.perfTimer == 0 ? 99 : (this.perfTimer - 1)];
	}
	
	public float getTpsRate() {
		return ((float)this.tpsRate) / 1000.0f;
	}

	public float getTpsTarget() {
		return ((float)this.tpsTarget) / 1000.0f;
	}

	public void setTpsTarget(float target) {
		this.tpsTarget = this.tpsRate = (long)(target * 1000.0f);
		this.currentTime = this.lastSchedule = this.lastPoll = System.nanoTime() / 1000L;
		this.timePassed = this.ticksTodo = this.ticksDone = 0L;
	}

	public List<String> getAllPlayerNames() {
		List<String> list = new ArrayList<String>(this.players.size());
		for(int z = 0; z < this.players.size(); z++) {
			list.add(this.players.get(z).getUser());
		}
		return list;
	}

	public List<String> getAllUserNames() {
		return Lists.newArrayList(this.users.keySet());
	}

	public List<Player> getPlayers() {
		return this.players;
	}

	public Collection<User> getUsers() {
		return this.users.values();
	}

	public Player getPlayer(String user) {
		return this.online.get(user);
	}

	public User getUser(String user) {
		return this.users.get(user);
	}
	
	private <V> ListenableFuture<V> callFromMainThread(Callable<V> callable) {
		if(!this.isMainThread() && !this.stopped) {
			ListenableFutureTask<V> task = ListenableFutureTask.<V>create(callable);
			synchronized(this.queue) {
				this.queue.add(task);
				return task;
			}
		}
		else {
			try {
				return Futures.<V>immediateFuture(callable.call());
			}
			catch(Exception exception) {
				Log.SYSTEM.error(exception, "Fehler beim sofortigen Ausführen von Server-Task " + callable);
				return Futures.immediateFailedFuture(exception);
			}
		}
	}

	public ListenableFuture<Object> schedule(Runnable run) {
		return this.<Object>callFromMainThread(Executors.callable(run));
	}

	public boolean isMainThread() {
		return Thread.currentThread() == this.serverThread;
	}
	
//	private void movePlayerToSpawn(EntityNPC player) {
//    	BlockPos pos = new BlockPos(Config.spawnX, Config.spawnY, Config.spawnZ);
//        int radius = Config.spawnRadius;
//        if(radius > 0) {
//            pos = ((WorldServer)player.worldObj).getTopSolidOrLiquidBlock(pos.add(
//            		ExtMath.clampi(player.worldObj.rand.excl(-radius, radius), -World.MAX_SIZE + 1, World.MAX_SIZE - 1), 0, 
//            		ExtMath.clampi(player.worldObj.rand.excl(-radius, radius), -World.MAX_SIZE + 1, World.MAX_SIZE - 1)));
//        }
//        player.moveToBlockPosAndAngles(pos, radius > 0 ? (-180.0f + player.worldObj.rand.floatv() * 360.0f) : Config.spawnYaw, 
//        		radius > 0 ? 0.0f : Config.spawnPitch);
//        while(radius >= 0 && !player.worldObj.getCollidingBoundingBoxes(player, player.getEntityBoundingBox()).isEmpty() 
//        		&& player.posY < 511.0D) {
//        	player.setPosition(player.posX, player.posY + 1.0D, player.posZ);
//        }
//	}
	
	public Position getRandomSpawnPosition(WorldPos origin) {
		WorldServer world = this.getWorld(origin.getDimension());
		world = world == null ? this.space : world;
    	BlockPos pos = origin;
        int radius = Config.spawnRadius;
        if(radius > 0) {
            pos = world.getTopSolidOrLiquidBlock(pos.add(
            		ExtMath.clampi(world.rand.excl(-radius, radius), -World.MAX_SIZE + 1, World.MAX_SIZE - 1), 0, 
            		ExtMath.clampi(world.rand.excl(-radius, radius), -World.MAX_SIZE + 1, World.MAX_SIZE - 1)));
        }
		int y = pos.getY();
    	while(world.getState(new BlockPos(pos.getX(), y, pos.getZ())).getBlock().getMaterial().blocksMovement() && y < 511)
            y++;
    	return new Position(pos.getX() + 0.5d, (double)y, pos.getZ() + 0.5d, 
    			radius > 0 ? (-180.0f + world.rand.floatv() * 360.0f) : Config.spawnYaw, 
    	        		radius > 0 ? 0.0f : Config.spawnPitch, world.dimension.getDimensionId());
	}
	
	public void addUser(User user) {
		this.users.put(user.getUser(), user);
	}

	public void addPlayer(NetConnection connection, String loginUser) {
		TagObject tag = this.readPlayer(loginUser);
		Player conn = new Player(this, connection, loginUser);
		if(tag != null)
			conn.readTags(tag);
        if(Config.compression >= 0) {
        	connection.sendPacket(new RPacketEnableCompression(Config.compression), new ChannelFutureListener() {
                public void operationComplete(ChannelFuture future) throws Exception {
                	connection.setCompressionTreshold(Config.compression);
                }
            });
        }
		connection.sendPacket(new RPacketLoginSuccess(this.debug));
		connection.setNetHandler(conn);
		this.players.add(conn);
		User user = this.users.remove(loginUser);
		if(user != null)
			conn.copyFrom(user);
		this.users.put(loginUser, conn);
		this.online.put(loginUser, conn);
		
		tag = conn.readCharacter();
		WorldServer world = tag == null ? this.space : this.getWorld(tag.getInt("Dimension"));
		world = world == null ? this.space : world;
		EntityNPC player = conn.createPlayer(world, tag == null ? EntityRegistry.getEntityString(EntityHuman.class) : tag.getString("id"));
		if(tag != null)
			player.readTags(tag);
		else
			player.onInitialSpawn(null);
//		player.setWorld(world);
		if(tag == null)
			/* this.movePlayerToSpawn(player); */ player.moveToBlockPosAndAngles(new BlockPos(0, 16384, 0), 0.0f, 0.0f);
		
		Log.NETWORK.info(loginUser + "[" + connection.getCutAddress() + "] hat sich mit Objekt-ID " 
		+ player.getId() + " auf Level " + world.dimension.getDimensionId() + ": "
		+ String.format("%.2f %.2f %.2f", player.posX, player.posY, player.posZ) + " verbunden (" + (tag == null ? "Charakter-Editor" : "'" + player.getCommandName() + "'") + ")");
		
		conn.sendPacket(new SPacketJoinGame(player.getId(), world.dimension, EntityRegistry.getEntityID(player), tag == null));
		conn.sendPacket(new SPacketHeldItemChange(player.inventory.currentItem));
		conn.sendPacket(new SPacketWorld(WorldServer.clampGravity(),
				Config.dayCycle, Config.timeFlow));
//		conn.initializeStats();
		this.sendPacket(new SPacketPlayerListItem(false, conn));
		
		world.spawnEntityInWorld(player);
		this.preparePlayer(player, null);
		
		for(int i = 0; i < this.players.size(); ++i) {
			Player other = this.players.get(i);
			conn.sendPacket(new SPacketPlayerListItem(false, other));
		}
		conn.sendPacket(new SPacketSkin(player.getId(), player.getSkin())); // , player.getModel()));
		conn.setPlayerLocation(player.posX, player.posY, player.posZ, player.rotYaw, player.rotPitch);
		this.updateTimeAndWeatherForPlayer(conn, world);
		for(PotionEffect effect : player.getEffects()) {
			conn.sendPacket(new SPacketEntityEffect(player.getId(), effect));
		}
		conn.sendPacket(new SPacketPlayerAbilities(player));
		conn.addSelfToInternalCraftingInventory();
		conn.onConnect();
	}

	public void removePlayer(Player conn) {
		EntityNPC player = conn.getEntity();
		player.unmount();
		this.writePlayer(conn);
		WorldServer world = (WorldServer)player.getServerWorld();
		world.removeEntity(player);
		world.removePlayer(player);
		this.players.remove(conn);
		this.online.remove(conn.getUser());
		User user = new User(conn.getUser());
		user.copyFrom(conn);
		this.users.put(conn.getUser(), user);
		this.sendPacket(new SPacketPlayerListItem(true, conn));
	}

	private void preparePlayer(EntityNPC player, WorldServer oldWorld) {
		WorldServer newWorld = (WorldServer)player.getServerWorld();
		if(oldWorld != null) {
			oldWorld.removePlayer(player);
		}
		newWorld.addPlayer(player);
		newWorld.loadChunk((int)player.posX >> 4, (int)player.posZ >> 4);
	}

	private TagObject readPlayer(String user) {
		if(this.debug)
			return null;
		TagObject tag = null;
		try {
			File dat = new File(new File("players"), user + ".cdt");

			if(dat.exists() && dat.isFile()) {
				tag = TagObject.readGZip(dat);
			}
		}
		catch(Exception e) {
			Log.IO.error(e, "Konnte Spielerdaten für " + user + " nicht laden");
		}
		return tag;
	}

	private void writePlayer(Player conn) {
		if(this.debug)
			return;
		try {
			TagObject tag = new TagObject();
			EntityNPC entity = conn.getPresentEntity();
			if(entity != null) {
				TagObject etag = new TagObject();
				entity.writeTags(etag);
				etag.setInt("Dimension", entity.worldObj.dimension.getDimensionId());
				etag.setString("id", EntityRegistry.getEntityString(entity));
				conn.writeCharacter(etag);
			}
			conn.writeTags(tag);
			File tmp = new File(new File("players"), conn.getUser() + ".cdt.tmp");
			File dat = new File(new File("players"), conn.getUser() + ".cdt");
			TagObject.writeGZip(tag, tmp);
			if(dat.exists()) {
				dat.delete();
			}
			tmp.renameTo(dat);
		}
		catch(Exception e) {
			Log.IO.error(e, "Konnte Spielerdaten für " + conn.getUser() + " nicht speichern");
		}
	}

	public void recreatePlayer(Player conn) {
		EntityNPC old = conn.getEntity();
		BlockPos pos = old.getPosition();
		WorldServer oldWorld = (WorldServer)old.getServerWorld();
		oldWorld.removePlayerFromTrackers(old);
		oldWorld.untrackEntity(old);
		oldWorld.removePlayer(old);
		oldWorld.removePlayerEntityDangerously(old);
		WorldPos bed = old.getSpawnPoint();
		WorldPos origin = old.getOrigin();
		BlockPos spawn = null;
		String message = null;
		WorldServer world = bed == null ? this.space : this.getWorld(bed.getDimension());
		if(world == null) {
			world = this.space;
			bed = null;
			message = "Die Dimension deines Einstiegspunkts wurde gelöscht oder zerstört";
		}
		else if(bed != null) {
			spawn = EntityNPC.getBedSpawnLocation(world, bed);
			if(spawn == null) {
				world = this.space;
				bed = null;
				message = "Dein Einstiegspunkt wurde blockiert oder dein Bett zerstört";
			}
		}
		if(bed == null) {
			world = this.getWorld(origin.getDimension());
			world = world == null ? this.space : world;
		}
		EntityNPC nplayer = conn.createPlayer(world, EntityRegistry.getEntityString(old));
		conn.clonePlayer(old);
		nplayer.setId(old.getId());
		nplayer.setOrigin(origin);
		if(bed != null) {
			nplayer.setLocationAndAngles((double)((float)spawn.getX() + 0.5F), (double)((float)spawn.getY() + 0.1F),
					(double)((float)spawn.getZ() + 0.5F), 0.0F, 0.0F);
			nplayer.setSpawnPoint(bed);
		}
		else {
			Position rpos = this.getRandomSpawnPosition(origin);
			nplayer.setLocationAndAngles(rpos.x(), rpos.y(), rpos.z(), rpos.yaw(), rpos.pitch());
//			this.movePlayerToSpawn(nplayer);
		}
		world.loadChunk((int)nplayer.posX >> 4, (int)nplayer.posZ >> 4);
		if(bed != null ? Config.checkBed : Config.spawnRadius >= 0) {
			while(!world.getCollidingBoundingBoxes(nplayer, nplayer.getEntityBoundingBox()).isEmpty() && nplayer.posY < 512.0D) {
				nplayer.setPosition(nplayer.posX, nplayer.posY + 1.0D, nplayer.posZ);
			}
		}
		conn.sendPacket(new SPacketRespawn(world.dimension, EntityRegistry.getEntityID(nplayer), conn.isInEditor()));
		conn.setPlayerLocation(nplayer.posX, nplayer.posY, nplayer.posZ, nplayer.rotYaw, nplayer.rotPitch);
		conn.sendPacket(new SPacketSetExperience(nplayer.experience, nplayer.experienceTotal, nplayer.experienceLevel));
		this.updateTimeAndWeatherForPlayer(conn, world);
		world.addPlayer(nplayer);
		world.spawnEntityInWorld(nplayer);
		conn.addSelfToInternalCraftingInventory();
		nplayer.setHealth(nplayer.getHealth());
		conn.sendPlayerAbilities();
		if(message != null)
			conn.addHotbar(TextColor.DRED + message);
		conn.addFeed(TextColor.RED + "* Bei %d, %d, %d in Dimension %s gestorben", pos.getX(), pos.getY(), pos.getZ(),
				old.worldObj.dimension.getFormattedName(false));
	}

	public TagObject swapPlayer(Player conn, TagObject tag, Class<? extends EntityNPC> clazz) {
		EntityNPC old = conn.getEntity();
		old.unmount();
		TagObject oldTag = new TagObject();
		old.writeTags(oldTag);
		oldTag.setInt("Dimension", old.worldObj.dimension.getDimensionId());
		oldTag.setString("id", EntityRegistry.getEntityString(old));

		WorldServer oldWorld = (WorldServer)old.getServerWorld();
		oldWorld.removePlayerFromTrackers(old);
		oldWorld.untrackEntity(old);
		oldWorld.removePlayer(old);
		oldWorld.removePlayerEntityDangerously(old);
//		old.dead = false;
		
		WorldServer world = tag == null ? this.space : this.getWorld(tag.getInt("Dimension"));
		world = world == null ? this.space : world;
		EntityNPC nplayer = conn.createPlayer(world, tag == null ? EntityRegistry.getEntityString(clazz) : tag.getString("id"));
//		conn.sendPacket(new SPacketRespawn(world.dimension, EntityRegistry.getEntityID(nplayer)));
		if(tag != null)
			nplayer.readTags(tag);
		else
			nplayer.onInitialSpawn(null);
//		nplayer.clonePlayer(old);
		nplayer.setId(old.getId());
		if(tag == null)
			/* this.movePlayerToSpawn(nplayer); */ nplayer.moveToBlockPosAndAngles(new BlockPos(0, 16384, 0), 0.0f, 0.0f);
		world.loadChunk((int)nplayer.posX >> 4, (int)nplayer.posZ >> 4);
		world.addPlayer(nplayer);
		world.spawnEntityInWorld(nplayer);
		conn.sendPacket(new SPacketRespawn(world.dimension, EntityRegistry.getEntityID(nplayer), conn.isInEditor()));
		conn.sendPacket(new SPacketSkin(nplayer.getId(), nplayer.getSkin())); // , nplayer.getModel()));
		conn.setPlayerLocation(nplayer.posX, nplayer.posY, nplayer.posZ, nplayer.rotYaw, nplayer.rotPitch);
		conn.sendPacket(new SPacketSetExperience(nplayer.experience, nplayer.experienceTotal, nplayer.experienceLevel));
//		conn.initializeStats();
		conn.addSelfToInternalCraftingInventory();
		nplayer.setHealth(nplayer.getHealth());
		this.updateTimeAndWeatherForPlayer(conn, world);
		this.syncPlayerInventory(nplayer);
		for(PotionEffect effect : nplayer.getEffects()) {
			conn.sendPacket(new SPacketEntityEffect(nplayer.getId(), effect));
		}
		conn.sendPlayerAbilities();
		return oldTag;
	}

	public void transferToDimension(EntityNPC player, int dimension, BlockPos pos, float yaw, float pitch, PortalType portal) {
		WorldServer oldWorld = (WorldServer)player.getServerWorld(); // this.getWorld(player.dimension);
//		player.dimension = dimension;
		WorldServer newWorld = this.getWorld(dimension);
		player.connection.sendPacket(new SPacketRespawn(newWorld.dimension, EntityRegistry.getEntityID(player), player.connection.isInEditor()));
		oldWorld.removePlayerEntityDangerously(player);
		player.dead = false;
		this.placeInDimension(player, oldWorld, newWorld, pos, portal);
		if(player.isEntityAlive()) {
			newWorld.spawnEntityInWorld(player);
			newWorld.updateEntity(player, false);
		}
//        player.loadedChunks.clear(); // FIX ??
		this.preparePlayer(player, oldWorld);
		player.connection.setPlayerLocation(player.posX, player.posY, player.posZ, pos != null ? yaw : player.rotYaw, pos != null ? pitch : player.rotPitch);
		if(pos != null)
			player.setRotationYawHead(yaw);
//		player.interactManager.setWorld(newWorld);
		this.updateTimeAndWeatherForPlayer((Player)player.connection, newWorld);
		this.syncPlayerInventory(player);
		for(PotionEffect effect : player.getEffects()) {
			player.connection.sendPacket(new SPacketEntityEffect(player.getId(), effect));
		}
		player.connection.sendPlayerAbilities();
	}

	public void placeInDimension(Entity entity, WorldServer oldWorld, WorldServer world, BlockPos pos, PortalType portal) {
		double newX = entity.posX;
		double newY = entity.posY;
		double newZ = entity.posZ;
		float newYaw = entity.rotYaw;
		float newPitch = entity.rotPitch;
		if(pos != null) {
			newX = ((double)pos.getX()) + 0.5;
			newY = pos.getY();
			newZ = ((double)pos.getZ()) + 0.5;
		}
		else {
			pos = world.getTopSolidOrLiquidBlock(new BlockPos(newX, 0, newZ));
			newX = ((double)pos.getX()) + 0.5;
			newY = (double)pos.getY();
			newZ = ((double)pos.getZ()) + 0.5;
		}
		newX = (double)ExtMath.clampd(newX, -World.MAX_SIZE + 1, World.MAX_SIZE - 1);
		newZ = (double)ExtMath.clampd(newZ, -World.MAX_SIZE + 1, World.MAX_SIZE - 1);
		entity.setLocationAndAngles(newX, newY, newZ, newYaw, newPitch);
		if(entity.isEntityAlive()) {
			oldWorld.updateEntity(entity, false);
		}
		if(entity.isEntityAlive()) {
			entity.setLocationAndAngles(newX, entity.posY, newZ, entity.rotYaw, entity.rotPitch);
			if(portal != null)
				world.makePortal(new BlockPos(ExtMath.floord(entity.posX)
		        ,ExtMath.floord(entity.posY)
		        ,ExtMath.floord(entity.posZ)), 128, portal);
		}
		entity.setWorld(world);
	}

	public void sendPacket(Packet packet) {
		for(Player conn : this.players) {
			conn.sendPacket(packet);
		}
	}

	public void sendPacket(Packet packet, int dimension) {
		for(Player conn : this.players) {
			if(conn.getEntity() != null && conn.getEntity().worldObj.dimension.getDimensionId() == dimension) {
				conn.sendPacket(packet);
			}
		}
	}

	public void sendNear(double x, double y, double z, double radius, int dimension, Packet packet) {
		this.sendNearExcept(null, x, y, z, radius, dimension, packet);
	}

	public void sendNearExcept(EntityNPC except, double x, double y, double z, double radius, int dimension, Packet packet) {
		for(Player conn : this.players) {
			EntityNPC player = conn.getEntity();
			if(player != null && player != except && player.worldObj.dimension.getDimensionId() == dimension) {
				double dx = x - player.posX;
				double dy = y - player.posY;
				double dz = z - player.posZ;
				if(dx * dx + dy * dy + dz * dz < radius * radius) {
					conn.sendPacket(packet);
				}
			}
		}
	}

	public void saveAllPlayerData(boolean message) {
		if(this.debug)
			return;
		if(message) {
			Log.TICK.info("Speichere Spielerdaten");
		}
		for(Player conn : this.players) {
			this.writePlayer(conn);
		}
		User.saveDatabase(this.users);
	}

	private void updateTimeAndWeatherForPlayer(Player conn, WorldServer world) {
		conn.sendPacket(new SPacketTimeUpdate(world.getDayTime(), this.getInfo()));
		conn.sendPacket(new SPacketChangeGameState(SPacketChangeGameState.Action.SET_WEATHER, world.getWeather().getID()));
		conn.sendPacket(new SPacketChangeGameState(SPacketChangeGameState.Action.RAIN_STRENGTH, world.getRainStrength()));
		conn.sendPacket(new SPacketChangeGameState(SPacketChangeGameState.Action.DARKNESS, world.getDarkness()));
		conn.sendPacket(new SPacketChangeGameState(SPacketChangeGameState.Action.FOG_STRENGTH, world.getFogStrength()));
		conn.sendPacket(new SPacketChangeGameState(SPacketChangeGameState.Action.TEMPERATURE, world.getTempOffset()));
	}

	public void syncPlayerInventory(EntityNPC player) {
		player.connection.sendContainerToPlayer(player.inventoryContainer);
		player.connection.setPlayerHealthUpdated();
		player.connection.sendPacket(new SPacketHeldItemChange(player.inventory.currentItem));
	}
	
	private void terminateEndpoint(String message) {
		if(this.started)
			for(Player conn : Lists.newArrayList(this.players)) {
				conn.disconnect(message);
			}
		synchronized(this.serverThread) {
			if(this.endpoint != null) {
				Log.NETWORK.info("Schließe Port");
				try {
					this.endpoint.channel().close().sync();
					this.endpoint = null;
				}
				catch(InterruptedException e) {
					Log.NETWORK.warn("Unterbrochen beim Schließen des Kanals");
				}
			}
		}
	}

	private void networkTick() {
		synchronized(this.clients) {
			Iterator<NetConnection> iter = this.clients.iterator();
			while(iter.hasNext()) {
				final NetConnection manager = iter.next();
				if(!manager.hasNoChannel()) {
					if(!manager.isChannelOpen()) {
						iter.remove();
						manager.checkDisconnected();
					}
					else {
						try {
							manager.processReceivedPackets();
						}
						catch(Exception e) {
							Log.NETWORK.error(e, "Konnte Paket von " + manager.getCutAddress() + " nicht verarbeiten");
							manager.sendPacket(new SPacketDisconnect(e.getMessage()), new GenericFutureListener<Future<? super Void>>() {
								public void operationComplete(Future<? super Void> future) throws Exception {
									manager.closeChannel("Fehlerhaftes Datenpaket");
								}
							});
							manager.disableAutoRead();
						}
					}
				}
			}
		}
	}

	public Map<String, Position> getWarps() {
		return this.warps;
	}
//	
//	public void start() {
//		this.serverThread.start();
//	}

	private void stopServer() {
		if(!this.stopped) {
			Log.SYSTEM.info("Beende Server");
			this.terminateEndpoint(this.endMessage);
			if(this.started) {
				this.saveAllPlayerData(true);
				this.saveAllWorlds(true);
				Region.finishWrite();
			}
		}
	}

	public void bind(int port) {
		synchronized(this.serverThread) {
			if(port >= 0) {
				try {
					if(this.endpoint != null)
						this.terminateEndpoint("Wechsele auf Port " + port);
						// throw new IllegalStateException("Eingangspunkt bereits gesetzt");
					Log.NETWORK.info("Öffne Port %d auf 0.0.0.0 (Timeout %ds)", port, Config.timeout);
					this.endpoint = ((ServerBootstrap)((ServerBootstrap)(new ServerBootstrap()).channel(NioServerSocketChannel.class)).childHandler(new ChannelInitializer<Channel>() {
						protected void initChannel(Channel channel) throws Exception {
							try {
								channel.config().setOption(ChannelOption.TCP_NODELAY, Boolean.valueOf(true));
							}
							catch(ChannelException e) {
							}
							channel.pipeline().addLast((String)"timeout", (ChannelHandler)(new ReadTimeoutHandler(Config.timeout)))
									.addLast((String)"splitter", (ChannelHandler)(new PacketSplitter()))
									.addLast((String)"decoder", (ChannelHandler)(new PacketDecoder(true)))
									.addLast((String)"prepender", (ChannelHandler)(new PacketPrepender()))
									.addLast((String)"encoder", (ChannelHandler)(new PacketEncoder(false)));
							NetConnection manager = new NetConnection();
							Server.this.clients.add(manager);
							channel.pipeline().addLast((String)"packet_handler", (ChannelHandler)manager);
							manager.setNetHandler(new HandshakeHandler(Server.this, manager));
						}
					}).group(SERVER_NIO_EVENTLOOP.getValue()).localAddress((InetAddress)null, port)).bind().syncUninterruptibly();
				}
				catch(Throwable e) {
					Log.NETWORK.error(e, "**** KONNTE NICHT AN PORT " + port + " ANBINDEN!");
				}
			}
			else {
				if(this.endpoint != null)
					this.terminateEndpoint("Trenne Verbindung");
			}
		}
	}

	public void shutdown(String message) {
		this.running = false;
		this.endMessage = message;
	}
	
	public String getInfo() {
		return String.format("Server: %.3f T/s (%.1fx), Z: %.1f T/s, D: %.3f ms", this.getTpsRate(), this.getTpsRate() / 20.0f, this.getTpsTarget(), this.getAverageTps()) + "\n" + 
    		"Geladen: " + this.getWorlds().size() + " Welten, " + WorldServer.getLoadedInfo(this);
	}
	
	public void logConsole(String message) {
		Log.CONSOLE.info(message);
	}

	public PublicKey getPublicKey() {
		return this.keyPair.getPublic();
	}

	public PrivateKey getPrivateKey() {
		return this.keyPair.getPrivate();
	}
}