L2J_Mobius_Test/java/com/l2jmobius/commons/database/DatabaseFactory.java

@@ -0,0 +1,135 @@
+/*
+ * This file is part of the L2J Mobius project.
+ * 
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.l2jmobius.commons.database;
+
+import java.beans.PropertyVetoException;
+import java.sql.Connection;
+import java.sql.SQLException;
+import java.util.logging.Logger;
+
+import com.l2jmobius.Config;
+import com.mchange.v2.c3p0.ComboPooledDataSource;
+
+/**
+ * Database Factory implementation.
+ * @author Zoey76
+ */
+public class DatabaseFactory
+{
+	private static final Logger _log = Logger.getLogger(DatabaseFactory.class.getName());
+	
+	private final ComboPooledDataSource _dataSource;
+	
+	public DatabaseFactory()
+	{
+		if (Config.DATABASE_MAX_CONNECTIONS < 2)
+		{
+			Config.DATABASE_MAX_CONNECTIONS = 2;
+			_log.warning("A minimum of 2 connections are required.");
+		}
+		
+		_dataSource = new ComboPooledDataSource();
+		_dataSource.setAutoCommitOnClose(true);
+		
+		_dataSource.setInitialPoolSize(10);
+		_dataSource.setMinPoolSize(10);
+		_dataSource.setMaxPoolSize(Math.max(10, Config.DATABASE_MAX_CONNECTIONS));
+		
+		_dataSource.setAcquireRetryAttempts(0); // try to obtain connections indefinitely (0 = never quit)
+		_dataSource.setAcquireRetryDelay(500); // 500 milliseconds wait before try to acquire connection again
+		_dataSource.setCheckoutTimeout(0); // 0 = wait indefinitely for new connection if pool is exhausted
+		_dataSource.setAcquireIncrement(5); // if pool is exhausted, get 5 more connections at a time cause there is
+		// a "long" delay on acquire connection so taking more than one connection at once will make connection pooling more effective.
+		
+		// this "connection_test_table" is automatically created if not already there
+		_dataSource.setAutomaticTestTable("connection_test_table");
+		_dataSource.setTestConnectionOnCheckin(false);
+		
+		// testing OnCheckin used with IdleConnectionTestPeriod is faster than testing on checkout
+		
+		_dataSource.setIdleConnectionTestPeriod(3600); // test idle connection every 60 sec
+		_dataSource.setMaxIdleTime(Config.DATABASE_MAX_IDLE_TIME); // 0 = idle connections never expire
+		// *THANKS* to connection testing configured above but I prefer to disconnect all connections not used for more than 1 hour
+		
+		// enables statement caching, there is a "semi-bug" in c3p0 0.9.0 but in 0.9.0.2 and later it's fixed
+		_dataSource.setMaxStatementsPerConnection(100);
+		
+		_dataSource.setBreakAfterAcquireFailure(false); // never fail if any way possible setting this to true will make c3p0 "crash"
+		// and refuse to work till restart thus making acquire errors "FATAL" ... we don't want that it should be possible to recover
+		
+		try
+		{
+			_dataSource.setDriverClass(Config.DATABASE_DRIVER);
+		}
+		catch (PropertyVetoException e)
+		{
+			e.printStackTrace();
+		}
+		_dataSource.setJdbcUrl(Config.DATABASE_URL);
+		_dataSource.setUser(Config.DATABASE_LOGIN);
+		_dataSource.setPassword(Config.DATABASE_PASSWORD);
+		
+		/* Test the connection */
+		try
+		{
+			_dataSource.getConnection().close();
+		}
+		catch (SQLException e)
+		{
+			e.printStackTrace();
+		}
+	}
+	
+	public Connection getConnection()
+	{
+		Connection con = null;
+		while (con == null)
+		{
+			try
+			{
+				con = _dataSource.getConnection();
+			}
+			catch (SQLException e)
+			{
+				_log.warning(getClass().getSimpleName() + ": Unable to get a connection: " + e.getMessage());
+			}
+		}
+		return con;
+	}
+	
+	public void close()
+	{
+		try
+		{
+			_dataSource.close();
+		}
+		catch (Exception e)
+		{
+			_log.info(e.getMessage());
+		}
+	}
+	
+	public static DatabaseFactory getInstance()
+	{
+		return SingletonHolder.INSTANCE;
+	}
+	
+	private static class SingletonHolder
+	{
+		protected static final DatabaseFactory INSTANCE = new DatabaseFactory();
+	}
+}

L2J_Mobius_Test/java/com/l2jmobius/commons/geodriver/Cell.java

@@ -0,0 +1,48 @@
+/*
+ * This file is part of the L2J Mobius project.
+ * 
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.l2jmobius.commons.geodriver;
+
+/**
+ * @author HorridoJoho
+ */
+public final class Cell
+{
+	/** East NSWE flag */
+	public static final byte NSWE_EAST = 1 << 0;
+	/** West NSWE flag */
+	public static final byte NSWE_WEST = 1 << 1;
+	/** South NSWE flag */
+	public static final byte NSWE_SOUTH = 1 << 2;
+	/** North NSWE flag */
+	public static final byte NSWE_NORTH = 1 << 3;
+	
+	/** North-East NSWE flags */
+	public static final byte NSWE_NORTH_EAST = NSWE_NORTH | NSWE_EAST;
+	/** North-West NSWE flags */
+	public static final byte NSWE_NORTH_WEST = NSWE_NORTH | NSWE_WEST;
+	/** South-East NSWE flags */
+	public static final byte NSWE_SOUTH_EAST = NSWE_SOUTH | NSWE_EAST;
+	/** South-West NSWE flags */
+	public static final byte NSWE_SOUTH_WEST = NSWE_SOUTH | NSWE_WEST;
+	
+	/** All directions NSWE flags */
+	public static final byte NSWE_ALL = NSWE_EAST | NSWE_WEST | NSWE_SOUTH | NSWE_NORTH;
+	
+	private Cell()
+	{
+	}
+}

L2J_Mobius_Test/java/com/l2jmobius/commons/geodriver/GeoDriver.java

@@ -0,0 +1,162 @@
+/*
+ * This file is part of the L2J Mobius project.
+ * 
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.l2jmobius.commons.geodriver;
+
+import java.io.IOException;
+import java.io.RandomAccessFile;
+import java.nio.ByteOrder;
+import java.nio.channels.FileChannel.MapMode;
+import java.nio.file.Path;
+import java.util.concurrent.atomic.AtomicReferenceArray;
+
+import com.l2jmobius.commons.geodriver.regions.NullRegion;
+import com.l2jmobius.commons.geodriver.regions.Region;
+
+/**
+ * @author HorridoJoho
+ */
+public final class GeoDriver
+{
+	// world dimensions: 1048576 * 1048576 = 1099511627776
+	private static final int WORLD_MIN_X = -655360;
+	private static final int WORLD_MAX_X = 393215;
+	private static final int WORLD_MIN_Y = -589824;
+	private static final int WORLD_MAX_Y = 458751;
+	
+	/** Regions in the world on the x axis */
+	public static final int GEO_REGIONS_X = 32;
+	/** Regions in the world on the y axis */
+	public static final int GEO_REGIONS_Y = 32;
+	/** Region in the world */
+	public static final int GEO_REGIONS = GEO_REGIONS_X * GEO_REGIONS_Y;
+	
+	/** Blocks in the world on the x axis */
+	public static final int GEO_BLOCKS_X = GEO_REGIONS_X * IRegion.REGION_BLOCKS_X;
+	/** Blocks in the world on the y axis */
+	public static final int GEO_BLOCKS_Y = GEO_REGIONS_Y * IRegion.REGION_BLOCKS_Y;
+	/** Blocks in the world */
+	public static final int GEO_BLOCKS = GEO_REGIONS * IRegion.REGION_BLOCKS;
+	
+	/** Cells in the world on the x axis */
+	public static final int GEO_CELLS_X = GEO_BLOCKS_X * IBlock.BLOCK_CELLS_X;
+	/** Cells in the world in the y axis */
+	public static final int GEO_CELLS_Y = GEO_BLOCKS_Y * IBlock.BLOCK_CELLS_Y;
+	
+	/** The regions array */
+	private final AtomicReferenceArray<IRegion> _regions = new AtomicReferenceArray<>(GEO_REGIONS);
+	
+	public GeoDriver()
+	{
+		for (int i = 0; i < _regions.length(); i++)
+		{
+			_regions.set(i, NullRegion.INSTANCE);
+		}
+	}
+	
+	private void checkGeoX(int geoX)
+	{
+		if ((geoX < 0) || (geoX >= GEO_CELLS_X))
+		{
+			throw new IllegalArgumentException();
+		}
+	}
+	
+	private void checkGeoY(int geoY)
+	{
+		if ((geoY < 0) || (geoY >= GEO_CELLS_Y))
+		{
+			throw new IllegalArgumentException();
+		}
+	}
+	
+	private IRegion getRegion(int geoX, int geoY)
+	{
+		checkGeoX(geoX);
+		checkGeoY(geoY);
+		return _regions.get(((geoX / IRegion.REGION_CELLS_X) * GEO_REGIONS_Y) + (geoY / IRegion.REGION_CELLS_Y));
+	}
+	
+	public void loadRegion(Path filePath, int regionX, int regionY) throws IOException
+	{
+		final int regionOffset = (regionX * GEO_REGIONS_Y) + regionY;
+		
+		try (RandomAccessFile raf = new RandomAccessFile(filePath.toFile(), "r"))
+		{
+			_regions.set(regionOffset, new Region(raf.getChannel().map(MapMode.READ_ONLY, 0, raf.length()).order(ByteOrder.LITTLE_ENDIAN)));
+		}
+	}
+	
+	public void unloadRegion(int regionX, int regionY)
+	{
+		_regions.set((regionX * GEO_REGIONS_Y) + regionY, NullRegion.INSTANCE);
+	}
+	
+	public boolean hasGeoPos(int geoX, int geoY)
+	{
+		return getRegion(geoX, geoY).hasGeo();
+	}
+	
+	public boolean checkNearestNswe(int geoX, int geoY, int worldZ, int nswe)
+	{
+		return getRegion(geoX, geoY).checkNearestNswe(geoX, geoY, worldZ, nswe);
+	}
+	
+	public int getNearestZ(int geoX, int geoY, int worldZ)
+	{
+		return getRegion(geoX, geoY).getNearestZ(geoX, geoY, worldZ);
+	}
+	
+	public int getNextLowerZ(int geoX, int geoY, int worldZ)
+	{
+		return getRegion(geoX, geoY).getNextLowerZ(geoX, geoY, worldZ);
+	}
+	
+	public int getNextHigherZ(int geoX, int geoY, int worldZ)
+	{
+		return getRegion(geoX, geoY).getNextHigherZ(geoX, geoY, worldZ);
+	}
+	
+	public int getGeoX(int worldX)
+	{
+		if ((worldX < WORLD_MIN_X) || (worldX > WORLD_MAX_X))
+		{
+			throw new IllegalArgumentException();
+		}
+		return (worldX - WORLD_MIN_X) / 16;
+	}
+	
+	public int getGeoY(int worldY)
+	{
+		if ((worldY < WORLD_MIN_Y) || (worldY > WORLD_MAX_Y))
+		{
+			throw new IllegalArgumentException();
+		}
+		return (worldY - WORLD_MIN_Y) / 16;
+	}
+	
+	public int getWorldX(int geoX)
+	{
+		checkGeoX(geoX);
+		return (geoX * 16) + WORLD_MIN_X + 8;
+	}
+	
+	public int getWorldY(int geoY)
+	{
+		checkGeoY(geoY);
+		return (geoY * 16) + WORLD_MIN_Y + 8;
+	}
+}

L2J_Mobius_Test/java/com/l2jmobius/commons/geodriver/IBlock.java

@@ -0,0 +1,42 @@
+/*
+ * This file is part of the L2J Mobius project.
+ * 
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.l2jmobius.commons.geodriver;
+
+/**
+ * @author HorridoJoho
+ */
+public interface IBlock
+{
+	int TYPE_FLAT = 0;
+	int TYPE_COMPLEX = 1;
+	int TYPE_MULTILAYER = 2;
+	
+	/** Cells in a block on the x axis */
+	int BLOCK_CELLS_X = 8;
+	/** Cells in a block on the y axis */
+	int BLOCK_CELLS_Y = 8;
+	/** Cells in a block */
+	int BLOCK_CELLS = BLOCK_CELLS_X * BLOCK_CELLS_Y;
+	
+	boolean checkNearestNswe(int geoX, int geoY, int worldZ, int nswe);
+	
+	int getNearestZ(int geoX, int geoY, int worldZ);
+	
+	int getNextLowerZ(int geoX, int geoY, int worldZ);
+	
+	int getNextHigherZ(int geoX, int geoY, int worldZ);
+}

L2J_Mobius_Test/java/com/l2jmobius/commons/geodriver/IRegion.java

@@ -0,0 +1,47 @@
+/*
+ * This file is part of the L2J Mobius project.
+ * 
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.l2jmobius.commons.geodriver;
+
+/**
+ * @author HorridoJoho
+ */
+public interface IRegion
+{
+	/** Blocks in a region on the x axis. */
+	int REGION_BLOCKS_X = 256;
+	/** Blocks in a region on the y axis. */
+	int REGION_BLOCKS_Y = 256;
+	/** Blocks in a region. */
+	int REGION_BLOCKS = REGION_BLOCKS_X * REGION_BLOCKS_Y;
+	
+	/** Cells in a region on the x axis. */
+	int REGION_CELLS_X = REGION_BLOCKS_X * IBlock.BLOCK_CELLS_X;
+	/** Cells in a regioin on the y axis. */
+	int REGION_CELLS_Y = REGION_BLOCKS_Y * IBlock.BLOCK_CELLS_Y;
+	/** Cells in a region. */
+	int REGION_CELLS = REGION_CELLS_X * REGION_CELLS_Y;
+	
+	boolean checkNearestNswe(int geoX, int geoY, int worldZ, int nswe);
+	
+	int getNearestZ(int geoX, int geoY, int worldZ);
+	
+	int getNextLowerZ(int geoX, int geoY, int worldZ);
+	
+	int getNextHigherZ(int geoX, int geoY, int worldZ);
+	
+	boolean hasGeo();
+}

L2J_Mobius_Test/java/com/l2jmobius/commons/geodriver/blocks/ComplexBlock.java

@@ -0,0 +1,79 @@
+/*
+ * This file is part of the L2J Mobius project.
+ * 
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.l2jmobius.commons.geodriver.blocks;
+
+import java.nio.ByteBuffer;
+
+import com.l2jmobius.commons.geodriver.IBlock;
+
+/**
+ * @author HorridoJoho
+ */
+public final class ComplexBlock implements IBlock
+{
+	private final short[] _data;
+	
+	public ComplexBlock(ByteBuffer bb)
+	{
+		_data = new short[IBlock.BLOCK_CELLS];
+		for (int cellOffset = 0; cellOffset < IBlock.BLOCK_CELLS; cellOffset++)
+		{
+			_data[cellOffset] = bb.getShort();
+		}
+	}
+	
+	private short _getCellData(int geoX, int geoY)
+	{
+		return _data[((geoX % IBlock.BLOCK_CELLS_X) * IBlock.BLOCK_CELLS_Y) + (geoY % IBlock.BLOCK_CELLS_Y)];
+	}
+	
+	private byte _getCellNSWE(int geoX, int geoY)
+	{
+		return (byte) (_getCellData(geoX, geoY) & 0x000F);
+	}
+	
+	private int _getCellHeight(int geoX, int geoY)
+	{
+		return (short) (_getCellData(geoX, geoY) & 0x0FFF0) >> 1;
+	}
+	
+	@Override
+	public boolean checkNearestNswe(int geoX, int geoY, int worldZ, int nswe)
+	{
+		return (_getCellNSWE(geoX, geoY) & nswe) == nswe;
+	}
+	
+	@Override
+	public int getNearestZ(int geoX, int geoY, int worldZ)
+	{
+		return _getCellHeight(geoX, geoY);
+	}
+	
+	@Override
+	public int getNextLowerZ(int geoX, int geoY, int worldZ)
+	{
+		final int cellHeight = _getCellHeight(geoX, geoY);
+		return cellHeight <= worldZ ? cellHeight : worldZ;
+	}
+	
+	@Override
+	public int getNextHigherZ(int geoX, int geoY, int worldZ)
+	{
+		final int cellHeight = _getCellHeight(geoX, geoY);
+		return cellHeight >= worldZ ? cellHeight : worldZ;
+	}
+}

L2J_Mobius_Test/java/com/l2jmobius/commons/geodriver/blocks/FlatBlock.java

@@ -0,0 +1,58 @@
+/*
+ * This file is part of the L2J Mobius project.
+ * 
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.l2jmobius.commons.geodriver.blocks;
+
+import java.nio.ByteBuffer;
+
+import com.l2jmobius.commons.geodriver.IBlock;
+
+/**
+ * @author HorridoJoho
+ */
+public class FlatBlock implements IBlock
+{
+	private final short _height;
+	
+	public FlatBlock(ByteBuffer bb)
+	{
+		_height = bb.getShort();
+	}
+	
+	@Override
+	public boolean checkNearestNswe(int geoX, int geoY, int worldZ, int nswe)
+	{
+		return true;
+	}
+	
+	@Override
+	public int getNearestZ(int geoX, int geoY, int worldZ)
+	{
+		return _height;
+	}
+	
+	@Override
+	public int getNextLowerZ(int geoX, int geoY, int worldZ)
+	{
+		return _height <= worldZ ? _height : worldZ;
+	}
+	
+	@Override
+	public int getNextHigherZ(int geoX, int geoY, int worldZ)
+	{
+		return _height >= worldZ ? _height : worldZ;
+	}
+}

L2J_Mobius_Test/java/com/l2jmobius/commons/geodriver/blocks/MultilayerBlock.java

@@ -0,0 +1,186 @@
+/*
+ * This file is part of the L2J Mobius project.
+ * 
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.l2jmobius.commons.geodriver.blocks;
+
+import java.nio.ByteBuffer;
+
+import com.l2jmobius.commons.geodriver.IBlock;
+
+/**
+ * @author HorridoJoho
+ */
+public class MultilayerBlock implements IBlock
+{
+	private final byte[] _data;
+	
+	/**
+	 * Initializes a new instance of this block reading the specified buffer.
+	 * @param bb the buffer
+	 */
+	public MultilayerBlock(ByteBuffer bb)
+	{
+		final int start = bb.position();
+		
+		for (int blockCellOffset = 0; blockCellOffset < IBlock.BLOCK_CELLS; blockCellOffset++)
+		{
+			final byte nLayers = bb.get();
+			if ((nLayers <= 0) || (nLayers > 125))
+			{
+				throw new RuntimeException("L2JGeoDriver: Geo file corrupted! Invalid layers count!");
+			}
+			
+			bb.position(bb.position() + (nLayers * 2));
+		}
+		
+		_data = new byte[bb.position() - start];
+		bb.position(start);
+		bb.get(_data);
+	}
+	
+	private short _getNearestLayer(int geoX, int geoY, int worldZ)
+	{
+		final int startOffset = _getCellDataOffset(geoX, geoY);
+		final byte nLayers = _data[startOffset];
+		final int endOffset = startOffset + 1 + (nLayers * 2);
+		
+		// 1 layer at least was required on loading so this is set at least once on the loop below
+		int nearestDZ = 0;
+		short nearestData = 0;
+		for (int offset = startOffset + 1; offset < endOffset; offset += 2)
+		{
+			final short layerData = _extractLayerData(offset);
+			final int layerZ = _extractLayerHeight(layerData);
+			if (layerZ == worldZ)
+			{
+				// exact z
+				return layerData;
+			}
+			
+			final int layerDZ = Math.abs(layerZ - worldZ);
+			if ((offset == (startOffset + 1)) || (layerDZ < nearestDZ))
+			{
+				nearestDZ = layerDZ;
+				nearestData = layerData;
+			}
+		}
+		
+		return nearestData;
+	}
+	
+	private int _getCellDataOffset(int geoX, int geoY)
+	{
+		final int cellLocalOffset = ((geoX % IBlock.BLOCK_CELLS_X) * IBlock.BLOCK_CELLS_Y) + (geoY % IBlock.BLOCK_CELLS_Y);
+		int cellDataOffset = 0;
+		// move index to cell, we need to parse on each request, OR we parse on creation and save indexes
+		for (int i = 0; i < cellLocalOffset; i++)
+		{
+			cellDataOffset += 1 + (_data[cellDataOffset] * 2);
+		}
+		// now the index points to the cell we need
+		
+		return cellDataOffset;
+	}
+	
+	private short _extractLayerData(int dataOffset)
+	{
+		return (short) ((_data[dataOffset] & 0xFF) | (_data[dataOffset + 1] << 8));
+	}
+	
+	private int _getNearestNSWE(int geoX, int geoY, int worldZ)
+	{
+		return _extractLayerNswe(_getNearestLayer(geoX, geoY, worldZ));
+	}
+	
+	private int _extractLayerNswe(short layer)
+	{
+		return (byte) (layer & 0x000F);
+	}
+	
+	private int _extractLayerHeight(short layer)
+	{
+		layer = (short) (layer & 0x0fff0);
+		return layer >> 1;
+	}
+	
+	@Override
+	public boolean checkNearestNswe(int geoX, int geoY, int worldZ, int nswe)
+	{
+		return (_getNearestNSWE(geoX, geoY, worldZ) & nswe) == nswe;
+	}
+	
+	@Override
+	public int getNearestZ(int geoX, int geoY, int worldZ)
+	{
+		return _extractLayerHeight(_getNearestLayer(geoX, geoY, worldZ));
+	}
+	
+	@Override
+	public int getNextLowerZ(int geoX, int geoY, int worldZ)
+	{
+		final int startOffset = _getCellDataOffset(geoX, geoY);
+		final byte nLayers = _data[startOffset];
+		final int endOffset = startOffset + 1 + (nLayers * 2);
+		
+		int lowerZ = Integer.MIN_VALUE;
+		for (int offset = startOffset + 1; offset < endOffset; offset += 2)
+		{
+			final short layerData = _extractLayerData(offset);
+			
+			final int layerZ = _extractLayerHeight(layerData);
+			if (layerZ == worldZ)
+			{
+				// exact z
+				return layerZ;
+			}
+			
+			if ((layerZ < worldZ) && (layerZ > lowerZ))
+			{
+				lowerZ = layerZ;
+			}
+		}
+		
+		return lowerZ == Integer.MIN_VALUE ? worldZ : lowerZ;
+	}
+	
+	@Override
+	public int getNextHigherZ(int geoX, int geoY, int worldZ)
+	{
+		final int startOffset = _getCellDataOffset(geoX, geoY);
+		final byte nLayers = _data[startOffset];
+		final int endOffset = startOffset + 1 + (nLayers * 2);
+		
+		int higherZ = Integer.MAX_VALUE;
+		for (int offset = startOffset + 1; offset < endOffset; offset += 2)
+		{
+			final short layerData = _extractLayerData(offset);
+			
+			final int layerZ = _extractLayerHeight(layerData);
+			if (layerZ == worldZ)
+			{
+				// exact z
+				return layerZ;
+			}
+			
+			if ((layerZ > worldZ) && (layerZ < higherZ))
+			{
+				higherZ = layerZ;
+			}
+		}
+		
+		return higherZ == Integer.MAX_VALUE ? worldZ : higherZ;
+	}
+}

L2J_Mobius_Test/java/com/l2jmobius/commons/geodriver/regions/NullRegion.java

@@ -0,0 +1,57 @@
+/*
+ * This file is part of the L2J Mobius project.
+ * 
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.l2jmobius.commons.geodriver.regions;
+
+import com.l2jmobius.commons.geodriver.IRegion;
+
+/**
+ * @author HorridoJoho
+ */
+public final class NullRegion implements IRegion
+{
+	public static final NullRegion INSTANCE = new NullRegion();
+	
+	@Override
+	public boolean checkNearestNswe(int geoX, int geoY, int worldZ, int nswe)
+	{
+		return true;
+	}
+	
+	@Override
+	public int getNearestZ(int geoX, int geoY, int worldZ)
+	{
+		return worldZ;
+	}
+	
+	@Override
+	public int getNextLowerZ(int geoX, int geoY, int worldZ)
+	{
+		return worldZ;
+	}
+	
+	@Override
+	public int getNextHigherZ(int geoX, int geoY, int worldZ)
+	{
+		return worldZ;
+	}
+	
+	@Override
+	public boolean hasGeo()
+	{
+		return false;
+	}
+}

L2J_Mobius_Test/java/com/l2jmobius/commons/geodriver/regions/Region.java

@@ -0,0 +1,98 @@
+/*
+ * This file is part of the L2J Mobius project.
+ * 
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.l2jmobius.commons.geodriver.regions;
+
+import java.nio.ByteBuffer;
+
+import com.l2jmobius.commons.geodriver.IBlock;
+import com.l2jmobius.commons.geodriver.IRegion;
+import com.l2jmobius.commons.geodriver.blocks.ComplexBlock;
+import com.l2jmobius.commons.geodriver.blocks.FlatBlock;
+import com.l2jmobius.commons.geodriver.blocks.MultilayerBlock;
+
+/**
+ * @author HorridoJoho
+ */
+public final class Region implements IRegion
+{
+	private final IBlock[] _blocks = new IBlock[IRegion.REGION_BLOCKS];
+	
+	public Region(ByteBuffer bb)
+	{
+		for (int blockOffset = 0; blockOffset < IRegion.REGION_BLOCKS; blockOffset++)
+		{
+			final int blockType = bb.get();
+			switch (blockType)
+			{
+				case IBlock.TYPE_FLAT:
+				{
+					_blocks[blockOffset] = new FlatBlock(bb);
+					break;
+				}
+				case IBlock.TYPE_COMPLEX:
+				{
+					_blocks[blockOffset] = new ComplexBlock(bb);
+					break;
+				}
+				case IBlock.TYPE_MULTILAYER:
+				{
+					_blocks[blockOffset] = new MultilayerBlock(bb);
+					break;
+				}
+				default:
+				{
+					throw new RuntimeException("Invalid block type " + blockType + "!");
+				}
+			}
+		}
+	}
+	
+	private IBlock getBlock(int geoX, int geoY)
+	{
+		return _blocks[(((geoX / IBlock.BLOCK_CELLS_X) % IRegion.REGION_BLOCKS_X) * IRegion.REGION_BLOCKS_Y) + ((geoY / IBlock.BLOCK_CELLS_Y) % IRegion.REGION_BLOCKS_Y)];
+	}
+	
+	@Override
+	public boolean checkNearestNswe(int geoX, int geoY, int worldZ, int nswe)
+	{
+		return getBlock(geoX, geoY).checkNearestNswe(geoX, geoY, worldZ, nswe);
+	}
+	
+	@Override
+	public int getNearestZ(int geoX, int geoY, int worldZ)
+	{
+		return getBlock(geoX, geoY).getNearestZ(geoX, geoY, worldZ);
+	}
+	
+	@Override
+	public int getNextLowerZ(int geoX, int geoY, int worldZ)
+	{
+		return getBlock(geoX, geoY).getNextLowerZ(geoX, geoY, worldZ);
+	}
+	
+	@Override
+	public int getNextHigherZ(int geoX, int geoY, int worldZ)
+	{
+		return getBlock(geoX, geoY).getNextHigherZ(geoX, geoY, worldZ);
+	}
+	
+	@Override
+	public boolean hasGeo()
+	{
+		return true;
+	}
+}

L2J_Mobius_Test/java/com/l2jmobius/commons/javaengine/CompilationException.java

@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2006 Sun Microsystems, Inc. All rights reserved. 
+ * Use is subject to license terms.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are 
+ * permitted provided that the following conditions are met: Redistributions of source code 
+ * must retain the above copyright notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice, this list of 
+ * conditions and the following disclaimer in the documentation and/or other materials 
+ * provided with the distribution. Neither the name of the Sun Microsystems nor the names of 
+ * is contributors may be used to endorse or promote products derived from this software 
+ * without specific prior written permission. 
+
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY 
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER 
+ * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON 
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+package com.l2jmobius.commons.javaengine;
+
+public class CompilationException extends Exception
+{
+	public CompilationException(String message)
+	{
+		super(message);
+	}
+}

L2J_Mobius_Test/java/com/l2jmobius/commons/javaengine/JavaCompiler.java

@@ -0,0 +1,124 @@
+/*
+ * Copyright (C) 2006 Sun Microsystems, Inc. All rights reserved. 
+ * Use is subject to license terms.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are 
+ * permitted provided that the following conditions are met: Redistributions of source code 
+ * must retain the above copyright notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice, this list of 
+ * conditions and the following disclaimer in the documentation and/or other materials 
+ * provided with the distribution. Neither the name of the Sun Microsystems nor the names of 
+ * is contributors may be used to endorse or promote products derived from this software 
+ * without specific prior written permission. 
+
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY 
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER 
+ * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON 
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+package com.l2jmobius.commons.javaengine;
+
+import java.io.PrintWriter;
+import java.io.Writer;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+
+import javax.tools.Diagnostic;
+import javax.tools.DiagnosticCollector;
+import javax.tools.JavaCompiler.CompilationTask;
+import javax.tools.JavaFileObject;
+
+import org.eclipse.jdt.internal.compiler.tool.EclipseCompiler;
+
+/**
+ * Simple interface to Java compiler using JSR 199 Compiler API.
+ * @author A. Sundararajan
+ */
+public class JavaCompiler
+{
+	private final javax.tools.JavaCompiler tool;
+	
+	public JavaCompiler()
+	{
+		tool = new EclipseCompiler();
+	}
+	
+	public Map<String, byte[]> compile(String source, String fileName)
+	{
+		return compile(source, fileName, new PrintWriter(System.err), null, null);
+	}
+	
+	public Map<String, byte[]> compile(String fileName, String source, Writer err)
+	{
+		return compile(fileName, source, err, null, null);
+	}
+	
+	public Map<String, byte[]> compile(String fileName, String source, Writer err, String sourcePath)
+	{
+		return compile(fileName, source, err, sourcePath, null);
+	}
+	
+	/**
+	 * compile given String source and return bytecodes as a Map.
+	 * @param fileName source fileName to be used for error messages etc.
+	 * @param source Java source as String
+	 * @param err error writer where diagnostic messages are written
+	 * @param sourcePath location of additional .java source files
+	 * @param classPath location of additional .class files
+	 * @return
+	 */
+	public Map<String, byte[]> compile(String fileName, String source, Writer err, String sourcePath, String classPath)
+	{
+		// to collect errors, warnings etc.
+		final DiagnosticCollector<JavaFileObject> diagnostics = new DiagnosticCollector<>();
+		
+		// create a new memory JavaFileManager
+		final MemoryJavaFileManager manager = new MemoryJavaFileManager();
+		
+		// prepare the compilation unit
+		final List<JavaFileObject> compUnits = new ArrayList<>(1);
+		compUnits.add(MemoryJavaFileManager.makeStringSource(fileName, source));
+		
+		// javac options
+		final List<String> options = new ArrayList<>();
+		options.add("-warn:-enumSwitch");
+		options.add("-g");
+		options.add("-deprecation");
+		options.add("-1.8");
+		if (sourcePath != null)
+		{
+			options.add("-sourcepath");
+			options.add(sourcePath);
+		}
+		if (classPath != null)
+		{
+			options.add("-classpath");
+			options.add(classPath);
+		}
+		
+		// create a compilation task
+		final CompilationTask task = tool.getTask(err, manager, diagnostics, options, null, compUnits);
+		
+		if (!task.call())
+		{
+			final PrintWriter perr = new PrintWriter(err);
+			for (Diagnostic<?> diagnostic : diagnostics.getDiagnostics())
+			{
+				perr.println(diagnostic.getMessage(Locale.getDefault()));
+			}
+			perr.flush();
+			return null;
+		}
+		
+		final Map<String, byte[]> classBytes = manager.getClassBytes();
+		manager.close();
+		return classBytes;
+	}
+}

L2J_Mobius_Test/java/com/l2jmobius/commons/javaengine/JavaScriptEngine.java

@@ -0,0 +1,447 @@
+/*
+ * Copyright (C) 2006 Sun Microsystems, Inc. All rights reserved. 
+ * Use is subject to license terms.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are 
+ * permitted provided that the following conditions are met: Redistributions of source code 
+ * must retain the above copyright notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice, this list of 
+ * conditions and the following disclaimer in the documentation and/or other materials 
+ * provided with the distribution. Neither the name of the Sun Microsystems nor the names of 
+ * is contributors may be used to endorse or promote products derived from this software 
+ * without specific prior written permission. 
+
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY 
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER 
+ * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON 
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+package com.l2jmobius.commons.javaengine;
+
+import java.io.IOException;
+import java.io.Reader;
+import java.io.Serializable;
+import java.io.StringWriter;
+import java.io.Writer;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+
+import javax.script.AbstractScriptEngine;
+import javax.script.Bindings;
+import javax.script.Compilable;
+import javax.script.CompiledScript;
+import javax.script.ScriptContext;
+import javax.script.ScriptEngine;
+import javax.script.ScriptEngineFactory;
+import javax.script.ScriptException;
+import javax.script.SimpleBindings;
+
+/**
+ * This is script engine for Java programming language.
+ * @author A. Sundararajan
+ */
+public class JavaScriptEngine extends AbstractScriptEngine implements Compilable
+{
+	// Java compiler
+	private final JavaCompiler compiler;
+	
+	public JavaScriptEngine()
+	{
+		compiler = new JavaCompiler();
+	}
+	
+	// my factory, may be null
+	private ScriptEngineFactory factory;
+	
+	// my implementation for CompiledScript
+	private static class JavaCompiledScript extends CompiledScript implements Serializable
+	{
+		private final transient JavaScriptEngine _engine;
+		private transient Class<?> _class;
+		private final Map<String, byte[]> _classBytes;
+		private final String _classPath;
+		
+		JavaCompiledScript(JavaScriptEngine engine, Map<String, byte[]> classBytes, String classPath)
+		{
+			_engine = engine;
+			_classBytes = classBytes;
+			_classPath = classPath;
+		}
+		
+		@Override
+		public ScriptEngine getEngine()
+		{
+			return _engine;
+		}
+		
+		@Override
+		public Object eval(ScriptContext ctx) throws ScriptException
+		{
+			if (_class == null)
+			{
+				final Map<String, byte[]> classBytesCopy = new HashMap<>();
+				classBytesCopy.putAll(_classBytes);
+				_class = JavaScriptEngine.parseMain(new MemoryClassLoader(classBytesCopy, _classPath, JavaScriptEngine.getParentLoader(ctx)), ctx);
+			}
+			return JavaScriptEngine.evalClass(_class, ctx);
+		}
+	}
+	
+	@Override
+	public CompiledScript compile(String script) throws ScriptException
+	{
+		return compile(script, context);
+	}
+	
+	@Override
+	public CompiledScript compile(Reader reader) throws ScriptException
+	{
+		return compile(readFully(reader));
+	}
+	
+	@Override
+	public Object eval(String str, ScriptContext ctx) throws ScriptException
+	{
+		return evalClass(parse(str, ctx), ctx);
+	}
+	
+	@Override
+	public Object eval(Reader reader, ScriptContext ctx) throws ScriptException
+	{
+		return eval(readFully(reader), ctx);
+	}
+	
+	@Override
+	public ScriptEngineFactory getFactory()
+	{
+		synchronized (this)
+		{
+			if (factory == null)
+			{
+				factory = new JavaScriptEngineFactory();
+			}
+		}
+		return factory;
+	}
+	
+	@Override
+	public Bindings createBindings()
+	{
+		return new SimpleBindings();
+	}
+	
+	void setFactory(ScriptEngineFactory factory)
+	{
+		this.factory = factory;
+	}
+	
+	// Internals only below this point
+	
+	private Class<?> parse(String str, ScriptContext ctx) throws ScriptException
+	{
+		final String fileName = getFileName(ctx);
+		final String sourcePath = getSourcePath(ctx);
+		final String classPath = getClassPath(ctx);
+		
+		final Writer err = ctx.getErrorWriter() == null ? new StringWriter() : ctx.getErrorWriter();
+		
+		final Map<String, byte[]> classBytes = compiler.compile(fileName, str, err, sourcePath, classPath);
+		
+		if (classBytes == null)
+		{
+			throw err instanceof StringWriter ? new ScriptException(((StringWriter) err).toString()) : new ScriptException("compilation failed");
+		}
+		
+		// create a ClassLoader to load classes from MemoryJavaFileManager
+		return parseMain(new MemoryClassLoader(classBytes, classPath, getParentLoader(ctx)), ctx);
+	}
+	
+	protected static Class<?> parseMain(MemoryClassLoader loader, ScriptContext ctx) throws ScriptException
+	{
+		final String mainClassName = getMainClassName(ctx);
+		if (mainClassName != null)
+		{
+			try
+			{
+				final Class<?> clazz = loader.load(mainClassName);
+				final Method mainMethod = findMainMethod(clazz);
+				if (mainMethod == null)
+				{
+					throw new ScriptException("no main method in " + mainClassName);
+				}
+				return clazz;
+			}
+			catch (ClassNotFoundException cnfe)
+			{
+				cnfe.printStackTrace();
+				throw new ScriptException(cnfe);
+			}
+		}
+		
+		// no main class configured - load all compiled classes
+		Iterable<Class<?>> classes;
+		try
+		{
+			classes = loader.loadAll();
+		}
+		catch (ClassNotFoundException exp)
+		{
+			throw new ScriptException(exp);
+		}
+		
+		// search for class with main method
+		final Class<?> c = findMainClass(classes);
+		if (c != null)
+		{
+			return c;
+		}
+		
+		// if class with "main" method, then
+		// return first class
+		final Iterator<Class<?>> itr = classes.iterator();
+		return itr.hasNext() ? itr.next() : null;
+	}
+	
+	private JavaCompiledScript compile(String str, ScriptContext ctx) throws ScriptException
+	{
+		final String fileName = getFileName(ctx);
+		final String sourcePath = getSourcePath(ctx);
+		final String classPath = getClassPath(ctx);
+		
+		final Writer err = ctx.getErrorWriter() == null ? new StringWriter() : ctx.getErrorWriter();
+		final Map<String, byte[]> classBytes = compiler.compile(fileName, str, err, sourcePath, classPath);
+		if (classBytes == null)
+		{
+			throw err instanceof StringWriter ? new ScriptException(((StringWriter) err).toString()) : new ScriptException("compilation failed");
+		}
+		
+		return new JavaCompiledScript(this, classBytes, classPath);
+	}
+	
+	private static Class<?> findMainClass(Iterable<Class<?>> classes)
+	{
+		// find a public class with public static main method
+		for (Class<?> clazz : classes)
+		{
+			if (Modifier.isPublic(clazz.getModifiers()) && (findMainMethod(clazz) != null))
+			{
+				return clazz;
+			}
+		}
+		
+		// okay, try to find package private class that
+		// has public static main method
+		for (Class<?> clazz : classes)
+		{
+			if (findMainMethod(clazz) != null)
+			{
+				return clazz;
+			}
+		}
+		
+		// no main class found!
+		return null;
+	}
+	
+	// find public static void main(String[]) method, if any
+	private static Method findMainMethod(Class<?> clazz)
+	{
+		try
+		{
+			final Method mainMethod = clazz.getMethod("main", new Class[]
+			{
+				String[].class
+			});
+			final int modifiers = mainMethod.getModifiers();
+			if (Modifier.isPublic(modifiers) && Modifier.isStatic(modifiers))
+			{
+				return mainMethod;
+			}
+		}
+		catch (NoSuchMethodException nsme)
+		{
+		}
+		return null;
+	}
+	
+	// find public static void setScriptContext(ScriptContext) method, if any
+	private static Method findSetScriptContextMethod(Class<?> clazz)
+	{
+		try
+		{
+			final Method setCtxMethod = clazz.getMethod("setScriptContext", new Class[]
+			{
+				ScriptContext.class
+			});
+			final int modifiers = setCtxMethod.getModifiers();
+			if (Modifier.isPublic(modifiers) && Modifier.isStatic(modifiers))
+			{
+				return setCtxMethod;
+			}
+		}
+		catch (NoSuchMethodException nsme)
+		{
+		}
+		return null;
+	}
+	
+	private static String getFileName(ScriptContext ctx)
+	{
+		final int scope = ctx.getAttributesScope("javax.script.filename");
+		return scope != -1 ? ctx.getAttribute("javax.script.filename", scope).toString() : "$unnamed.java";
+	}
+	
+	// for certain variables, we look for System properties. This is
+	// the prefix used for such System properties
+	private static final String SYSPROP_PREFIX = "com.sun.script.java.";
+	
+	private static final String[] EMPTY_STRING_ARRAY = new String[0];
+	private static final String ARGUMENTS = "arguments";
+	
+	private static String[] getArguments(ScriptContext ctx)
+	{
+		final int scope = ctx.getAttributesScope(ARGUMENTS);
+		if (scope != -1)
+		{
+			final Object obj = ctx.getAttribute(ARGUMENTS, scope);
+			if (obj instanceof String[])
+			{
+				return (String[]) obj;
+			}
+		}
+		// return zero length array
+		return EMPTY_STRING_ARRAY;
+	}
+	
+	private static final String SOURCEPATH = "sourcepath";
+	
+	private static String getSourcePath(ScriptContext ctx)
+	{
+		return ctx.getAttributesScope(SOURCEPATH) != -1 ? ctx.getAttribute(SOURCEPATH).toString() : System.getProperty(SYSPROP_PREFIX + SOURCEPATH);
+	}
+	
+	private static final String CLASSPATH = "classpath";
+	
+	private static String getClassPath(ScriptContext ctx)
+	{
+		final int scope = ctx.getAttributesScope(CLASSPATH);
+		if (scope != -1)
+		{
+			return ctx.getAttribute(CLASSPATH).toString();
+		}
+		
+		// look for "com.sun.script.java.classpath"
+		String res = System.getProperty(SYSPROP_PREFIX + CLASSPATH);
+		if (res == null)
+		{
+			res = System.getProperty("java.class.path");
+		}
+		return res;
+	}
+	
+	private static final String MAINCLASS = "mainClass";
+	
+	private static String getMainClassName(ScriptContext ctx)
+	{
+		return ctx.getAttributesScope(MAINCLASS) != -1 ? ctx.getAttribute(MAINCLASS).toString() : System.getProperty("com.sun.script.java.mainClass");
+	}
+	
+	private static final String PARENTLOADER = "parentLoader";
+	
+	protected static ClassLoader getParentLoader(ScriptContext ctx)
+	{
+		final int scope = ctx.getAttributesScope(PARENTLOADER);
+		if (scope != -1)
+		{
+			final Object loader = ctx.getAttribute(PARENTLOADER);
+			if (loader instanceof ClassLoader)
+			{
+				return (ClassLoader) loader;
+			}
+		}
+		return ClassLoader.getSystemClassLoader();
+	}
+	
+	protected static Object evalClass(Class<?> clazz, ScriptContext ctx) throws ScriptException
+	{
+		// JSR-223 requirement
+		ctx.setAttribute("context", ctx, 100);
+		if (clazz == null)
+		{
+			return null;
+		}
+		try
+		{
+			final boolean isPublicClazz = Modifier.isPublic(clazz.getModifiers());
+			
+			// find the setScriptContext method
+			final Method setCtxMethod = findSetScriptContextMethod(clazz);
+			// call setScriptContext and pass current ctx variable
+			if (setCtxMethod != null)
+			{
+				if (!isPublicClazz)
+				{
+					// try to relax access
+					setCtxMethod.setAccessible(true);
+				}
+				setCtxMethod.invoke(null, new Object[]
+				{
+					ctx
+				});
+			}
+			
+			// find the main method
+			final Method mainMethod = findMainMethod(clazz);
+			if (mainMethod != null)
+			{
+				if (!isPublicClazz)
+				{
+					// try to relax access
+					mainMethod.setAccessible(true);
+				}
+				
+				// call main method
+				mainMethod.invoke(null, new Object[]
+				{
+					getArguments(ctx)
+				});
+			}
+			
+			// return main class as eval's result
+			return clazz;
+		}
+		catch (Exception exp)
+		{
+			exp.printStackTrace();
+			throw new ScriptException(exp);
+		}
+	}
+	
+	// read a Reader fully and return the content as string
+	private String readFully(Reader reader) throws ScriptException
+	{
+		final char[] arr = new char[8 * 1024]; // 8K at a time
+		final StringBuilder buf = new StringBuilder();
+		int numChars;
+		try
+		{
+			while ((numChars = reader.read(arr, 0, arr.length)) > 0)
+			{
+				buf.append(arr, 0, numChars);
+			}
+		}
+		catch (IOException exp)
+		{
+			throw new ScriptException(exp);
+		}
+		return buf.toString();
+	}
+}

L2J_Mobius_Test/java/com/l2jmobius/commons/javaengine/JavaScriptEngineFactory.java

@@ -0,0 +1,221 @@
+/*
+ * Copyright (C) 2006 Sun Microsystems, Inc. All rights reserved. 
+ * Use is subject to license terms.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are 
+ * permitted provided that the following conditions are met: Redistributions of source code 
+ * must retain the above copyright notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice, this list of 
+ * conditions and the following disclaimer in the documentation and/or other materials 
+ * provided with the distribution. Neither the name of the Sun Microsystems nor the names of 
+ * is contributors may be used to endorse or promote products derived from this software 
+ * without specific prior written permission. 
+
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY 
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER 
+ * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON 
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+package com.l2jmobius.commons.javaengine;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import javax.script.ScriptEngine;
+import javax.script.ScriptEngineFactory;
+
+/**
+ * This is script engine factory for "Java" script engine.
+ * @author A. Sundararajan
+ */
+public class JavaScriptEngineFactory implements ScriptEngineFactory
+{
+	@Override
+	public String getEngineName()
+	{
+		return "java";
+	}
+	
+	@Override
+	public String getEngineVersion()
+	{
+		return "1.8";
+	}
+	
+	@Override
+	public List<String> getExtensions()
+	{
+		return extensions;
+	}
+	
+	@Override
+	public String getLanguageName()
+	{
+		return "java";
+	}
+	
+	@Override
+	public String getLanguageVersion()
+	{
+		return "1.8";
+	}
+	
+	@Override
+	public String getMethodCallSyntax(String obj, String m, String... args)
+	{
+		final StringBuilder buf = new StringBuilder();
+		buf.append(obj);
+		buf.append('.');
+		buf.append(m);
+		buf.append('(');
+		if (args.length != 0)
+		{
+			int i = 0;
+			for (; i < (args.length - 1); i++)
+			{
+				buf.append(args[i] + ", ");
+			}
+			buf.append(args[i]);
+		}
+		buf.append(')');
+		return buf.toString();
+	}
+	
+	@Override
+	public List<String> getMimeTypes()
+	{
+		return mimeTypes;
+	}
+	
+	@Override
+	public List<String> getNames()
+	{
+		return names;
+	}
+	
+	@Override
+	public String getOutputStatement(String toDisplay)
+	{
+		final StringBuilder buf = new StringBuilder();
+		buf.append("System.out.print(\"");
+		final int len = toDisplay.length();
+		for (int i = 0; i < len; i++)
+		{
+			final char ch = toDisplay.charAt(i);
+			switch (ch)
+			{
+				case 34: // '"'
+				{
+					buf.append("\\\"");
+					break;
+				}
+				case 92: // '\\'
+				{
+					buf.append("\\\\");
+					break;
+				}
+				default:
+				{
+					buf.append(ch);
+					break;
+				}
+			}
+		}
+		buf.append("\");");
+		return buf.toString();
+	}
+	
+	@Override
+	public String getParameter(String key)
+	{
+		if (key.equals("javax.script.engine"))
+		{
+			return getEngineName();
+		}
+		if (key.equals("javax.script.engine_version"))
+		{
+			return getEngineVersion();
+		}
+		if (key.equals("javax.script.name"))
+		{
+			return getEngineName();
+		}
+		if (key.equals("javax.script.language"))
+		{
+			return getLanguageName();
+		}
+		if (key.equals("javax.script.language_version"))
+		{
+			return getLanguageVersion();
+		}
+		if (key.equals("THREADING"))
+		{
+			return "MULTITHREADED";
+		}
+		return null;
+	}
+	
+	@Override
+	public String getProgram(String... statements)
+	{
+		// we generate a Main class with main method
+		// that contains all the given statements
+		
+		final StringBuilder buf = new StringBuilder();
+		buf.append("class ");
+		buf.append(getClassName());
+		buf.append(" {\n");
+		buf.append("    public static void main(String[] args) {\n");
+		if (statements.length != 0)
+		{
+			for (String statement : statements)
+			{
+				buf.append("        ");
+				buf.append(statement);
+				buf.append(";\n");
+			}
+		}
+		buf.append("    }\n");
+		buf.append("}\n");
+		return buf.toString();
+	}
+	
+	@Override
+	public ScriptEngine getScriptEngine()
+	{
+		final JavaScriptEngine engine = new JavaScriptEngine();
+		engine.setFactory(this);
+		return engine;
+	}
+	
+	// used to generate a unique class name in getProgram
+	private String getClassName()
+	{
+		return "com_sun_script_java_Main$" + getNextClassNumber();
+	}
+	
+	private static synchronized long getNextClassNumber()
+	{
+		return nextClassNum++;
+	}
+	
+	private static long nextClassNum = 0L;
+	private static List<String> names;
+	private static List<String> extensions;
+	private static List<String> mimeTypes;
+	static
+	{
+		names = new ArrayList<>(1);
+		names.add("java");
+		names = Collections.unmodifiableList(names);
+		extensions = names;
+		mimeTypes = new ArrayList<>(0);
+		mimeTypes = Collections.unmodifiableList(mimeTypes);
+	}
+}

L2J_Mobius_Test/java/com/l2jmobius/commons/javaengine/MemoryClassLoader.java

@@ -0,0 +1,123 @@
+/*
+ * Copyright (C) 2006 Sun Microsystems, Inc. All rights reserved. 
+ * Use is subject to license terms.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are 
+ * permitted provided that the following conditions are met: Redistributions of source code 
+ * must retain the above copyright notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice, this list of 
+ * conditions and the following disclaimer in the documentation and/or other materials 
+ * provided with the distribution. Neither the name of the Sun Microsystems nor the names of 
+ * is contributors may be used to endorse or promote products derived from this software 
+ * without specific prior written permission. 
+
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY 
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER 
+ * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON 
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+package com.l2jmobius.commons.javaengine;
+
+import java.io.File;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.StringTokenizer;
+
+/**
+ * ClassLoader that loads .class bytes from memory.
+ * @author A. Sundararajan
+ */
+public final class MemoryClassLoader extends URLClassLoader
+{
+	private final Map<String, byte[]> classBytes;
+	
+	public MemoryClassLoader(Map<String, byte[]> classBytes, String classPath, ClassLoader parent)
+	{
+		super(toURLs(classPath), parent);
+		this.classBytes = classBytes;
+	}
+	
+	public MemoryClassLoader(Map<String, byte[]> classBytes, String classPath)
+	{
+		this(classBytes, classPath, null);
+	}
+	
+	public Class<?> load(String className) throws ClassNotFoundException
+	{
+		return loadClass(className);
+	}
+	
+	public Iterable<Class<?>> loadAll() throws ClassNotFoundException
+	{
+		final List<Class<?>> classes = new ArrayList<>(classBytes.size());
+		for (String name : classBytes.keySet())
+		{
+			classes.add(loadClass(name));
+		}
+		return classes;
+	}
+	
+	@Override
+	protected Class<?> findClass(String className) throws ClassNotFoundException
+	{
+		final byte buf[] = classBytes.get(className);
+		if (buf != null)
+		{
+			// clear the bytes in map -- we don't need it anymore
+			classBytes.put(className, null);
+			return defineClass(className, buf, 0, buf.length);
+		}
+		return super.findClass(className);
+	}
+	
+	private static URL[] toURLs(String classPath)
+	{
+		if (classPath == null)
+		{
+			return new URL[0];
+		}
+		
+		final List<URL> list = new ArrayList<>();
+		final StringTokenizer st = new StringTokenizer(classPath, File.pathSeparator);
+		while (st.hasMoreTokens())
+		{
+			final String token = st.nextToken();
+			final File file = new File(token);
+			if (file.exists())
+			{
+				try
+				{
+					list.add(file.toURI().toURL());
+				}
+				catch (MalformedURLException mue)
+				{
+					//
+				}
+			}
+			else
+			{
+				try
+				{
+					list.add(new URL(token));
+				}
+				catch (MalformedURLException mue)
+				{
+					//
+				}
+			}
+		}
+		
+		final URL res[] = new URL[list.size()];
+		list.toArray(res);
+		return res;
+	}
+}

L2J_Mobius_Test/java/com/l2jmobius/commons/javaengine/MemoryJavaFileManager.java

@@ -0,0 +1,162 @@
+/*
+ * Copyright (C) 2006 Sun Microsystems, Inc. All rights reserved. 
+ * Use is subject to license terms.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are 
+ * permitted provided that the following conditions are met: Redistributions of source code 
+ * must retain the above copyright notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice, this list of 
+ * conditions and the following disclaimer in the documentation and/or other materials 
+ * provided with the distribution. Neither the name of the Sun Microsystems nor the names of 
+ * is contributors may be used to endorse or promote products derived from this software 
+ * without specific prior written permission. 
+
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
+ * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY 
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER 
+ * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON 
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+package com.l2jmobius.commons.javaengine;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FilterOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.net.URI;
+import java.nio.CharBuffer;
+import java.util.HashMap;
+import java.util.Map;
+
+import javax.tools.FileObject;
+import javax.tools.JavaFileManager;
+import javax.tools.JavaFileObject;
+import javax.tools.JavaFileObject.Kind;
+import javax.tools.SimpleJavaFileObject;
+
+import org.eclipse.jdt.internal.compiler.tool.EclipseFileManager;
+
+/**
+ * JavaFileManager that keeps compiled .class bytes in memory.
+ * @author A. Sundararajan
+ */
+public final class MemoryJavaFileManager extends EclipseFileManager
+{
+	private static final String EXT = ".java";
+	protected Map<String, byte[]> classBytes;
+	
+	public MemoryJavaFileManager()
+	{
+		super(null, null);
+		classBytes = new HashMap<>();
+	}
+	
+	public Map<String, byte[]> getClassBytes()
+	{
+		return classBytes;
+	}
+	
+	@Override
+	public void close()
+	{
+		classBytes = new HashMap<>();
+	}
+	
+	@Override
+	public void flush()
+	{
+	}
+	
+	/**
+	 * A file object used to represent Java source coming from a string.
+	 */
+	private static class StringInputBuffer extends SimpleJavaFileObject
+	{
+		final String code;
+		
+		StringInputBuffer(String name, String code)
+		{
+			super(toURI(name), Kind.SOURCE);
+			this.code = code;
+		}
+		
+		@Override
+		public CharBuffer getCharContent(boolean ignoreEncodingErrors)
+		{
+			return CharBuffer.wrap(code);
+		}
+	}
+	
+	/**
+	 * A file object that stores Java bytecode into the classBytes map.
+	 */
+	private class ClassOutputBuffer extends SimpleJavaFileObject
+	{
+		protected final String name;
+		
+		ClassOutputBuffer(String name)
+		{
+			super(toURI(name), Kind.CLASS);
+			this.name = name;
+		}
+		
+		@Override
+		public OutputStream openOutputStream()
+		{
+			return new FilterOutputStream(new ByteArrayOutputStream())
+			{
+				@Override
+				public void close() throws IOException
+				{
+					out.close();
+					classBytes.put(name, ((ByteArrayOutputStream) out).toByteArray());
+				}
+			};
+		}
+	}
+	
+	@Override
+	public JavaFileObject getJavaFileForOutput(JavaFileManager.Location location, String className, Kind kind, FileObject sibling) throws IOException
+	{
+		if (kind == Kind.CLASS)
+		{
+			return new ClassOutputBuffer(className.replace('/', '.'));
+		}
+		return super.getJavaFileForOutput(location, className, kind, sibling);
+	}
+	
+	static JavaFileObject makeStringSource(String name, String code)
+	{
+		return new StringInputBuffer(name, code);
+	}
+	
+	static URI toURI(String name)
+	{
+		final File file = new File(name);
+		if (file.exists())
+		{
+			return file.toURI();
+		}
+		
+		try
+		{
+			final StringBuilder newUri = new StringBuilder();
+			newUri.append("file:///");
+			newUri.append(name.replace('.', '/'));
+			if (name.endsWith(EXT))
+			{
+				newUri.replace(newUri.length() - EXT.length(), newUri.length(), EXT);
+			}
+			return URI.create(newUri.toString());
+		}
+		catch (Exception exp)
+		{
+			return URI.create("file:///com/sun/script/java/java_source");
+		}
+	}
+}

L2J_Mobius_Test/java/com/l2jmobius/commons/mmocore/AbstractPacket.java

@@ -0,0 +1,35 @@
+/*
+ * This file is part of the L2J Mobius project.
+ * 
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.l2jmobius.commons.mmocore;
+
+import java.nio.ByteBuffer;
+
+/**
+ * @author KenM
+ * @param <T>
+ */
+public abstract class AbstractPacket<T extends MMOClient<?>>
+{
+	protected ByteBuffer _buf;
+	
+	T _client;
+	
+	public final T getClient()
+	{
+		return _client;
+	}
+}

L2J_Mobius_Test/java/com/l2jmobius/commons/mmocore/IAcceptFilter.java

@@ -0,0 +1,27 @@
+/*
+ * This file is part of the L2J Mobius project.
+ * 
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.l2jmobius.commons.mmocore;
+
+import java.nio.channels.SocketChannel;
+
+/**
+ * @author KenM
+ */
+public interface IAcceptFilter
+{
+	boolean accept(SocketChannel sc);
+}

L2J_Mobius_Test/java/com/l2jmobius/commons/mmocore/IClientFactory.java

@@ -0,0 +1,26 @@
+/*
+ * This file is part of the L2J Mobius project.
+ * 
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.l2jmobius.commons.mmocore;
+
+/**
+ * @author KenM
+ * @param <T>
+ */
+public interface IClientFactory<T extends MMOClient<?>>
+{
+	T create(MMOConnection<T> con);
+}

L2J_Mobius_Test/java/com/l2jmobius/commons/mmocore/IMMOExecutor.java

@@ -0,0 +1,26 @@
+/*
+ * This file is part of the L2J Mobius project.
+ * 
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.l2jmobius.commons.mmocore;
+
+/**
+ * @author KenM
+ * @param <T>
+ */
+public interface IMMOExecutor<T extends MMOClient<?>>
+{
+	void execute(ReceivablePacket<T> packet);
+}

L2J_Mobius_Test/java/com/l2jmobius/commons/mmocore/IPacketHandler.java

@@ -0,0 +1,28 @@
+/*
+ * This file is part of the L2J Mobius project.
+ * 
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.l2jmobius.commons.mmocore;
+
+import java.nio.ByteBuffer;
+
+/**
+ * @author KenM
+ * @param <T>
+ */
+public interface IPacketHandler<T extends MMOClient<?>>
+{
+	ReceivablePacket<T> handlePacket(ByteBuffer buf, T client);
+}

L2J_Mobius_Test/java/com/l2jmobius/commons/mmocore/MMOClient.java

@@ -0,0 +1,46 @@
+/*
+ * This file is part of the L2J Mobius project.
+ * 
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.l2jmobius.commons.mmocore;
+
+import java.nio.ByteBuffer;
+
+/**
+ * @author KenM
+ * @param <T>
+ */
+public abstract class MMOClient<T extends MMOConnection<?>>
+{
+	private final T _con;
+	
+	public MMOClient(T con)
+	{
+		_con = con;
+	}
+	
+	public T getConnection()
+	{
+		return _con;
+	}
+	
+	public abstract boolean decrypt(ByteBuffer buf, int size);
+	
+	public abstract boolean encrypt(ByteBuffer buf, int size);
+	
+	protected abstract void onDisconnection();
+	
+	protected abstract void onForcedDisconnection();
+}

L2J_Mobius_Test/java/com/l2jmobius/commons/mmocore/MMOConnection.java

@@ -0,0 +1,283 @@
+/*
+ * This file is part of the L2J Mobius project.
+ * 
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.l2jmobius.commons.mmocore;
+
+import java.io.IOException;
+import java.net.InetAddress;
+import java.net.Socket;
+import java.net.SocketException;
+import java.nio.ByteBuffer;
+import java.nio.channels.CancelledKeyException;
+import java.nio.channels.ReadableByteChannel;
+import java.nio.channels.SelectionKey;
+import java.nio.channels.WritableByteChannel;
+
+/**
+ * @author KenM
+ * @param <T>
+ */
+public class MMOConnection<T extends MMOClient<?>>
+{
+	private final SelectorThread<T> _selectorThread;
+	
+	private final Socket _socket;
+	
+	private final InetAddress _address;
+	
+	private final ReadableByteChannel _readableByteChannel;
+	
+	private final WritableByteChannel _writableByteChannel;
+	
+	private final int _port;
+	
+	private final NioNetStackList<SendablePacket<T>> _sendQueue;
+	
+	private final SelectionKey _selectionKey;
+	
+	private ByteBuffer _readBuffer;
+	
+	private ByteBuffer _primaryWriteBuffer;
+	
+	private ByteBuffer _secondaryWriteBuffer;
+	
+	private volatile boolean _pendingClose;
+	
+	private T _client;
+	
+	public MMOConnection(SelectorThread<T> selectorThread, Socket socket, SelectionKey key, boolean tcpNoDelay)
+	{
+		_selectorThread = selectorThread;
+		_socket = socket;
+		_address = socket.getInetAddress();
+		_readableByteChannel = socket.getChannel();
+		_writableByteChannel = socket.getChannel();
+		_port = socket.getPort();
+		_selectionKey = key;
+		
+		_sendQueue = new NioNetStackList<>();
+		
+		try
+		{
+			_socket.setTcpNoDelay(tcpNoDelay);
+		}
+		catch (SocketException e)
+		{
+			e.printStackTrace();
+		}
+	}
+	
+	final void setClient(T client)
+	{
+		_client = client;
+	}
+	
+	public final T getClient()
+	{
+		return _client;
+	}
+	
+	public final void sendPacket(SendablePacket<T> sp)
+	{
+		sp._client = _client;
+		
+		if (_pendingClose)
+		{
+			return;
+		}
+		
+		synchronized (getSendQueue())
+		{
+			_sendQueue.addLast(sp);
+		}
+		
+		if (!_sendQueue.isEmpty())
+		{
+			try
+			{
+				_selectionKey.interestOps(_selectionKey.interestOps() | SelectionKey.OP_WRITE);
+			}
+			catch (CancelledKeyException e)
+			{
+				// ignore
+			}
+		}
+	}
+	
+	final SelectionKey getSelectionKey()
+	{
+		return _selectionKey;
+	}
+	
+	public final InetAddress getInetAddress()
+	{
+		return _address;
+	}
+	
+	public final int getPort()
+	{
+		return _port;
+	}
+	
+	final void close() throws IOException
+	{
+		_socket.close();
+	}
+	
+	final int read(ByteBuffer buf) throws IOException
+	{
+		return _readableByteChannel.read(buf);
+	}
+	
+	final int write(ByteBuffer buf) throws IOException
+	{
+		return _writableByteChannel.write(buf);
+	}
+	
+	final void createWriteBuffer(ByteBuffer buf)
+	{
+		if (_primaryWriteBuffer == null)
+		{
+			_primaryWriteBuffer = _selectorThread.getPooledBuffer();
+			_primaryWriteBuffer.put(buf);
+		}
+		else
+		{
+			final ByteBuffer temp = _selectorThread.getPooledBuffer();
+			temp.put(buf);
+			
+			final int remaining = temp.remaining();
+			_primaryWriteBuffer.flip();
+			final int limit = _primaryWriteBuffer.limit();
+			
+			if (remaining >= _primaryWriteBuffer.remaining())
+			{
+				temp.put(_primaryWriteBuffer);
+				_selectorThread.recycleBuffer(_primaryWriteBuffer);
+			}
+			else
+			{
+				_primaryWriteBuffer.limit(remaining);
+				temp.put(_primaryWriteBuffer);
+				_primaryWriteBuffer.limit(limit);
+				_primaryWriteBuffer.compact();
+				_secondaryWriteBuffer = _primaryWriteBuffer;
+			}
+			_primaryWriteBuffer = temp;
+		}
+	}
+	
+	final boolean hasPendingWriteBuffer()
+	{
+		return _primaryWriteBuffer != null;
+	}
+	
+	final void movePendingWriteBufferTo(ByteBuffer dest)
+	{
+		_primaryWriteBuffer.flip();
+		dest.put(_primaryWriteBuffer);
+		_selectorThread.recycleBuffer(_primaryWriteBuffer);
+		_primaryWriteBuffer = _secondaryWriteBuffer;
+		_secondaryWriteBuffer = null;
+	}
+	
+	final void setReadBuffer(ByteBuffer buf)
+	{
+		_readBuffer = buf;
+	}
+	
+	final ByteBuffer getReadBuffer()
+	{
+		return _readBuffer;
+	}
+	
+	public final boolean isClosed()
+	{
+		return _pendingClose;
+	}
+	
+	final NioNetStackList<SendablePacket<T>> getSendQueue()
+	{
+		return _sendQueue;
+	}
+	
+	/*
+	 * final SendablePacket<T> getClosePacket() { return _closePacket; }
+	 */
+	
+	@SuppressWarnings("unchecked")
+	public final void close(SendablePacket<T> sp)
+	{
+		close(new SendablePacket[]
+		{
+			sp
+		});
+	}
+	
+	public final void close(SendablePacket<T>[] closeList)
+	{
+		if (_pendingClose)
+		{
+			return;
+		}
+		
+		synchronized (getSendQueue())
+		{
+			if (!_pendingClose)
+			{
+				_pendingClose = true;
+				_sendQueue.clear();
+				for (SendablePacket<T> sp : closeList)
+				{
+					_sendQueue.addLast(sp);
+				}
+			}
+		}
+		
+		try
+		{
+			_selectionKey.interestOps(_selectionKey.interestOps() & ~SelectionKey.OP_WRITE);
+		}
+		catch (CancelledKeyException e)
+		{
+			// ignore
+		}
+		
+		// _closePacket = sp;
+		_selectorThread.closeConnection(this);
+	}
+	
+	final void releaseBuffers()
+	{
+		if (_primaryWriteBuffer != null)
+		{
+			_selectorThread.recycleBuffer(_primaryWriteBuffer);
+			_primaryWriteBuffer = null;
+			
+			if (_secondaryWriteBuffer != null)
+			{
+				_selectorThread.recycleBuffer(_secondaryWriteBuffer);
+				_secondaryWriteBuffer = null;
+			}
+		}
+		
+		if (_readBuffer != null)
+		{
+			_selectorThread.recycleBuffer(_readBuffer);
+			_readBuffer = null;
+		}
+	}
+}

L2J_Mobius_Test/java/com/l2jmobius/commons/mmocore/NioNetStackList.java

@@ -0,0 +1,101 @@
+/*
+ * This file is part of the L2J Mobius project.
+ * 
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.l2jmobius.commons.mmocore;
+
+/**
+ * @author Forsaiken
+ * @param <E>
+ */
+public final class NioNetStackList<E>
+{
+	private final NioNetStackNode _start = new NioNetStackNode();
+	
+	private final NioNetStackNodeBuf _buf = new NioNetStackNodeBuf();
+	
+	private NioNetStackNode _end = new NioNetStackNode();
+	
+	public NioNetStackList()
+	{
+		clear();
+	}
+	
+	public final void addLast(E elem)
+	{
+		final NioNetStackNode newEndNode = _buf.removeFirst();
+		_end._value = elem;
+		_end._next = newEndNode;
+		_end = newEndNode;
+	}
+	
+	public final E removeFirst()
+	{
+		final NioNetStackNode old = _start._next;
+		final E value = old._value;
+		_start._next = old._next;
+		_buf.addLast(old);
+		return value;
+	}
+	
+	public final boolean isEmpty()
+	{
+		return _start._next == _end;
+	}
+	
+	public final void clear()
+	{
+		_start._next = _end;
+	}
+	
+	protected final class NioNetStackNode
+	{
+		protected NioNetStackNode _next;
+		
+		protected E _value;
+	}
+	
+	private final class NioNetStackNodeBuf
+	{
+		private final NioNetStackNode _start = new NioNetStackNode();
+		
+		private NioNetStackNode _end = new NioNetStackNode();
+		
+		NioNetStackNodeBuf()
+		{
+			_start._next = _end;
+		}
+		
+		final void addLast(NioNetStackNode node)
+		{
+			node._next = null;
+			node._value = null;
+			_end._next = node;
+			_end = node;
+		}
+		
+		final NioNetStackNode removeFirst()
+		{
+			if (_start._next == _end)
+			{
+				return new NioNetStackNode();
+			}
+			
+			final NioNetStackNode old = _start._next;
+			_start._next = old._next;
+			return old;
+		}
+	}
+}

L2J_Mobius_Test/java/com/l2jmobius/commons/mmocore/NioNetStringBuffer.java

@@ -0,0 +1,61 @@
+/*
+ * This file is part of the L2J Mobius project.
+ * 
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.l2jmobius.commons.mmocore;
+
+import java.nio.BufferOverflowException;
+
+/**
+ * @author Forsaiken
+ */
+public final class NioNetStringBuffer
+{
+	private final char[] _buf;
+	
+	private final int _size;
+	
+	private int _len;
+	
+	public NioNetStringBuffer(int size)
+	{
+		_buf = new char[size];
+		_size = size;
+		_len = 0;
+	}
+	
+	public final void clear()
+	{
+		_len = 0;
+	}
+	
+	public final void append(char c)
+	{
+		if (_len < _size)
+		{
+			_buf[_len++] = c;
+		}
+		else
+		{
+			throw new BufferOverflowException();
+		}
+	}
+	
+	@Override
+	public final String toString()
+	{
+		return new String(_buf, 0, _len);
+	}
+}

L2J_Mobius_Test/java/com/l2jmobius/commons/mmocore/ReceivablePacket.java

@@ -0,0 +1,139 @@
+/*
+ * This file is part of the L2J Mobius project.
+ * 
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.l2jmobius.commons.mmocore;
+
+import java.nio.ByteBuffer;
+
+/**
+ * @author KenM
+ * @param <T>
+ */
+public abstract class ReceivablePacket<T extends MMOClient<?>>extends AbstractPacket<T> implements Runnable
+{
+	NioNetStringBuffer _sbuf;
+	
+	protected ReceivablePacket()
+	{
+	}
+	
+	protected abstract boolean read();
+	
+	@Override
+	public abstract void run();
+	
+	/**
+	 * Reads <B>byte[]</B> from the buffer. <BR>
+	 * Reads as many bytes as the length of the array.
+	 * @param dst : the byte array which will be filled with the data.
+	 */
+	protected final void readB(byte[] dst)
+	{
+		_buf.get(dst);
+	}
+	
+	/**
+	 * Reads <B>byte[]</B> from the buffer. <BR>
+	 * Reads as many bytes as the given length (len). Starts to fill the byte array from the given offset to <B>offset</B> + <B>len</B>.
+	 * @param dst : the byte array which will be filled with the data.
+	 * @param offset : starts to fill the byte array from the given offset.
+	 * @param len : the given length of bytes to be read.
+	 */
+	protected final void readB(byte[] dst, int offset, int len)
+	{
+		_buf.get(dst, offset, len);
+	}
+	
+	/**
+	 * Reads <B>byte</B> from the buffer. <BR>
+	 * 8bit integer (00)
+	 * @return
+	 */
+	protected final int readC()
+	{
+		return _buf.get() & 0xFF;
+	}
+	
+	/**
+	 * Reads <B>short</B> from the buffer. <BR>
+	 * 16bit integer (00 00)
+	 * @return
+	 */
+	protected final int readH()
+	{
+		return _buf.getShort() & 0xFFFF;
+	}
+	
+	/**
+	 * Reads <B>int</B> from the buffer. <BR>
+	 * 32bit integer (00 00 00 00)
+	 * @return
+	 */
+	protected final int readD()
+	{
+		return _buf.getInt();
+	}
+	
+	/**
+	 * Reads <B>long</B> from the buffer. <BR>
+	 * 64bit integer (00 00 00 00 00 00 00 00)
+	 * @return
+	 */
+	protected final long readQ()
+	{
+		return _buf.getLong();
+	}
+	
+	/**
+	 * Reads <B>double</B> from the buffer. <BR>
+	 * 64bit double precision float (00 00 00 00 00 00 00 00)
+	 * @return
+	 */
+	protected final double readF()
+	{
+		return _buf.getDouble();
+	}
+	
+	/**
+	 * Reads <B>String</B> from the buffer.
+	 * @return
+	 */
+	protected final String readS()
+	{
+		_sbuf.clear();
+		
+		char ch;
+		while ((ch = _buf.getChar()) != 0)
+		{
+			_sbuf.append(ch);
+		}
+		
+		return _sbuf.toString();
+	}
+	
+	/**
+	 * packet forge purpose
+	 * @param data
+	 * @param client
+	 * @param sBuffer
+	 */
+	public void setBuffers(ByteBuffer data, T client, NioNetStringBuffer sBuffer)
+	{
+		_buf = data;
+		_client = client;
+		_sbuf = sBuffer;
+	}
+}

L2J_Mobius_Test/java/com/l2jmobius/commons/mmocore/SelectorConfig.java

@@ -0,0 +1,63 @@
+/*
+ * This file is part of the L2J Mobius project.
+ * 
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.l2jmobius.commons.mmocore;
+
+/**
+ * @author KenM
+ */
+public final class SelectorConfig
+{
+	public int READ_BUFFER_SIZE = 64 * 1024;
+	
+	public int WRITE_BUFFER_SIZE = 64 * 1024;
+	
+	public int HELPER_BUFFER_COUNT = 20;
+	
+	public int HELPER_BUFFER_SIZE = 64 * 1024;
+	
+	/**
+	 * Server will try to send MAX_SEND_PER_PASS packets per socket write call<br>
+	 * however it may send less if the write buffer was filled before achieving this value.
+	 */
+	public int MAX_SEND_PER_PASS = 10;
+	
+	/**
+	 * Server will try to read MAX_READ_PER_PASS packets per socket read call<br>
+	 * however it may read less if the read buffer was empty before achieving this value.
+	 */
+	public int MAX_READ_PER_PASS = 10;
+	
+	/**
+	 * Defines how much time (in milis) should the selector sleep, an higher value increases throughput but also increases latency(to a max of the sleep value itself).<BR>
+	 * Also an extremely high value(usually > 100) will decrease throughput due to the server not doing enough sends per second (depends on max sends per pass).<BR>
+	 * <BR>
+	 * Recommended values:<BR>
+	 * 1 for minimal latency.<BR>
+	 * 10-30 for an latency/troughput trade-off based on your needs.<BR>
+	 */
+	public int SLEEP_TIME = 10;
+	
+	/**
+	 * Used to enable/disable TCP_NODELAY which disable/enable Nagle's algorithm.<BR>
+	 * <BR>
+	 * Nagle's algorithm try to conserve bandwidth by minimizing the number of segments that are sent. When applications wish to decrease network latency and increase performance, they can disable Nagle's algorithm (that is enable TCP_NODELAY). Data will be sent earlier, at the cost of an increase
+	 * in bandwidth consumption. The Nagle's algorithm is described in RFC 896.<BR>
+	 * <BR>
+	 * Summary, data will be sent earlier, thus lowering the ping, at the cost of a small increase in bandwidth consumption.
+	 */
+	public boolean TCP_NODELAY = true;
+}

L2J_Mobius_Test/java/com/l2jmobius/commons/mmocore/SelectorThread.java

@@ -0,0 +1,714 @@
+/*
+ * This file is part of the L2J Mobius project.
+ * 
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.l2jmobius.commons.mmocore;
+
+import java.io.IOException;
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
+import java.net.ServerSocket;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.channels.SelectionKey;
+import java.nio.channels.Selector;
+import java.nio.channels.ServerSocketChannel;
+import java.nio.channels.SocketChannel;
+import java.util.Iterator;
+import java.util.LinkedList;
+
+/**
+ * Parts of design based on network core from WoodenGil
+ * @param <T>
+ * @author KenM
+ */
+public final class SelectorThread<T extends MMOClient<?>>extends Thread
+{
+	// default BYTE_ORDER
+	private static final ByteOrder BYTE_ORDER = ByteOrder.LITTLE_ENDIAN;
+	// default HEADER_SIZE
+	private static final int HEADER_SIZE = 2;
+	// Selector
+	private final Selector _selector;
+	// Implementations
+	private final IPacketHandler<T> _packetHandler;
+	private final IMMOExecutor<T> _executor;
+	private final IClientFactory<T> _clientFactory;
+	private final IAcceptFilter _acceptFilter;
+	// Configurations
+	private final int HELPER_BUFFER_SIZE;
+	private final int HELPER_BUFFER_COUNT;
+	private final int MAX_SEND_PER_PASS;
+	private final int MAX_READ_PER_PASS;
+	private final long SLEEP_TIME;
+	public boolean TCP_NODELAY;
+	// Main Buffers
+	private final ByteBuffer DIRECT_WRITE_BUFFER;
+	private final ByteBuffer WRITE_BUFFER;
+	private final ByteBuffer READ_BUFFER;
+	// String Buffer
+	private final NioNetStringBuffer STRING_BUFFER;
+	// ByteBuffers General Purpose Pool
+	private final LinkedList<ByteBuffer> _bufferPool;
+	// Pending Close
+	private final NioNetStackList<MMOConnection<T>> _pendingClose;
+	
+	private boolean _shutdown;
+	
+	public SelectorThread(SelectorConfig sc, IMMOExecutor<T> executor, IPacketHandler<T> packetHandler, IClientFactory<T> clientFactory, IAcceptFilter acceptFilter) throws IOException
+	{
+		super.setName("SelectorThread-" + super.getId());
+		
+		HELPER_BUFFER_SIZE = sc.HELPER_BUFFER_SIZE;
+		HELPER_BUFFER_COUNT = sc.HELPER_BUFFER_COUNT;
+		MAX_SEND_PER_PASS = sc.MAX_SEND_PER_PASS;
+		MAX_READ_PER_PASS = sc.MAX_READ_PER_PASS;
+		SLEEP_TIME = sc.SLEEP_TIME;
+		TCP_NODELAY = sc.TCP_NODELAY;
+		
+		DIRECT_WRITE_BUFFER = ByteBuffer.allocateDirect(sc.WRITE_BUFFER_SIZE).order(BYTE_ORDER);
+		WRITE_BUFFER = ByteBuffer.wrap(new byte[sc.WRITE_BUFFER_SIZE]).order(BYTE_ORDER);
+		READ_BUFFER = ByteBuffer.wrap(new byte[sc.READ_BUFFER_SIZE]).order(BYTE_ORDER);
+		
+		STRING_BUFFER = new NioNetStringBuffer(64 * 1024);
+		
+		_pendingClose = new NioNetStackList<>();
+		_bufferPool = new LinkedList<>();
+		
+		for (int i = 0; i < HELPER_BUFFER_COUNT; i++)
+		{
+			_bufferPool.addLast(ByteBuffer.wrap(new byte[HELPER_BUFFER_SIZE]).order(BYTE_ORDER));
+		}
+		
+		_acceptFilter = acceptFilter;
+		_packetHandler = packetHandler;
+		_clientFactory = clientFactory;
+		_executor = executor;
+		_selector = Selector.open();
+	}
+	
+	public final void openServerSocket(InetAddress address, int tcpPort) throws IOException
+	{
+		final ServerSocketChannel selectable = ServerSocketChannel.open();
+		selectable.configureBlocking(false);
+		
+		final ServerSocket ss = selectable.socket();
+		
+		if (address != null)
+		{
+			ss.bind(new InetSocketAddress(address, tcpPort));
+		}
+		else
+		{
+			ss.bind(new InetSocketAddress(tcpPort));
+		}
+		
+		selectable.register(_selector, SelectionKey.OP_ACCEPT);
+	}
+	
+	final ByteBuffer getPooledBuffer()
+	{
+		if (_bufferPool.isEmpty())
+		{
+			return ByteBuffer.wrap(new byte[HELPER_BUFFER_SIZE]).order(BYTE_ORDER);
+		}
+		
+		return _bufferPool.removeFirst();
+	}
+	
+	final void recycleBuffer(ByteBuffer buf)
+	{
+		if (_bufferPool.size() < HELPER_BUFFER_COUNT)
+		{
+			buf.clear();
+			_bufferPool.addLast(buf);
+		}
+	}
+	
+	@SuppressWarnings("unchecked")
+	@Override
+	public final void run()
+	{
+		int selectedKeysCount = 0;
+		
+		SelectionKey key;
+		MMOConnection<T> con;
+		
+		Iterator<SelectionKey> selectedKeys;
+		
+		while (!_shutdown)
+		{
+			try
+			{
+				selectedKeysCount = _selector.selectNow();
+			}
+			catch (IOException e)
+			{
+				e.printStackTrace();
+			}
+			
+			if (selectedKeysCount > 0)
+			{
+				selectedKeys = _selector.selectedKeys().iterator();
+				
+				while (selectedKeys.hasNext())
+				{
+					key = selectedKeys.next();
+					selectedKeys.remove();
+					
+					con = (MMOConnection<T>) key.attachment();
+					
+					switch (key.readyOps())
+					{
+						case SelectionKey.OP_CONNECT:
+						{
+							finishConnection(key, con);
+							break;
+						}
+						case SelectionKey.OP_ACCEPT:
+						{
+							acceptConnection(key, con);
+							break;
+						}
+						case SelectionKey.OP_READ:
+						{
+							readPacket(key, con);
+							break;
+						}
+						case SelectionKey.OP_WRITE:
+						{
+							writePacket(key, con);
+							break;
+						}
+						case SelectionKey.OP_READ | SelectionKey.OP_WRITE:
+						{
+							writePacket(key, con);
+							if (key.isValid())
+							{
+								readPacket(key, con);
+							}
+							break;
+						}
+					}
+				}
+			}
+			
+			synchronized (_pendingClose)
+			{
+				while (!_pendingClose.isEmpty())
+				{
+					try
+					{
+						con = _pendingClose.removeFirst();
+						writeClosePacket(con);
+						closeConnectionImpl(con.getSelectionKey(), con);
+					}
+					catch (Exception e)
+					{
+						e.printStackTrace();
+					}
+				}
+			}
+			
+			try
+			{
+				Thread.sleep(SLEEP_TIME);
+			}
+			catch (InterruptedException e)
+			{
+				e.printStackTrace();
+			}
+		}
+		closeSelectorThread();
+	}
+	
+	private final void finishConnection(SelectionKey key, MMOConnection<T> con)
+	{
+		try
+		{
+			((SocketChannel) key.channel()).finishConnect();
+		}
+		catch (IOException e)
+		{
+			con.getClient().onForcedDisconnection();
+			closeConnectionImpl(key, con);
+		}
+		
+		// key might have been invalidated on finishConnect()
+		if (key.isValid())
+		{
+			key.interestOps(key.interestOps() | SelectionKey.OP_READ);
+			key.interestOps(key.interestOps() & ~SelectionKey.OP_CONNECT);
+		}
+	}
+	
+	private final void acceptConnection(SelectionKey key, MMOConnection<T> con)
+	{
+		final ServerSocketChannel ssc = (ServerSocketChannel) key.channel();
+		SocketChannel sc;
+		
+		try
+		{
+			while ((sc = ssc.accept()) != null)
+			{
+				if ((_acceptFilter == null) || _acceptFilter.accept(sc))
+				{
+					sc.configureBlocking(false);
+					final SelectionKey clientKey = sc.register(_selector, SelectionKey.OP_READ);
+					con = new MMOConnection<>(this, sc.socket(), clientKey, TCP_NODELAY);
+					con.setClient(_clientFactory.create(con));
+					clientKey.attach(con);
+				}
+				else
+				{
+					sc.socket().close();
+				}
+			}
+		}
+		catch (IOException e)
+		{
+			e.printStackTrace();
+		}
+	}
+	
+	private final void readPacket(SelectionKey key, MMOConnection<T> con)
+	{
+		if (con.isClosed())
+		{
+			return;
+		}
+		ByteBuffer buf = con.getReadBuffer();
+		if (buf == null)
+		{
+			buf = READ_BUFFER;
+		}
+		
+		// if we try to to do a read with no space in the buffer it will read 0 bytes going into infinite loop
+		if (buf.position() == buf.limit())
+		{
+			System.exit(0);
+		}
+		
+		int result = -2;
+		
+		try
+		{
+			result = con.read(buf);
+		}
+		catch (IOException e)
+		{
+			// error handling goes bellow
+		}
+		
+		if (result > 0)
+		{
+			buf.flip();
+			
+			final T client = con.getClient();
+			
+			for (int i = 0; i < MAX_READ_PER_PASS; i++)
+			{
+				if (!tryReadPacket(key, client, buf, con))
+				{
+					return;
+				}
+			}
+			
+			// only reachable if MAX_READ_PER_PASS has been reached
+			// check if there are some more bytes in buffer
+			// and allocate/compact to prevent content lose.
+			if (buf.remaining() > 0)
+			{
+				// did we use the READ_BUFFER ?
+				if (buf == READ_BUFFER)
+				{
+					// move the pending byte to the connections READ_BUFFER
+					allocateReadBuffer(con);
+				}
+				else
+				{
+					// move the first byte to the beginning :)
+					buf.compact();
+				}
+			}
+		}
+		else
+		{
+			switch (result)
+			{
+				case 0:
+				case -1:
+				{
+					closeConnectionImpl(key, con);
+					break;
+				}
+				case -2:
+				{
+					con.getClient().onForcedDisconnection();
+					closeConnectionImpl(key, con);
+					break;
+				}
+			}
+		}
+	}
+	
+	private final boolean tryReadPacket(SelectionKey key, T client, ByteBuffer buf, MMOConnection<T> con)
+	{
+		switch (buf.remaining())
+		{
+			case 0:
+			{
+				// buffer is full nothing to read
+				return false;
+			}
+			case 1:
+			{
+				// we don`t have enough data for header so we need to read
+				key.interestOps(key.interestOps() | SelectionKey.OP_READ);
+				
+				// did we use the READ_BUFFER ?
+				if (buf == READ_BUFFER)
+				{
+					// move the pending byte to the connections READ_BUFFER
+					allocateReadBuffer(con);
+				}
+				else
+				{
+					// move the first byte to the beginning :)
+					buf.compact();
+				}
+				return false;
+			}
+			default:
+			{
+				// data size excluding header size :>
+				final int dataPending = (buf.getShort() & 0xFFFF) - HEADER_SIZE;
+				
+				// do we got enough bytes for the packet?
+				if (dataPending <= buf.remaining())
+				{
+					// avoid parsing dummy packets (packets without body)
+					if (dataPending > 0)
+					{
+						final int pos = buf.position();
+						parseClientPacket(pos, buf, dataPending, client);
+						buf.position(pos + dataPending);
+					}
+					
+					if (buf.hasRemaining())
+					{
+						return true;
+					}
+					if (buf != READ_BUFFER)
+					{
+						con.setReadBuffer(null);
+						recycleBuffer(buf);
+					}
+					else
+					{
+						READ_BUFFER.clear();
+					}
+					return false;
+				}
+				
+				// we don`t have enough bytes for the dataPacket so we need to read
+				key.interestOps(key.interestOps() | SelectionKey.OP_READ);
+				
+				// move it`s position
+				buf.position(buf.position() - HEADER_SIZE);
+				// did we use the READ_BUFFER ?
+				if (buf == READ_BUFFER)
+				{
+					// move the pending byte to the connections READ_BUFFER
+					allocateReadBuffer(con);
+				}
+				else
+				{
+					buf.compact();
+				}
+				return false;
+			}
+		}
+	}
+	
+	private final void allocateReadBuffer(MMOConnection<T> con)
+	{
+		con.setReadBuffer(getPooledBuffer().put(READ_BUFFER));
+		READ_BUFFER.clear();
+	}
+	
+	private final void parseClientPacket(int pos, ByteBuffer buf, int dataSize, T client)
+	{
+		if (!client.decrypt(buf, dataSize) || !buf.hasRemaining())
+		{
+			return;
+		}
+		
+		// apply limit
+		final int limit = buf.limit();
+		buf.limit(pos + dataSize);
+		final ReceivablePacket<T> cp = _packetHandler.handlePacket(buf, client);
+		
+		if (cp != null)
+		{
+			cp._buf = buf;
+			cp._sbuf = STRING_BUFFER;
+			cp._client = client;
+			
+			if (cp.read())
+			{
+				_executor.execute(cp);
+			}
+			
+			cp._buf = null;
+			cp._sbuf = null;
+		}
+		buf.limit(limit);
+	}
+	
+	private final void writeClosePacket(MMOConnection<T> con)
+	{
+		SendablePacket<T> sp;
+		synchronized (con.getSendQueue())
+		{
+			if (con.getSendQueue().isEmpty())
+			{
+				return;
+			}
+			
+			while ((sp = con.getSendQueue().removeFirst()) != null)
+			{
+				WRITE_BUFFER.clear();
+				
+				putPacketIntoWriteBuffer(con.getClient(), sp);
+				
+				WRITE_BUFFER.flip();
+				
+				try
+				{
+					con.write(WRITE_BUFFER);
+				}
+				catch (IOException e)
+				{
+					// error handling goes on the if bellow
+				}
+			}
+		}
+	}
+	
+	protected final void writePacket(SelectionKey key, MMOConnection<T> con)
+	{
+		if (!prepareWriteBuffer(con))
+		{
+			key.interestOps(key.interestOps() & ~SelectionKey.OP_WRITE);
+			return;
+		}
+		
+		DIRECT_WRITE_BUFFER.flip();
+		
+		final int size = DIRECT_WRITE_BUFFER.remaining();
+		
+		int result = -1;
+		
+		try
+		{
+			result = con.write(DIRECT_WRITE_BUFFER);
+		}
+		catch (IOException e)
+		{
+			// error handling goes on the if bellow
+		}
+		
+		// check if no error happened
+		if (result >= 0)
+		{
+			// check if we written everything
+			if (result == size)
+			{
+				// complete write
+				synchronized (con.getSendQueue())
+				{
+					if (con.getSendQueue().isEmpty() && !con.hasPendingWriteBuffer())
+					{
+						key.interestOps(key.interestOps() & ~SelectionKey.OP_WRITE);
+					}
+				}
+			}
+			else
+			{
+				// incomplete write
+				con.createWriteBuffer(DIRECT_WRITE_BUFFER);
+			}
+		}
+		else
+		{
+			con.getClient().onForcedDisconnection();
+			closeConnectionImpl(key, con);
+		}
+	}
+	
+	private final boolean prepareWriteBuffer(MMOConnection<T> con)
+	{
+		boolean hasPending = false;
+		DIRECT_WRITE_BUFFER.clear();
+		
+		// if there is pending content add it
+		if (con.hasPendingWriteBuffer())
+		{
+			con.movePendingWriteBufferTo(DIRECT_WRITE_BUFFER);
+			hasPending = true;
+		}
+		
+		if ((DIRECT_WRITE_BUFFER.remaining() > 1) && !con.hasPendingWriteBuffer())
+		{
+			final NioNetStackList<SendablePacket<T>> sendQueue = con.getSendQueue();
+			final T client = con.getClient();
+			SendablePacket<T> sp;
+			
+			for (int i = 0; i < MAX_SEND_PER_PASS; i++)
+			{
+				synchronized (con.getSendQueue())
+				{
+					if (sendQueue.isEmpty())
+					{
+						sp = null;
+					}
+					else
+					{
+						sp = sendQueue.removeFirst();
+					}
+				}
+				
+				if (sp == null)
+				{
+					break;
+				}
+				
+				hasPending = true;
+				
+				// put into WriteBuffer
+				putPacketIntoWriteBuffer(client, sp);
+				
+				WRITE_BUFFER.flip();
+				
+				if (DIRECT_WRITE_BUFFER.remaining() < WRITE_BUFFER.limit())
+				{
+					con.createWriteBuffer(WRITE_BUFFER);
+					break;
+				}
+				DIRECT_WRITE_BUFFER.put(WRITE_BUFFER);
+			}
+		}
+		return hasPending;
+	}
+	
+	private final void putPacketIntoWriteBuffer(T client, SendablePacket<T> sp)
+	{
+		WRITE_BUFFER.clear();
+		
+		// reserve space for the size
+		final int headerPos = WRITE_BUFFER.position();
+		final int dataPos = headerPos + HEADER_SIZE;
+		WRITE_BUFFER.position(dataPos);
+		
+		// set the write buffer
+		sp._buf = WRITE_BUFFER;
+		// set the client.
+		sp._client = client;
+		// write content to buffer
+		sp.write();
+		// delete the write buffer
+		sp._buf = null;
+		
+		// size (inclusive header)
+		int dataSize = WRITE_BUFFER.position() - dataPos;
+		WRITE_BUFFER.position(dataPos);
+		client.encrypt(WRITE_BUFFER, dataSize);
+		
+		// recalculate size after encryption
+		dataSize = WRITE_BUFFER.position() - dataPos;
+		
+		WRITE_BUFFER.position(headerPos);
+		// write header
+		WRITE_BUFFER.putShort((short) (dataSize + HEADER_SIZE));
+		WRITE_BUFFER.position(dataPos + dataSize);
+	}
+	
+	final void closeConnection(MMOConnection<T> con)
+	{
+		synchronized (_pendingClose)
+		{
+			_pendingClose.addLast(con);
+		}
+	}
+	
+	private final void closeConnectionImpl(SelectionKey key, MMOConnection<T> con)
+	{
+		try
+		{
+			// notify connection
+			con.getClient().onDisconnection();
+		}
+		finally
+		{
+			try
+			{
+				// close socket and the SocketChannel
+				con.close();
+			}
+			catch (IOException e)
+			{
+				// ignore, we are closing anyway
+			}
+			finally
+			{
+				con.releaseBuffers();
+				// clear attachment
+				key.attach(null);
+				// cancel key
+				key.cancel();
+			}
+		}
+	}
+	
+	public final void shutdown()
+	{
+		_shutdown = true;
+	}
+	
+	protected void closeSelectorThread()
+	{
+		for (SelectionKey key : _selector.keys())
+		{
+			try
+			{
+				key.channel().close();
+			}
+			catch (IOException e)
+			{
+				// ignore
+			}
+		}
+		
+		try
+		{
+			_selector.close();
+		}
+		catch (IOException e)
+		{
+			// Ignore
+		}
+	}
+}

L2J_Mobius_Test/java/com/l2jmobius/commons/mmocore/SendablePacket.java

@@ -0,0 +1,139 @@
+/*
+ * This file is part of the L2J Mobius project.
+ * 
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.l2jmobius.commons.mmocore;
+
+/**
+ * @author KenM
+ * @param <T>
+ */
+public abstract class SendablePacket<T extends MMOClient<?>>extends AbstractPacket<T>
+{
+	protected final void putInt(int value)
+	{
+		_buf.putInt(value);
+	}
+	
+	protected final void putDouble(double value)
+	{
+		_buf.putDouble(value);
+	}
+	
+	protected final void putFloat(float value)
+	{
+		_buf.putFloat(value);
+	}
+	
+	/**
+	 * Write <B>byte</B> to the buffer. <BR>
+	 * 8bit integer (00)
+	 * @param data
+	 */
+	protected final void writeC(boolean data)
+	{
+		_buf.put((byte) (data ? 0x01 : 0x00));
+	}
+	
+	/**
+	 * Write <B>byte</B> to the buffer. <BR>
+	 * 8bit integer (00)
+	 * @param data
+	 */
+	protected final void writeC(int data)
+	{
+		_buf.put((byte) data);
+	}
+	
+	/**
+	 * Write <B>double</B> to the buffer. <BR>
+	 * 64bit double precision float (00 00 00 00 00 00 00 00)
+	 * @param value
+	 */
+	protected final void writeF(double value)
+	{
+		_buf.putDouble(value);
+	}
+	
+	/**
+	 * Write <B>short</B> to the buffer. <BR>
+	 * 16bit integer (00 00)
+	 * @param value
+	 */
+	protected final void writeH(int value)
+	{
+		_buf.putShort((short) value);
+	}
+	
+	/**
+	 * Write <B>int</B> to the buffer. <BR>
+	 * 32bit integer (00 00 00 00)
+	 * @param value
+	 */
+	protected final void writeD(int value)
+	{
+		_buf.putInt(value);
+	}
+	
+	/**
+	 * Write <B>int</B> to the buffer. <BR>
+	 * 32bit integer (00 00 00 00)
+	 * @param value
+	 */
+	protected final void writeD(boolean value)
+	{
+		_buf.putInt(value ? 0x01 : 0x00);
+	}
+	
+	/**
+	 * Write <B>long</B> to the buffer. <BR>
+	 * 64bit integer (00 00 00 00 00 00 00 00)
+	 * @param value
+	 */
+	protected final void writeQ(long value)
+	{
+		_buf.putLong(value);
+	}
+	
+	/**
+	 * Write <B>byte[]</B> to the buffer. <BR>
+	 * 8bit integer array (00 ...)
+	 * @param data
+	 */
+	protected final void writeB(byte[] data)
+	{
+		_buf.put(data);
+	}
+	
+	/**
+	 * Write <B>String</B> to the buffer.
+	 * @param text
+	 */
+	protected final void writeS(String text)
+	{
+		if (text != null)
+		{
+			final int len = text.length();
+			for (int i = 0; i < len; i++)
+			{
+				_buf.putChar(text.charAt(i));
+			}
+		}
+		
+		_buf.putChar('\000');
+	}
+	
+	protected abstract void write();
+}