diff --git a/modifiedeight-newadditions/headers/ExternalServer.hpp b/modifiedeight-newadditions/headers/ExternalServer.hpp
index 3dd005cd..de094297 100644
--- a/modifiedeight-newadditions/headers/ExternalServer.hpp
+++ b/modifiedeight-newadditions/headers/ExternalServer.hpp
@@ -7,9 +7,14 @@ struct ExternalServer
 	int32_t field_0;
 	std::string field_4, field_8;
 	int32_t field_C;
+	// Set when this entry is a Minecraft Java Edition 1.8.x server rather than
+	// an MCPE one, which decides whether joining goes through RakNet or through
+	// the Java session.
+	bool_t isJava;
 
 	ExternalServer();
 	ExternalServer(const ExternalServer&);
 	ExternalServer(int32_t, const std::string&, const std::string&, int32_t);
+	ExternalServer(int32_t, const std::string&, const std::string&, int32_t, bool_t);
 	//~ExternalServer();
 };
diff --git a/modifiedeight-newadditions/headers/ExternalServerFile.hpp b/modifiedeight-newadditions/headers/ExternalServerFile.hpp
index 887cf4c4..a4e428bc 100644
--- a/modifiedeight-newadditions/headers/ExternalServerFile.hpp
+++ b/modifiedeight-newadditions/headers/ExternalServerFile.hpp
@@ -11,7 +11,9 @@ struct ExternalServerFile
 
 	ExternalServerFile(const std::string&);
 	void addServer(const std::string&, const std::string&, int32_t);
+	void addServer(const std::string&, const std::string&, int32_t, bool_t);
 	void editServer(int32_t, const std::string&, const std::string&, int32_t);
+	void editServer(int32_t, const std::string&, const std::string&, int32_t, bool_t);
 	std::unordered_map<int32_t, ExternalServer>* getExternalServers();
 	void load();
 	void removeServer(int32_t);
diff --git a/modifiedeight-newadditions/headers/gui/screens/AddExternalServerScreen.hpp b/modifiedeight-newadditions/headers/gui/screens/AddExternalServerScreen.hpp
index bda6f511..78dfe798 100644
--- a/modifiedeight-newadditions/headers/gui/screens/AddExternalServerScreen.hpp
+++ b/modifiedeight-newadditions/headers/gui/screens/AddExternalServerScreen.hpp
@@ -18,8 +18,15 @@ struct AddExternalServerScreen: Screen
 	std::shared_ptr<TextBox> field_94;
 	std::shared_ptr<Label> field_9C;
 	std::shared_ptr<NinePatchLayer> field_A4;
+	// "Is this a Java server? (1.8.x)" - flips the entry between an MCPE 0.8.1
+	// server and a Minecraft Java Edition 1.8.x one.
+	std::shared_ptr<Button> javaToggleButton;
+	bool_t isJavaServer;
+
+	AddExternalServerScreen();
 
 	void closeScreen();
+	void refreshJavaToggle();
 
 	virtual ~AddExternalServerScreen();
 	virtual void render(int32_t, int32_t, float);
diff --git a/modifiedeight-newadditions/headers/gui/screens/EditExternalServerScreen.hpp b/modifiedeight-newadditions/headers/gui/screens/EditExternalServerScreen.hpp
index e49a7c11..b8db7b36 100644
--- a/modifiedeight-newadditions/headers/gui/screens/EditExternalServerScreen.hpp
+++ b/modifiedeight-newadditions/headers/gui/screens/EditExternalServerScreen.hpp
@@ -21,9 +21,13 @@ struct EditExternalServerScreen: Screen
 	std::shared_ptr<Label> field_9C;
 	std::shared_ptr<NinePatchLayer> field_A4;
 	ExternalServer server;
+	// "Is this a Java server? (1.8.x)" - see AddExternalServerScreen.
+	std::shared_ptr<Button> javaToggleButton;
+	bool_t isJavaServer;
 
 	EditExternalServerScreen(const ExternalServer&);
 	void closeScreen();
+	void refreshJavaToggle();
 
 	virtual ~EditExternalServerScreen();
 	virtual void render(int32_t, int32_t, float);
diff --git a/modifiedeight-newadditions/headers/java/JavaBridge.hpp b/modifiedeight-newadditions/headers/java/JavaBridge.hpp
new file mode 100644
index 00000000..aca73b25
--- /dev/null
+++ b/modifiedeight-newadditions/headers/java/JavaBridge.hpp
@@ -0,0 +1,49 @@
+#pragma once
+#include <_types.h>
+#include <string>
+
+struct Minecraft;
+struct Packet;
+struct JavaSession;
+
+/*
+ * The one global handle on the Java session.
+ *
+ * m8 can only be in one world at a time, so a single session is enough, and
+ * routing everything through statics keeps the edits in the engine down to
+ * one-line calls that read the same whether or not a Java server is involved.
+ */
+struct JavaBridge
+{
+	// Starts a session. host may carry a ":port" suffix; typedPort is the port
+	// column from the server list and is used when it does not.
+	static bool_t begin(Minecraft* minecraft, const std::string& displayName,
+	                    const std::string& host, int32_t typedPort);
+
+	// True from begin() until the session ends (cleanly or not).
+	static bool_t isActive();
+
+	// Called once per frame off RakNetInstance::runEvents. Safe to call always.
+	static void pump();
+
+	/*
+	 * Called once per game tick from LocalPlayer::tick, in place of m8's own
+	 * sendPosition().  A Java server wants to hear from the client every tick;
+	 * m8 reports only after a tenth of a block or a whole degree, which is far
+	 * too sparse for the movement checks on the other side.
+	 */
+	static void playerTick();
+
+	// Tears the session down and hands the client back to RakNet.
+	static void shutdown();
+
+	// Returns 1 when the packet was consumed by the Java session, in which case
+	// the caller must not touch RakNet. Returns 0 when no session is running.
+	static bool_t interceptSend(Packet* pk);
+
+	// Routes a typed chat line (commands included) to the Java server.
+	// Returns 0 when there is no session, so the caller falls back to MCPE.
+	static bool_t sendChat(const std::string& text);
+
+	static JavaSession* session();
+};
diff --git a/modifiedeight-newadditions/headers/java/JavaByteBuf.hpp b/modifiedeight-newadditions/headers/java/JavaByteBuf.hpp
new file mode 100644
index 00000000..ac5523c9
--- /dev/null
+++ b/modifiedeight-newadditions/headers/java/JavaByteBuf.hpp
@@ -0,0 +1,66 @@
+#pragma once
+#include <_types.h>
+#include <string>
+#include <vector>
+
+/*
+ * JavaByteBuf - big-endian byte buffer with the Minecraft Java Edition
+ * protocol primitives (VarInt, VarLong, String, UUID, Position).
+ *
+ * Reads are bounds checked; once a read runs past the end the buffer latches
+ * an error flag and every following read returns zero, so a truncated or
+ * malformed packet can never walk off the end of the storage.
+ */
+struct JavaByteBuf
+{
+	std::vector<uint8_t> bytes;
+	size_t readPos;
+	bool_t bad;
+
+	JavaByteBuf();
+	JavaByteBuf(const uint8_t*, size_t);
+
+	void clear();
+	void reset();
+	size_t remaining() const;
+	bool_t failed() const;
+	const uint8_t* data() const;
+	size_t size() const;
+
+	// ---- reading ----
+	uint8_t readByte();
+	int8_t readSByte();
+	bool_t readBool();
+	int16_t readShort();
+	uint16_t readUShort();
+	int32_t readInt();
+	int64_t readLong();
+	float readFloat();
+	double readDouble();
+	int32_t readVarInt();
+	int64_t readVarLong();
+	std::string readString(int32_t maxLen = 32767);
+	void readUUID(uint64_t* hi, uint64_t* lo);
+	void readPosition(int32_t* x, int32_t* y, int32_t* z);
+	void readBytes(uint8_t*, size_t);
+	void skip(size_t);
+
+	// ---- writing ----
+	void writeByte(uint8_t);
+	void writeSByte(int8_t);
+	void writeBool(bool_t);
+	void writeShort(int16_t);
+	void writeUShort(uint16_t);
+	void writeInt(int32_t);
+	void writeLong(int64_t);
+	void writeFloat(float);
+	void writeDouble(double);
+	void writeVarInt(int32_t);
+	void writeVarLong(int64_t);
+	void writeString(const std::string&);
+	void writePosition(int32_t, int32_t, int32_t);
+	void writeBytes(const uint8_t*, size_t);
+	void writeBuf(const JavaByteBuf&);
+
+	static int32_t varIntSize(int32_t);
+};
diff --git a/modifiedeight-newadditions/headers/java/JavaChat.hpp b/modifiedeight-newadditions/headers/java/JavaChat.hpp
new file mode 100644
index 00000000..6ec2bf69
--- /dev/null
+++ b/modifiedeight-newadditions/headers/java/JavaChat.hpp
@@ -0,0 +1,24 @@
+#pragma once
+#include <_types.h>
+#include <json/json.h>
+#include <string>
+
+/*
+ * Java's JSON text components, flattened into the plain strings m8 draws.
+ *
+ * Chat, disconnect reasons and a server list MOTD are all the same shape, so
+ * both the live session and the server list ping go through here.
+ */
+
+// Append the readable text of one component tree to *out.
+void javaChatFlatten(const Json::Value& node, std::string* out);
+
+/*
+ * Parse a component tree and flatten it, stripping the section-sign colour
+ * codes m8's font does not understand. A blob that is not valid JSON is handed
+ * back as-is, because some servers send a bare string.
+ */
+std::string javaChatToText(const std::string& json);
+
+// Flatten an already-parsed tree and strip its colour codes.
+std::string javaChatToText(const Json::Value& node);
diff --git a/modifiedeight-newadditions/headers/java/JavaChunkData.hpp b/modifiedeight-newadditions/headers/java/JavaChunkData.hpp
new file mode 100644
index 00000000..0d2e83bf
--- /dev/null
+++ b/modifiedeight-newadditions/headers/java/JavaChunkData.hpp
@@ -0,0 +1,38 @@
+#pragma once
+#include <_types.h>
+#include <stddef.h>
+
+struct Level;
+struct LevelChunk;
+
+/*
+ * JavaChunkData - decodes a Java Edition 1.8 chunk column payload straight into
+ * an m8 LevelChunk.
+ *
+ * The 1.8 payload is section major: for every bit set in the section mask, 4096
+ * little endian u16 block states (id << 4 | meta), then for every set bit 2048
+ * bytes of block light nibbles, then - on a dimension with sky - 2048 bytes of
+ * sky light nibbles per set bit, and finally 256 biome bytes when the column is
+ * a full "ground up" send.
+ *
+ * Neither the block array nor the nibble arrays can be memcpy'd across.  Java
+ * indexes a section as (y << 8) | (z << 4) | x while m8 indexes a whole column
+ * as y | (x << 11) | (z << 7), so every block and every nibble is transposed
+ * individually, and every block state goes through JavaIdMap on the way.
+ */
+struct JavaChunkData
+{
+	// Bytes one column occupies on the wire, for slicing a Map Chunk Bulk blob.
+	static size_t payloadSize(int32_t sectionMask, bool_t hasSkyLight, bool_t groundUp);
+
+	/*
+	 * Writes one column into `chunk`. Returns the number of bytes consumed, or 0
+	 * if the payload was short (in which case nothing is written).
+	 */
+	static size_t apply(Level* level, LevelChunk* chunk, const uint8_t* data, size_t len,
+	                    int32_t sectionMask, bool_t groundUp, bool_t hasSkyLight);
+
+	// Recomputes heightMap[] and topBlockY the way LevelChunk::recalcHeightmap would,
+	// without touching the sky light the server just gave us.
+	static void recomputeHeights(LevelChunk* chunk);
+};
diff --git a/modifiedeight-newadditions/headers/java/JavaChunkSource.hpp b/modifiedeight-newadditions/headers/java/JavaChunkSource.hpp
new file mode 100644
index 00000000..c9463027
--- /dev/null
+++ b/modifiedeight-newadditions/headers/java/JavaChunkSource.hpp
@@ -0,0 +1,67 @@
+#pragma once
+#include <_types.h>
+#include <level/gen/ChunkSource.hpp>
+#include <string>
+#include <vector>
+
+struct LevelChunk;
+struct Level;
+
+/*
+ * A server authoritative ChunkSource used only by Java (1.8.x) sessions.
+ *
+ * The stock ChunkCache pulls columns out of a local terrain generator and a
+ * local chunk file.  For a Java session neither of those exist: every column we
+ * are ever allowed to show comes straight out of the socket.  This source
+ * therefore never generates and never saves - it hands out blank columns and
+ * JavaChunkData fills them in when the matching Chunk Data packet arrives.
+ *
+ * Residency uses the same bounded 64x64 grid ChunkCache uses
+ * (`(x & 0x3F) + 64 * (z & 0x3F)`), so walking a long way recycles slots
+ * instead of growing without bound, and it does it through the same code shape
+ * the engine already trusts for entity/renderer bookkeeping.
+ *
+ * A blank column is not entirely empty: it carries one layer of bedrock at
+ * m8 y 0.  That mirrors a real Java overworld (which always has bedrock at
+ * y 0, so the first Chunk Data packet overwrites it with the same thing), it
+ * stops the player falling out of the world through a column the server has
+ * not sent yet, and - critically - it keeps Level::validateSpawn() from
+ * spinning forever: that loop runs before any chunk data can arrive and only
+ * terminates once getTopTile() finds something that is neither air nor
+ * invisible_bedrock.
+ */
+struct JavaChunkSource: ChunkSource {
+	static const int32_t GRID = 64;
+	static const int32_t GRID_MASK = 63;
+	static const int32_t SLOTS = 4096;
+
+	Level* level;
+	LevelChunk* emptyChunk;
+	LevelChunk* chunks[JavaChunkSource::SLOTS];
+	int32_t lastChunkX, lastChunkZ;
+	LevelChunk* lastChunk;
+	int32_t residentCount;
+
+	JavaChunkSource(Level* level);
+
+	static int32_t slotOf(int32_t x, int32_t z);
+
+	// Lookup that never allocates. Returns 0 when the column is not resident.
+	LevelChunk* find(int32_t x, int32_t z);
+	// Lookup that allocates a blank column (bedrock floor) when missing.
+	LevelChunk* obtain(int32_t x, int32_t z);
+	// Server told us to forget this column.
+	void drop(int32_t x, int32_t z);
+	void dropAll();
+
+	virtual ~JavaChunkSource();
+	virtual bool_t hasChunk(int32_t, int32_t);
+	virtual LevelChunk* getChunk(int32_t, int32_t);
+	virtual LevelChunk* create(int32_t, int32_t);
+	virtual void postProcess(ChunkSource*, int32_t, int32_t);
+	virtual bool_t tick();
+	virtual bool_t shouldSave();
+	virtual void saveAll(bool_t);
+	virtual std::vector<Biome::MobSpawnerData> getMobsAt(const MobCategory&, int32_t, int32_t, int32_t);
+	virtual std::string gatherStats();
+};
diff --git a/modifiedeight-newadditions/headers/java/JavaIdMap.hpp b/modifiedeight-newadditions/headers/java/JavaIdMap.hpp
new file mode 100644
index 00000000..4739126b
--- /dev/null
+++ b/modifiedeight-newadditions/headers/java/JavaIdMap.hpp
@@ -0,0 +1,43 @@
+#pragma once
+#include <_types.h>
+
+/*
+ * JavaIdMap - ID translation between Minecraft Java Edition 1.8 and m8.
+ *
+ * This is the single place that knows the two ID spaces are different, and it
+ * has to be a real table rather than the identity: modifiedeight-newadditions
+ * has claimed a lot of the higher vanilla block IDs for its own blocks.
+ * Java 115-122 are nether wart / enchanting table / brewing stand / ... while
+ * in m8 those same IDs are coloured logs; Java 174-189 are packed ice, double
+ * plants, banners and red sandstone while in m8 they are coloured fences; and
+ * so on for 125-137, 143-166, 159-162, 190-197. Feeding a Java block ID
+ * straight into Tile would fill the world with coloured fences, so every ID is
+ * mapped explicitly.
+ *
+ * Where m8 has no equivalent at all the mapping falls back to the closest
+ * lookalike (packed ice -> ice, red sandstone -> sandstone, mycelium -> grass,
+ * hopper -> iron block) and to air for purely technical or flat blocks
+ * (redstone wire, tripwire, pistons extensions, banners).
+ */
+struct JavaIdMap
+{
+	// Java 1.8 block state -> m8 tile id + meta. Writes 0/0 for "nothing here".
+	static void javaBlockToM8(int32_t javaId, int32_t javaMeta, int32_t* outId, int32_t* outMeta);
+	// m8 tile -> Java 1.8 block state. Used when we have to name a block to the server.
+	static void m8BlockToJava(int32_t m8Id, int32_t m8Meta, int32_t* outId, int32_t* outMeta);
+
+	// Item ids. Both sides use 1..197 for block items and 256.. for real items.
+	static int32_t javaItemToM8(int32_t javaItemId);
+	static int32_t m8ItemToJava(int32_t m8ItemId);
+
+	/*
+	 * Mob types. m8 only implements nine mobs (chicken 10, cow 11, pig 12,
+	 * sheep 13, zombie 32, creeper 33, skeleton 34, spider 35, pig zombie 36),
+	 * so every Java mob is folded onto the nearest one - endermen and villagers
+	 * become humanoids, slimes and magma cubes become creepers, bats and
+	 * rabbits become chickens. Returns 0 when there is nothing sensible.
+	 */
+	static int32_t javaMobToM8(int32_t javaType);
+	// Java "object" spawn types (SpawnObject) -> m8 EntityFactory types.
+	static int32_t javaObjectToM8(int32_t javaObjectType);
+};
diff --git a/modifiedeight-newadditions/headers/java/JavaLog.hpp b/modifiedeight-newadditions/headers/java/JavaLog.hpp
new file mode 100644
index 00000000..0e6016e0
--- /dev/null
+++ b/modifiedeight-newadditions/headers/java/JavaLog.hpp
@@ -0,0 +1,26 @@
+#pragma once
+#include <_types.h>
+
+/*
+ * Diagnostics for the Java Edition session.
+ *
+ * javaLog is for the handful of milestones (and failures) a player or a bug
+ * report needs to see; it always prints.  javaDebug is per packet noise and only
+ * prints when M8_JAVA_DEBUG is set to something other than 0 in the
+ * environment, so a normal session stays quiet.
+ */
+/*
+ * Let the compiler check the varargs.  Android builds five ABIs, three of them
+ * 32 bit, where handing a 64 bit or size_t value to %d prints rubbish.
+ */
+#if defined(__GNUC__) || defined(__clang__)
+#define JAVA_LOG_FORMAT __attribute__((format(printf, 1, 2)))
+#else
+#define JAVA_LOG_FORMAT
+#endif
+
+void javaLog(const char_t* fmt, ...) JAVA_LOG_FORMAT;
+void javaDebug(const char_t* fmt, ...) JAVA_LOG_FORMAT;
+bool_t javaDebugEnabled();
+// M8_JAVA_DEBUG=2: also name every packet in both directions.
+bool_t javaTraceEnabled();
diff --git a/modifiedeight-newadditions/headers/java/JavaPing.hpp b/modifiedeight-newadditions/headers/java/JavaPing.hpp
new file mode 100644
index 00000000..5e5e7896
--- /dev/null
+++ b/modifiedeight-newadditions/headers/java/JavaPing.hpp
@@ -0,0 +1,52 @@
+#pragma once
+#include <_types.h>
+#include <string>
+
+/*
+ * Server List Ping for the Java Edition entries in m8's server list.
+ *
+ * m8 learns whether an MCPE server is up from RakNet's broadcast pings, and a
+ * Java server answers none of those, so a Java entry used to sit on
+ * "Loading..." for ever even though joining it worked perfectly.  Java has its
+ * own status handshake - the same one the vanilla server list uses: connect,
+ * handshake with next state 1, ask, and read back a single JSON blob carrying
+ * the MOTD, the player counts and the version.
+ *
+ * The query blocks, so it runs on a detached thread and drops its answer into a
+ * cache; get() only ever reads that cache and starts a thread when there is
+ * nothing fresh in it.  Render code can therefore call get() every frame.
+ */
+struct JavaPingResult
+{
+	enum State
+	{
+		// No answer yet - either the first query is in flight or one is about to be.
+		PENDING = 0,
+		ONLINE,
+		// Refused, timed out, unresolvable, or answered with something unreadable.
+		OFFLINE
+	};
+
+	State state;
+	// First line of the MOTD, colour codes stripped.
+	std::string motd;
+	// Whatever the server calls its version, e.g. "1.8.9" or "Spigot 1.8.8".
+	std::string version;
+	// Protocol number the server reports; 47 is 1.8.x, which is what m8 speaks.
+	int32_t protocol;
+	int32_t online, max;
+	// Round trip of the status exchange, in milliseconds.
+	int32_t latencyMs;
+
+	JavaPingResult();
+};
+
+struct JavaPing
+{
+	/*
+	 * The status of host:typedPort.  host may carry its own ":port" suffix and
+	 * may resolve through an SRV record, exactly as when joining.  Returns
+	 * PENDING until an answer lands; never blocks.
+	 */
+	static JavaPingResult get(const std::string& host, int32_t typedPort);
+};
diff --git a/modifiedeight-newadditions/headers/java/JavaSession.hpp b/modifiedeight-newadditions/headers/java/JavaSession.hpp
new file mode 100644
index 00000000..b38b012a
--- /dev/null
+++ b/modifiedeight-newadditions/headers/java/JavaSession.hpp
@@ -0,0 +1,282 @@
+#pragma once
+#include <_types.h>
+#include <java/JavaByteBuf.hpp>
+#include <java/JavaSocket.hpp>
+#include <map>
+#include <string>
+#include <vector>
+
+struct Minecraft;
+struct MultiPlayerLevel;
+struct LocalPlayer;
+struct Entity;
+struct JavaChunkSource;
+struct Packet;
+
+/*
+ * One connection to a Minecraft Java Edition 1.8.x server, spoken natively.
+ *
+ * Everything happens on the main thread: pump() is driven from
+ * RakNetInstance::runEvents, which Minecraft::update already calls once per
+ * frame before ticking, so this sits exactly where the RakNet receive loop
+ * would have been and inherits its threading guarantees.
+ *
+ * The socket is non blocking and nothing here ever waits, so a slow or dead
+ * server costs one frame at worst.
+ *
+ * Only offline mode ("cracked") servers can be joined: implementing the
+ * Yggdrasil handshake would mean shipping the player's Mojang credentials
+ * through a client that has no account system.  A server that asks for
+ * encryption is reported as such instead of failing obscurely.
+ */
+struct JavaSession {
+	enum Phase {
+		IDLE = 0,
+		CONNECTING = 1,
+		LOGIN = 2,
+		PLAY = 3,
+		CLOSED = 4
+	};
+
+	static const int32_t PROTOCOL = 47;
+	// A 1.8 server never legitimately sends a frame anywhere near this big.
+	static const int32_t MAX_FRAME = 8 * 1024 * 1024;
+	// Chunk traffic while the level is still being built has to be kept, not
+	// dropped: a Java server sends each column exactly once.
+	static const size_t MAX_DEFERRED = 96u * 1024u * 1024u;
+
+	// ---- wire ----
+	JavaSocket socket;
+	std::vector<uint8_t> inBuf;
+	size_t inOff;
+	std::vector<uint8_t> outBuf;
+	size_t outOff;
+	int32_t compressionThreshold; // -1 until the server enables compression
+	Phase phase;
+
+	// ---- target ----
+	std::string displayName;
+	std::string handshakeHost; // what the player typed, for virtual host routing
+	std::string ip;            // what we actually connect to
+	std::string username;
+	int32_t port;
+
+	// ---- error reporting ----
+	std::string failure;
+	bool_t reportedFailure;
+
+	// ---- engine ----
+	Minecraft* minecraft;
+	MultiPlayerLevel* level;
+	JavaChunkSource* chunkSource;
+	LocalPlayer* player;
+	bool_t levelRequested;
+	bool_t levelLive;
+
+	// ---- join info ----
+	int32_t serverEid;
+	int32_t gamemode;
+	int32_t dimension;
+	bool_t hasSkyLight;
+	double posX, posY, posZ;
+	float rotYaw, rotPitch;
+	bool_t havePosition;
+
+	// ---- inbound held back until the level exists ----
+	std::vector<std::vector<uint8_t> > deferred;
+	size_t deferredBytes;
+	bool_t deferredOverflowed;
+
+	// ---- outbound bookkeeping ----
+	int32_t tickCounter;
+	double sentX, sentY, sentZ;
+	float sentYaw, sentPitch;
+	bool_t sentGround;
+	bool_t everSentPosition;
+	/*
+	 * Vanilla's EntityPlayerSP.positionUpdateTicks: how many ticks have gone by
+	 * without a full position going out.  Twenty of them and one is sent whether
+	 * anything moved or not, which is what keeps the server's idea of where we
+	 * are from drifting.
+	 */
+	int32_t positionUpdateTicks;
+	bool_t sentSprint;
+	bool_t sentSneak;
+	// getTimeMs() of the last movement packet, for the idle fallback in pump().
+	int32_t lastMoveSentMs;
+	/*
+	 * A second's worth of movement packets, counted by kind, for the debug log.
+	 * A Java client sends exactly twenty a second and a server that measures
+	 * anything about how a player moves - a fall, a walk speed, a verification
+	 * lobby - is really measuring against that number, so it is worth being able
+	 * to see ours.
+	 */
+	int32_t moveWindowMs;
+	int32_t moveWindow[4];
+
+	/*
+	 * Java identifies a held item by its own item id, and m8's item ids only
+	 * partly line up.  Rather than round trip through the id map (which is lossy
+	 * in the outbound direction) the raw Slot bytes the server sent for each
+	 * hotbar index are kept verbatim and echoed back in Player Block Placement,
+	 * which is what the server compares against.
+	 */
+	std::vector<uint8_t> hotbar[9];
+	int32_t selectedSlot;
+
+	// uuid low 64 bits -> name, filled from Player List Item, used by Spawn Player
+	std::map<uint64_t, std::string> playerNames;
+	// Java entity ids of dropped items whose ItemStack has not arrived yet
+	std::map<int32_t, bool_t> pendingItems;
+	// every Java entity id we have spawned locally
+	std::map<int32_t, bool_t> knownEntities;
+	/*
+	 * A Java server hands an entity id straight back out again as soon as the
+	 * mob wearing it despawns, while m8 keeps a removed entity alive for a
+	 * tick or two before deleting it (Level::tickEntities).  Corpses are
+	 * therefore re-keyed onto private ids counting down from -2 so the
+	 * level's own id table never has two owners for one id.
+	 */
+	int32_t nextParkedEid;
+	/*
+	 * Frames left to hold the player still after a Respawn.
+	 *
+	 * A dimension change throws away every column, and the replacements arrive
+	 * over the next second or so.  Until they do the player is standing over
+	 * nothing but the bedrock floor JavaChunkSource lays into a column it knows
+	 * nothing about yet, and left alone would free fall the whole way down and
+	 * be dragged back up by the server - which is what made the nether portal
+	 * look broken.  While this is counting down the player is pinned to the
+	 * position the server last gave us; it is cleared early as soon as real
+	 * terrain is standing underneath them.
+	 */
+	int32_t respawnHold;
+
+	/*
+	 * The last Player Abilities flags the server sent, kept because it always
+	 * sends them before the level exists.  NetHandlerPlayClient can apply them
+	 * straight away - its player is made the instant Join Game lands - while m8
+	 * builds the level on a worker thread and has no player to write to for the
+	 * best part of a second, so the packet used to be read and thrown away.
+	 * That is how a survival player ended up able to fly: nothing ever told the
+	 * client what the server actually allows.
+	 */
+	int32_t abilityFlags;
+	bool_t hasAbilityFlags;
+
+	JavaSession();
+	~JavaSession();
+
+	bool_t begin(Minecraft* mc, const std::string& name, const std::string& host,
+	             int32_t typedPort, const std::string& user);
+	void pump();
+	void shutdown();
+	bool_t isActive() const;
+
+	// Returns 1 when the MCPE packet was consumed (translated or deliberately
+	// dropped) and must not reach RakNet.
+	bool_t interceptSend(Packet* pk);
+	// Chat text straight from the chat screen, '/' commands included.
+	void sendChatLine(const std::string& text);
+
+	// ---- wire plumbing ----
+	void fail(const std::string& why);
+	void flushOut();
+	void pumpSocket();
+	void dispatchFrames();
+	void send(const JavaByteBuf& payload);
+	void beginPacket(JavaByteBuf* out, int32_t id);
+	bool_t decodeFrame(const uint8_t* raw, size_t rawLen, JavaByteBuf* out);
+	void compactIn();
+
+	// ---- protocol ----
+	void sendHandshakeAndLogin();
+	void handleLoginPacket(JavaByteBuf* in, int32_t id);
+	void handlePlayPacket(JavaByteBuf* in, int32_t id);
+	void deferFrame(const JavaByteBuf& frame, int32_t id);
+	void flushDeferred();
+
+	// ---- world ----
+	void createLevel();
+	// Everything a Respawn (dimension change or death) has to unwind.
+	void resetForRespawn();
+	// See respawnHold.  Called once a frame, does nothing when not holding.
+	void holdPlayerForTerrain();
+	/*
+	 * Java has four game modes and m8 has two.  Survival and adventure are both
+	 * "not creative" as far as the abilities go, and spectator is the closest
+	 * thing to creative that exists here.
+	 */
+	bool_t isCreativeGamemode() const;
+	// Push the current gamemode, then the server's abilities, onto the player.
+	void applyGameMode();
+	void applyAbilities();
+	void applyChunk(int32_t cx, int32_t cz, int32_t mask, bool_t groundUp,
+	                bool_t skyLight, const uint8_t* data, size_t len);
+	void setJavaBlock(int32_t jx, int32_t jy, int32_t jz, int32_t state);
+	void applyInventorySlot(int32_t javaSlot, int32_t itemId, int32_t count, int32_t damage,
+	                        const std::vector<uint8_t>& raw);
+	/*
+	 * Signs.  A sign is two things in 0.8.1: a block, which arrives with the
+	 * chunk or as a Block Change, and a SignTileEntity, which is what actually
+	 * draws the post, the board and the four lines.  Chunk data never carries
+	 * tile entities, so without this the block is there and nothing is drawn -
+	 * SignTile::getRenderShape() is -1, so the chunk mesher contributes nothing
+	 * at all and the sign is invisible.  The server sends Update Sign for every
+	 * sign in a chunk right after the chunk itself, which is where the text and
+	 * the tile entity both come from.
+	 */
+	void applySignText(int32_t jx, int32_t jy, int32_t jz, const std::string* lines);
+	// Sends the four lines of a sign the local player just finished editing.
+	void sendSignText(int32_t mx, int32_t my, int32_t mz);
+
+	// ---- entities ----
+	Entity* findEntity(int32_t javaEid);
+	void attachEntity(int32_t javaEid, Entity* e);
+	void retireEntity(Entity* old);
+	void spawnMob(JavaByteBuf* in);
+	void spawnObject(JavaByteBuf* in);
+	void spawnPlayer(JavaByteBuf* in);
+	void moveEntity(int32_t javaEid, double dx, double dy, double dz,
+	                bool_t hasRot, float yaw, float pitch, bool_t absolute);
+	void destroyEntity(int32_t javaEid);
+	// Consumes a DataWatcher blob. Returns the ItemStack at index 10 when the
+	// blob carries one (that is how a dropped item announces what it is).
+	bool_t readMetadata(JavaByteBuf* in, int32_t* outItemId, int32_t* outCount,
+	                    int32_t* outDamage);
+	bool_t readSlot(JavaByteBuf* in, int32_t* outId, int32_t* outCount, int32_t* outDamage,
+	                std::vector<uint8_t>* rawOut);
+	void skipNbt(JavaByteBuf* in);
+	// Walks a Java (big endian) tile entity tag and picks out Text1..Text4.
+	// Returns 0 when the tag was malformed; the buffer is consumed either way.
+	bool_t readSignNbt(JavaByteBuf* in, std::string* lines);
+
+	// ---- outbound helpers ----
+	void sendKeepAlive(int32_t id);
+	/*
+	 * The equivalent of EntityPlayerSP.onUpdateWalkingPlayer, called once per
+	 * game tick from LocalPlayer::tick.  A Java server expects to hear from the
+	 * client every single tick - the packet may say nothing more than "still on
+	 * the ground", but it is that steady beat the server counts ticks by, and
+	 * the anti-bot checks public servers run reject a client that reports only
+	 * when it feels like it.
+	 */
+	void playerTick();
+	void sendPositionNow(bool_t force);
+	// Sneak and sprint state changes (0x0B Entity Action).
+	void sendEntityAction(int32_t action);
+	void sendDigging(int32_t status, int32_t jx, int32_t jy, int32_t jz, int32_t face);
+	void sendHeldSlot(int32_t slot);
+	// Notices that the player picked a different hotbar slot and tells the server.
+	void syncHeldSlot();
+	void writeHeldStack(JavaByteBuf* out);
+	// Creative only: hand the server everything m8 is already carrying.
+	void pushCreativeInventory();
+	void sendCreativeSlot(int32_t javaSlot, const struct ItemInstance* item);
+	void sendClientSettings();
+	// "MC|Brand": every real client announces what it is right after Join Game.
+	void sendClientBrand();
+	// Answers 0x48 Resource Pack Send, which some servers wait on before letting
+	// the player through.
+	void sendResourcePackStatus(const std::string& hash, int32_t status);
+};
diff --git a/modifiedeight-newadditions/headers/java/JavaSocket.hpp b/modifiedeight-newadditions/headers/java/JavaSocket.hpp
new file mode 100644
index 00000000..bc8e2fe8
--- /dev/null
+++ b/modifiedeight-newadditions/headers/java/JavaSocket.hpp
@@ -0,0 +1,57 @@
+#pragma once
+#include <_types.h>
+#include <string>
+#include <vector>
+
+/*
+ * JavaSocket - minimal non-blocking TCP client plus the DNS lookups the Java
+ * Edition server list needs.
+ *
+ * Minecraft Java servers are addressed through an SRV record
+ * (_minecraft._tcp.<host>) whenever the operator does not run on the default
+ * port; aternos hosts in particular hand out a random high port that way. So a
+ * plain A lookup is not enough - we resolve SRV first and only fall back to
+ * (host, port-as-typed) when there is no SRV record.
+ */
+struct JavaSocket
+{
+	enum State
+	{
+		CLOSED = 0,
+		CONNECTING,
+		CONNECTED,
+		FAILED
+	};
+
+	int64_t fd;
+	State state;
+	std::string lastError;
+
+	JavaSocket();
+	~JavaSocket();
+
+	// Starts a non-blocking connect. Returns 0 and sets lastError on immediate failure.
+	bool_t beginConnect(const std::string& ip, int32_t port);
+	// Drives an in-progress connect. Call every frame while state == CONNECTING.
+	void pumpConnect();
+	// Returns bytes read (>0), 0 for "nothing available", -1 for closed/error.
+	int32_t recvSome(uint8_t* dst, int32_t cap);
+	// Returns bytes written (may be less than len), or -1 on error.
+	int32_t sendSome(const uint8_t* src, int32_t len);
+	void close();
+
+	static void globalInit();
+
+	/*
+	 * Resolves a user-typed "host" (with the port they typed as fallback) into
+	 * a numeric address and port. Consults _minecraft._tcp.<host> SRV first.
+	 * Returns 0 if nothing could be resolved.
+	 */
+	static bool_t resolveMinecraftHost(const std::string& host, int32_t typedPort,
+	                                   std::string* outIp, int32_t* outPort,
+	                                   std::string* outConnectHost);
+	// Raw A/AAAA lookup via the platform resolver.
+	static bool_t resolveAddress(const std::string& host, std::string* outIp);
+	// Raw SRV lookup, implemented as a UDP DNS query so it behaves the same everywhere.
+	static bool_t resolveSrv(const std::string& fqdn, std::string* outTarget, int32_t* outPort);
+};
diff --git a/modifiedeight-newadditions/headers/java/JavaY.hpp b/modifiedeight-newadditions/headers/java/JavaY.hpp
new file mode 100644
index 00000000..9f25fc39
--- /dev/null
+++ b/modifiedeight-newadditions/headers/java/JavaY.hpp
@@ -0,0 +1,46 @@
+#pragma once
+#include <_types.h>
+#include <level/LevelHeight.hpp>
+
+/*
+ * JavaY - the single place that knows how a Java Y relates to an m8 Y.
+ *
+ * Minecraft Java Edition 1.8 worlds are 256 blocks tall and m8's are 128, so a
+ * Java session asks for a 256 tall level (LevelHeight::set(JAVA_HEIGHT) before
+ * the level is built) and the two agree block for block: BASE is 0, so toM8 and
+ * toJava are the identity and nothing is clipped.
+ *
+ * The translation is kept anyway rather than deleted, for two reasons.  It is
+ * the thing to change if the window ever has to move (a shorter level, or the
+ * top half of a world instead of the bottom), and it is the safety net: every
+ * range check below asks LevelHeight what the level actually is, so if a session
+ * ever ends up running against a 128 tall level the world is clipped at 128
+ * instead of writing past the end of a column buffer.
+ */
+struct JavaY
+{
+	// The Java Y that lands on m8 Y 0.
+	static const int32_t BASE = 0;
+	// What a Java server believes the world height to be, always 256.
+	static const int32_t HEIGHT = JAVA_HEIGHT;
+
+	static inline int32_t toM8(int32_t javaY) { return javaY - BASE; }
+	static inline int32_t toJava(int32_t m8Y) { return m8Y + BASE; }
+	static inline double toM8d(double javaY) { return javaY - (double)BASE; }
+	static inline double toJavad(double m8Y) { return m8Y + (double)BASE; }
+
+	// Does this Java Y have somewhere to live in the level as it stands?
+	static inline bool_t inRange(int32_t javaY) { return LevelHeight::inRange(javaY - BASE); }
+	// Section index (0..15) entirely outside the level, so it can be skipped wholesale.
+	static inline bool_t sectionVisible(int32_t section)
+	{
+		int32_t lo = section * 16 - BASE;
+		return lo + 15 >= 0 && lo < LevelHeight::height;
+	}
+	static inline int32_t clampM8(int32_t m8Y)
+	{
+		if(m8Y < 0) return 0;
+		if(m8Y > LevelHeight::maxY()) return LevelHeight::maxY();
+		return m8Y;
+	}
+};
diff --git a/modifiedeight-newadditions/headers/level/LevelHeight.hpp b/modifiedeight-newadditions/headers/level/LevelHeight.hpp
new file mode 100644
index 00000000..abfd29ae
--- /dev/null
+++ b/modifiedeight-newadditions/headers/level/LevelHeight.hpp
@@ -0,0 +1,74 @@
+#pragma once
+#include <_types.h>
+
+/*
+ * World height, and the shape of a chunk column.
+ *
+ * m8 is a 128 tall game: its region files, its MCPE network protocol and its
+ * level generators all deal in 16x16x128 columns, and a pile of tile and
+ * lighting code has 127 written straight into it.  A Minecraft Java 1.8
+ * server, on the other hand, always sends 256 tall columns.
+ *
+ * So the height is a runtime value, and it is 128 for absolutely everything
+ * except a live crossplay session against a Java server:
+ *
+ *   height    128                          256
+ *   used by   single player worlds,         a Java (1.8.x) session only
+ *             MCPE servers, MCPE clients
+ *   layout    y | (x << 11) | (z << 7)     y | (x << 12) | (z << 8)
+ *   column    32768 tiles, 16384 nibbles   65536 tiles, 32768 nibbles
+ *
+ * At 128 that is byte for byte the layout the game has always used, which is
+ * what keeps saved worlds safe: the region file format is the raw column
+ * buffer, and in a saved world the buffer is exactly the shape it always was.
+ * Nothing is converted, nothing is padded, and a world saved by this build is
+ * the same file a world saved by any other build is.  The tall layout only ever
+ * exists in memory, for a level that is never written to disk.
+ *
+ * One value for the whole process is enough: m8 holds at most one level at a
+ * time, and set() is called immediately before that level is built.
+ */
+
+// ---- the MCPE column: what the region files and the MCPE packets speak ------
+#define MCPE_HEIGHT  128
+#define MCPE_X_SHIFT 11
+#define MCPE_Z_SHIFT 7
+#define MCPE_TILES   (16 * 16 * MCPE_HEIGHT) /* 32768 */
+#define MCPE_NIBBLES (MCPE_TILES / 2)        /* 16384 */
+
+// ---- the tall column a Java server sends ------------------------------------
+#define JAVA_HEIGHT  256
+#define JAVA_X_SHIFT 12
+#define JAVA_Z_SHIFT 8
+#define JAVA_TILES   (16 * 16 * JAVA_HEIGHT) /* 65536 */
+
+// LevelChunk::miniChunkEntities is bucketed per 16 blocks of height and is
+// sized for the tall case either way: eight spare empty vectors per chunk is
+// not worth making the bucket count dynamic over.
+#define CHUNK_MINIS (JAVA_HEIGHT / 16) /* 16 */
+
+struct LevelHeight {
+	// 128 (everything) or 256 (a Java session). Never anything else.
+	static int32_t height;
+	// The x and z shifts of the current column layout: 11/7 at 128, 12/8 at 256.
+	static int32_t xShift;
+	static int32_t zShift;
+	// Tiles per chunk, and the DataLayer size that goes with it.
+	static int32_t tiles;
+
+	static void set(int32_t h);
+
+	// The highest y a block may occupy.
+	static int32_t maxY() {
+		return LevelHeight::height - 1;
+	}
+	static bool_t inRange(int32_t y) {
+		return (uint32_t)y < (uint32_t)LevelHeight::height;
+	}
+	static bool_t isTall() {
+		return LevelHeight::height > MCPE_HEIGHT;
+	}
+	static int32_t index(int32_t x, int32_t y, int32_t z) {
+		return y | (x << LevelHeight::xShift) | (z << LevelHeight::zShift);
+	}
+};
diff --git a/modifiedeight-newadditions/headers/level/chunk/LevelChunk.hpp b/modifiedeight-newadditions/headers/level/chunk/LevelChunk.hpp
index 9119888f..fa1666d9 100644
--- a/modifiedeight-newadditions/headers/level/chunk/LevelChunk.hpp
+++ b/modifiedeight-newadditions/headers/level/chunk/LevelChunk.hpp
@@ -1,5 +1,6 @@
 #pragma once
 #include <_types.h>
+#include <level/LevelHeight.hpp>
 #include <level/storage/DataLayer.hpp>
 #include <vector>
 #include <unordered_map>
@@ -14,7 +15,19 @@ struct LevelChunk
 	int8_t field_9, field_A, field_B;
 	struct Level* level;
 	DataLayer tileMeta, skyLight, blockLight;
-	uint8_t heightMap[256];
+	/*
+	 * The lowest y in a column with nothing opaque above it.  A 256 tall world
+	 * can push that to 256, one past what a byte holds, so this is wider than
+	 * the one the original game had - nothing serialises it (it is recomputed
+	 * on load), so widening it costs nothing.
+	 */
+	uint16_t heightMap[256];
+	/*
+	 * Per column bitmask of which 16 block sections changed.  Deliberately still
+	 * eight bits wide: its only readers are the region files and the MCPE chunk
+	 * packet, both of which are 128 tall formats, so sections above 128 are not
+	 * tracked and neither of those two ever sees a tall level.
+	 */
 	int8_t updateMap[256];
 	int32_t topBlockY;
 	int32_t chunkX, chunkZ;
@@ -25,7 +38,7 @@ struct LevelChunk
 	int32_t field_250;
 	uint8_t* tiles;
 	int8_t field_258, field_259, field_25A, field_25B;
-	std::vector<struct Entity*> miniChunkEntities[8];
+	std::vector<struct Entity*> miniChunkEntities[CHUNK_MINIS];
 	std::unordered_map<TilePos, struct TileEntity*> tileEntities;
 
 	LevelChunk(struct Level*, int32_t, int32_t);
diff --git a/modifiedeight-newadditions/impl/ExternalServer.cpp b/modifiedeight-newadditions/impl/ExternalServer.cpp
index 0808647b..99097396 100644
--- a/modifiedeight-newadditions/impl/ExternalServer.cpp
+++ b/modifiedeight-newadditions/impl/ExternalServer.cpp
@@ -5,10 +5,13 @@ ExternalServer::ExternalServer(const ExternalServer& a2) {
 	this->field_4 = a2.field_4;
 	this->field_8 = a2.field_8;
 	this->field_C = a2.field_C;
+	this->isJava = a2.isJava;
 }
 
 ExternalServer::ExternalServer(){
-
+	this->field_0 = 0;
+	this->field_C = 0;
+	this->isJava = 0;
 }
 
 ExternalServer::ExternalServer(int32_t a2, const std::string& a3, const std::string& a4, int32_t a5) {
@@ -16,4 +19,13 @@ ExternalServer::ExternalServer(int32_t a2, const std::string& a3, const std::str
 	this->field_4 = a3;
 	this->field_8 = a4;
 	this->field_C = a5;
+	this->isJava = 0;
+}
+
+ExternalServer::ExternalServer(int32_t a2, const std::string& a3, const std::string& a4, int32_t a5, bool_t a6) {
+	this->field_0 = a2;
+	this->field_4 = a3;
+	this->field_8 = a4;
+	this->field_C = a5;
+	this->isJava = a6;
 }
diff --git a/modifiedeight-newadditions/impl/ExternalServerFile.cpp b/modifiedeight-newadditions/impl/ExternalServerFile.cpp
index 7aab06dd..5b918d5a 100644
--- a/modifiedeight-newadditions/impl/ExternalServerFile.cpp
+++ b/modifiedeight-newadditions/impl/ExternalServerFile.cpp
@@ -8,12 +8,15 @@ ExternalServerFile::ExternalServerFile(const std::string& a2) {
 	this->fileName = a2 + "/external_servers.txt";
 }
 void ExternalServerFile::addServer(const std::string& a2, const std::string& a3, int32_t a4) {
+	this->addServer(a2, a3, a4, 0);
+}
+void ExternalServerFile::addServer(const std::string& a2, const std::string& a3, int32_t a4, bool_t a5) {
 	int32_t i;
 	for(i = 1; i <= 59999 && this->field_0.find(i) != this->field_0.end(); ++i) {
 	}
 
 	{
-		ExternalServer v10(i, a2, a3, a4);
+		ExternalServer v10(i, a2, a3, a4, a5);
 		ExternalServer v12(v10);
 		this->field_0[i] = v12;
 		//~v12, ~v10
@@ -21,11 +24,17 @@ void ExternalServerFile::addServer(const std::string& a2, const std::string& a3,
 	this->save();
 }
 void ExternalServerFile::editServer(int32_t a2, const std::string& a3, const std::string& a4, int32_t a5) {
+	auto v8 = this->field_0.find(a2);
+	bool_t java = v8 != this->field_0.end() ? v8->second.isJava : 0;
+	this->editServer(a2, a3, a4, a5, java);
+}
+void ExternalServerFile::editServer(int32_t a2, const std::string& a3, const std::string& a4, int32_t a5, bool_t a6) {
 	auto v8 = this->field_0.find(a2);
 	if(v8 != this->field_0.end()) {
 		v8->second.field_4 = a3;
 		v8->second.field_8 = a4;
 		v8->second.field_C = a5;
+		v8->second.isJava = a6;
 	}
 	this->save();
 }
@@ -52,13 +61,16 @@ void ExternalServerFile::load() {
 					v11.emplace_back(v13);
 				}
 
-				if(v11.size() == 4) {
+				// Four fields is the original layout; a fifth holds the Java
+				// flag. Both are accepted so older server lists keep working.
+				if(v11.size() == 4 || v11.size() == 5) {
 					int v6 = strtol(v11[0].c_str(), 0, 0);
 					std::string v8 = v11[1];
 					std::string v9 = v11[2];
 					int v7 = strtol(v11[3].c_str(), 0, 0);
+					bool_t java = v11.size() == 5 && strtol(v11[4].c_str(), 0, 0) != 0;
 					if(v7 && v6){
-						this->field_0.insert({v6, ExternalServer(v6, v8, v9, v7)}); //TODO check
+						this->field_0.insert({v6, ExternalServer(v6, v8, v9, v7, java)}); //TODO check
 					}
 				}
 			}
@@ -80,7 +92,7 @@ void ExternalServerFile::save() {
 	if(v2) {
 		for(auto& it: this->field_0) {
 			ExternalServer v5(it.second);
-			fprintf(v2, "%d:%s:%s:%d\n", v5.field_0, v5.field_4.c_str(), v5.field_8.c_str(), v5.field_C);
+			fprintf(v2, "%d:%s:%s:%d:%d\n", v5.field_0, v5.field_4.c_str(), v5.field_8.c_str(), v5.field_C, v5.isJava ? 1 : 0);
 		}
 		fclose(v2);
 	}
diff --git a/modifiedeight-newadditions/impl/Minecraft.cpp b/modifiedeight-newadditions/impl/Minecraft.cpp
index d3ce6cf7..0b74fe72 100644
--- a/modifiedeight-newadditions/impl/Minecraft.cpp
+++ b/modifiedeight-newadditions/impl/Minecraft.cpp
@@ -1,3 +1,5 @@
+#include <java/JavaBridge.hpp>
+#include <level/LevelHeight.hpp>
 #include <Minecraft.hpp>
 #include <ExternalServerFile.hpp>
 #include <ExternalServer.hpp>
@@ -393,7 +395,7 @@ void Minecraft::handleMouseDown(int32_t a2, bool_t a3) {
 		}
 	} else if(!this->player->isSleeping() && (a2 != 1 || this->field_D08 <= 0)) {
 		if(this->player->isDestroying) {
-			if(this->selectedObject.hitType || !a3 || a2 != 1 || this->selectedObject.field_24 || (v9 = Tile::tiles[this->level->getTile(this->selectedObject.field_4, this->selectedObject.field_8, this->selectedObject.field_C)]) != 0 && v9->isLiquidTile()) {
+			if(this->selectedObject.hitType || !a3 || a2 != 1 || this->selectedObject.field_24 || ((v9 = Tile::tiles[this->level->getTile(this->selectedObject.field_4, this->selectedObject.field_8, this->selectedObject.field_C)]) != 0 && v9->isLiquidTile())) {
 				this->player->stopDestroying();
 				this->gameMode->stopDestroyBlock();
 			} else {
@@ -482,7 +484,13 @@ bool_t Minecraft::isLevelGenerated(void) {
 	return 0;
 }
 bool_t Minecraft::isOnline(void) {
-	return this->serverSideNetworkHandler != 0;
+	/*
+	 * "There is a server on the other end."  A Java (1.8.x) session has no
+	 * ServerSideNetworkHandler - the server is a real Minecraft server across a
+	 * TCP socket - but everything this gates (block removals, held item and
+	 * container updates, position reports) is exactly what has to reach it.
+	 */
+	return this->serverSideNetworkHandler != 0 || JavaBridge::isActive();
 }
 bool_t Minecraft::isOnlineClient(void) {
 	if(this->level) return this->level->isClientMaybe;
@@ -534,6 +542,8 @@ void Minecraft::leaveGame(bool_t a2, bool_t a3) {
 			}
 			delete this->level;
 			this->level = 0;
+			// Back to the shape everything but a Java session uses.
+			LevelHeight::set(MCPE_HEIGHT);
 		}
 		this->player = 0;
 		this->viewEntityMaybe = 0;
@@ -769,6 +779,8 @@ void Minecraft::respawnPlayer(void) {
 }
 void Minecraft::selectLevel(const std::string& a2, const std::string& a3, const struct LevelSettings& a4) {
 	LevelStorage* v7 = this->levelStorageSource->selectLevel(a2, 0);
+	// A world on disk is 128 tall and has to stay that way.
+	LevelHeight::set(MCPE_HEIGHT);
 	this->level = new ServerLevel(v7, a3, a4, a4.generatorType, 0);
 	this->setLevel(this->level, "Generating level", 0);
 	this->setIsCreativeMode(this->level->getLevelData()->getGameType() == 1);
diff --git a/modifiedeight-newadditions/impl/Options.cpp b/modifiedeight-newadditions/impl/Options.cpp
index 85128a99..bdb03e8d 100644
--- a/modifiedeight-newadditions/impl/Options.cpp
+++ b/modifiedeight-newadditions/impl/Options.cpp
@@ -694,7 +694,10 @@ std::string Options::getDescription(const Options::Option* a2, std::string a4) {
 		int percent = (int)(this->brightness * 100.0f);
 		if(percent <= 0) return a4 + ": Moody";
 		if(percent >= 100) return a4 + ": Bright";
-		return a4 + ": +" + std::to_string(percent) + "%";
+		// std::to_string is missing from the NDK's gnu-libstdc++, so format it by hand.
+		char_t v9[16];
+		sprintf(v9, "%d", percent);
+		return a4 + ": +" + v9 + "%";
 	}
 	return a4;
 }
diff --git a/modifiedeight-newadditions/impl/entity/LocalPlayer.cpp b/modifiedeight-newadditions/impl/entity/LocalPlayer.cpp
index e0707e7e..fe5a1404 100644
--- a/modifiedeight-newadditions/impl/entity/LocalPlayer.cpp
+++ b/modifiedeight-newadditions/impl/entity/LocalPlayer.cpp
@@ -1,3 +1,5 @@
+#include <java/JavaBridge.hpp>
+#include <level/LevelHeight.hpp>
 #include <Minecraft.hpp>
 #include <entity/LocalPlayer.hpp>
 #include <entity/player/User.hpp>
@@ -287,7 +289,14 @@ void LocalPlayer::tick() {
         }
       }
       if (this->useItemDuration == 0) {
-        if (this->level->isClientMaybe) {
+        /*
+         * On MCPE the client waits for the server to echo entity event 9 back
+         * before the food is actually eaten.  A Java server has no such packet:
+         * it runs its own item-in-use countdown and reports the outcome as
+         * Update Health plus a Set Slot, so the local half has to finish itself
+         * or the player chews forever and nothing happens.
+         */
+        if (this->level->isClientMaybe && !JavaBridge::isActive()) {
           EntityEventPacket v23(this->entityId, 9);
           this->level->rakNetInstance->send(v23);
         } else {
@@ -299,7 +308,17 @@ void LocalPlayer::tick() {
     }
   }
   if (this->minecraft->isOnline()) {
-    if (this->isRiding() || fabsf(this->posX - this->field_BC8) > 0.1 ||
+    /*
+     * A Java server is told where we are every single tick, whether anything
+     * moved or not, because that is what its own client does and what its
+     * movement checks are written against.  These thresholds - a tenth of a
+     * block, a whole degree - are MCPE's way of keeping a phone's radio quiet
+     * and are far too coarse to stand between us and a Java server, so the Java
+     * layer does its own bookkeeping and this gate steps out of the way.
+     */
+    if (JavaBridge::isActive()) {
+      JavaBridge::playerTick();
+    } else if (this->isRiding() || fabsf(this->posX - this->field_BC8) > 0.1 ||
         fabsf(this->posY - this->field_BCC) > 0.01 ||
         fabsf(this->posZ - this->field_BD0) > 0.1 ||
         fabsf(this->field_BD4 - this->pitch) > 1.0 ||
@@ -387,6 +406,20 @@ void LocalPlayer::causeFallDamage(float a2) {
   int32_t v4; // r6
 
   v4 = (int32_t)ceil((float)(a2 - 3.0));
+  /*
+   * A Java server works out fall damage itself and sends the result back as
+   * Update Health, so all this has to do there is make the noise.  Hurting the
+   * player locally as well counts the same fall twice, and on a long drop - the
+   * two hundred block one a verification lobby likes to make you take - that is
+   * the difference between landing and a death screen the server never agreed
+   * to.
+   */
+  if (JavaBridge::isActive()) {
+    if (v4 > 0) {
+      this->level->playSound(this, v4 <= 4 ? "damage.fallsmall" : "damage.fallbig", 0.75, 1.0);
+    }
+    return;
+  }
   if (v4 > 0 && this->level->isClientMaybe) {
     SetHealthPacket v5(v4 - 64);
     this->minecraft->rakNetInstance->send(v5);
@@ -598,7 +631,7 @@ void LocalPlayer::travel(float a2, float a3) {
     int pz = (int)floorf(this->posZ);
     for (float yo = -0.5f; yo <= 1.4f; yo += 0.35f) {
       int py = (int)floorf(this->posY + yo);
-      if (py >= 0 && py < 128) {
+      if (LevelHeight::inRange(py)) {
         int tile = this->level->getTile(px, py, pz);
         Material *mat = this->level->getMaterial(px, py, pz);
         if (tile == Tile::water->blockID || tile == Tile::calmWater->blockID ||
diff --git a/modifiedeight-newadditions/impl/entity/Painting.cpp b/modifiedeight-newadditions/impl/entity/Painting.cpp
index d38654c3..8b168487 100644
--- a/modifiedeight-newadditions/impl/entity/Painting.cpp
+++ b/modifiedeight-newadditions/impl/entity/Painting.cpp
@@ -4,8 +4,17 @@
 #include <level/Level.hpp>
 #include <nbt/CompoundTag.hpp>
 
+/*
+ * The load-from-NBT / EntityFactory constructor.  readAdditionalSaveData() is
+ * what normally supplies the motive, but nothing guarantees it runs - a
+ * CreateEntity(83) that is never given save data leaves the field as whatever
+ * the allocation happened to contain, and getWidth() and PaintingRenderer both
+ * dereference it unconditionally.  Start from a real Motive so a painting that
+ * is never told what it depicts is merely wrong, not fatal.
+ */
 Painting::Painting(Level* a2)
 	: HangingEntity(a2) {
+	this->motive = Motive::DefaultImage;
 	this->entityRenderId = PAINTING;
 }
 Painting::Painting(Level* a2, int32_t a3, int32_t a4, int32_t a5, int32_t a6)
@@ -51,6 +60,7 @@ int32_t Painting::getEntityTypeId() const {
 	return 83;
 }
 void Painting::readAdditionalSaveData(CompoundTag* a2) {
+	// getMotiveByName falls back to DefaultImage, so this cannot leave it null.
 	this->motive = Motive::getMotiveByName(a2->getString("Motive"));
 	HangingEntity::readAdditionalSaveData(a2);
 }
@@ -61,10 +71,10 @@ void Painting::addAdditonalSaveData(CompoundTag* a2) {
 	HangingEntity::addAdditonalSaveData(a2);
 }
 int32_t Painting::getWidth() {
-	return this->motive->w;
+	return this->motive ? this->motive->w : Motive::DefaultImage->w;
 }
 int32_t Painting::getHeight() {
-	return this->motive->h;
+	return this->motive ? this->motive->h : Motive::DefaultImage->h;
 }
 void Painting::dropItem() {
 	if(this->level->getLevelData()->getGameType() != 1) {
diff --git a/modifiedeight-newadditions/impl/entity/Player.cpp b/modifiedeight-newadditions/impl/entity/Player.cpp
index 5fd17a91..bdbc992d 100644
--- a/modifiedeight-newadditions/impl/entity/Player.cpp
+++ b/modifiedeight-newadditions/impl/entity/Player.cpp
@@ -1,3 +1,4 @@
+#include <level/LevelHeight.hpp>
 #include <entity/Player.hpp>
 #include <entity/ItemEntity.hpp>
 #include <inventory/BaseContainerMenu.hpp>
@@ -521,11 +522,11 @@ void Player::tick() {
 	if (!this->isSleeping() && this->level) {
 		bool inWater = this->isInWater() || this->isUnderLiquid(Material::water);
 		if (!inWater) {
-			int px = (int)floorf(this->posX);
-			int pz = (int)floorf(this->posZ);
+			int px = Mth::floor(this->posX);
+			int pz = Mth::floor(this->posZ);
 			for (float yo = -0.5f; yo <= 1.4f; yo += 0.35f) {
-				int py = (int)floorf(this->posY + yo);
-				if (py >= 0 && py < 128) {
+				int py = Mth::floor(this->posY + yo);
+				if (LevelHeight::inRange(py)) {
 					int t = this->level->getTile(px, py, pz);
 					Material* mat = this->level->getMaterial(px, py, pz);
 					if ((mat && mat == Material::water) || t == Tile::water->blockID || t == Tile::calmWater->blockID || (Tile::seagrass && t == Tile::seagrass->blockID)) {
diff --git a/modifiedeight-newadditions/impl/gui/elements/LocalServerListItemElement.cpp b/modifiedeight-newadditions/impl/gui/elements/LocalServerListItemElement.cpp
index 4ca5b462..3e091d47 100644
--- a/modifiedeight-newadditions/impl/gui/elements/LocalServerListItemElement.cpp
+++ b/modifiedeight-newadditions/impl/gui/elements/LocalServerListItemElement.cpp
@@ -18,6 +18,9 @@
 #include <gui/screens/PlayScreen.hpp>
 #include <gui/screens/ProgressScreen.hpp>
 #include <gui/screens/RenameMPLevelScreen.hpp>
+#include <java/JavaBridge.hpp>
+#include <java/JavaPing.hpp>
+#include <java/JavaSession.hpp>
 #include <gui/screens/Touch_DeleteWorldScreen.hpp>
 #include <input/Mouse.hpp>
 #include <level/LevelSettings.hpp>
@@ -362,8 +365,31 @@ void LocalServerListItemElement::render(Minecraft *a2, int32_t a3, int32_t a4) {
                            (float)this->posY + 16.0, -4473925);
 
       bool isOnline = false;
+      bool isOffline = false;
       std::string playersStr = "0/20";
-      if (a2->rakNetInstance && a2->rakNetInstance->getServerList()) {
+      std::string wrongVersion = "";
+      if (server->isJava) {
+        /*
+         * A Java server is not on RakNet's ping list and never will be, so ask
+         * it directly. JavaPing answers out of its cache and re-pings on a
+         * background thread, so this costs the render loop nothing - without it
+         * a Java entry sat on "Loading..." for ever even though joining worked.
+         */
+        JavaPingResult ping = JavaPing::get(server->field_8, server->field_C);
+        if (ping.state == JavaPingResult::ONLINE) {
+          isOnline = true;
+          char countBuf[32];
+          sprintf(countBuf, "%d/%d", (int)ping.online, (int)ping.max);
+          playersStr = countBuf;
+          // m8 speaks 1.8.x and nothing else, so say so here rather than let the
+          // player find out from a failed join.
+          if (ping.protocol != JavaSession::PROTOCOL && !ping.version.empty()) {
+            wrongVersion = ping.version;
+          }
+        } else if (ping.state == JavaPingResult::OFFLINE) {
+          isOffline = true;
+        }
+      } else if (a2->rakNetInstance && a2->rakNetInstance->getServerList()) {
         auto *sList = a2->rakNetInstance->getServerList();
         for (auto &s : *sList) {
           char addrBuf[128];
@@ -386,10 +412,23 @@ void LocalServerListItemElement::render(Minecraft *a2, int32_t a3, int32_t a4) {
       for (int d = 0; d < dotCount; ++d)
         loadingDots += ".";
 
-      std::string statusStr = isOnline ? "Online" : ("Loading" + loadingDots);
+      std::string statusStr = "Loading" + loadingDots;
+      if (!wrongVersion.empty()) {
+        statusStr = wrongVersion;
+      } else if (isOnline) {
+        statusStr = "Online";
+      } else if (isOffline) {
+        statusStr = "Offline";
+      }
       if (!isOnline)
         playersStr = "";
-      int32_t statusColor = isOnline ? 0xFF55FF55 : 0xFFFFFF55;
+      int32_t statusColor = 0xFFFFFF55;
+      if (!wrongVersion.empty())
+        statusColor = 0xFFFFAA00;
+      else if (isOnline)
+        statusColor = 0xFF55FF55;
+      else if (isOffline)
+        statusColor = 0xFFFF5555;
       int32_t playersColor = isOnline ? 0xFFBBBBBB : 0xFF777777;
 
       if (this->isEditing) {
@@ -485,6 +524,18 @@ void LocalServerListItemElement::mouseReleased(Minecraft *a2, int32_t a3,
   if (this->field_3C || this->server) {
     if (this->server) {
       if (a2->platform()->isNetworkEnabled(1)) {
+        // A Java Edition entry never touches RakNet - the Java session dials
+        // the server itself and builds the level once it is through login.
+        if (this->server->isJava) {
+          if (!JavaBridge::begin(a2, this->server->field_4, this->server->field_8,
+                                 this->server->field_C)) {
+            a2->setScreen(new DisconnectionScreen(
+                "Could not start the Java Edition connection"));
+            return;
+          }
+          a2->setScreen(new ProgressScreen());
+          return;
+        }
         PingedCompatibleServer v43;
         v43.field_4.FromStringExplicitPort(this->server->field_8.c_str(),
                                            this->server->field_C, 0);
diff --git a/modifiedeight-newadditions/impl/gui/screens/AddExternalServerScreen.cpp b/modifiedeight-newadditions/impl/gui/screens/AddExternalServerScreen.cpp
index 50a02538..6ca2740f 100644
--- a/modifiedeight-newadditions/impl/gui/screens/AddExternalServerScreen.cpp
+++ b/modifiedeight-newadditions/impl/gui/screens/AddExternalServerScreen.cpp
@@ -6,13 +6,30 @@
 #include <gui/screens/PlayScreen.hpp>
 #include <rendering/Tesselator.hpp>
 #include <gui/NinePatchFactory.hpp>
+#include <gui/buttons/Touch_TButton.hpp>
 #include <util/IntRectangle.hpp>
 #include <stdlib.h>
 
+AddExternalServerScreen::AddExternalServerScreen() {
+	this->isJavaServer = 0;
+}
+
 void AddExternalServerScreen::closeScreen() {
 	this->minecraft->setScreen(new PlayScreen(1));
 }
 
+void AddExternalServerScreen::refreshJavaToggle() {
+	if(this->javaToggleButton) {
+		this->javaToggleButton->setMsg(this->isJavaServer ? "Java Server (1.8.x): YES"
+		                                                 : "Java Server (1.8.x): NO");
+	}
+	if(this->field_9C) {
+		this->field_9C->setText(this->isJavaServer
+			? "Add a Minecraft Java Edition 1.8.x server. The default port is 25565."
+			: "Add server by IP/Address.");
+	}
+}
+
 AddExternalServerScreen::~AddExternalServerScreen() {
 }
 void AddExternalServerScreen::render(int32_t a2, int32_t a3, float a4) {
@@ -41,11 +58,13 @@ void AddExternalServerScreen::init() {
 	this->field_94 = std::shared_ptr<TextBox>(new TextBox(this->minecraft, "Server Port", 6, numChars, strlen(numChars), 0, 0, 0, 0));
 	this->field_94->setText("19132");
 	this->field_9C = std::shared_ptr<Label>(new Label("Add server by IP/Address.", this->minecraft, -1, 0, 0, 0, 1));
+	this->javaToggleButton = std::shared_ptr<Button>(new Touch::TButton(3, "Java Server (1.8.x): NO", this->minecraft));
 	NinePatchFactory factory(this->minecraft->texturesPtr, "gui/spritesheet.png");
 	this->field_A4 = std::shared_ptr<NinePatchLayer>(factory.createSymmetrical(IntRectangle{34, 43, 14, 14}, 3, 3, 32, 32));
 	this->buttons.emplace_back(this->field_5C.get());
 	this->buttons.emplace_back(this->closeScreenButton.get());
 	this->buttons.emplace_back(this->addServerButton.get());
+	this->buttons.emplace_back(this->javaToggleButton.get());
 	this->elements.emplace_back(this->serverNameLabel.get());
 	this->elements.emplace_back(this->serverNameTextBox.get());
 	this->elements.emplace_back(this->addressLabel.get());
@@ -53,6 +72,7 @@ void AddExternalServerScreen::init() {
 	this->elements.emplace_back(this->portLabel.get());
 	this->elements.emplace_back(this->field_94.get());
 	this->elements.emplace_back(this->field_9C.get());
+	this->refreshJavaToggle();
 }
 void AddExternalServerScreen::setupPositions() {
 	int32_t height; // r0
@@ -91,8 +111,11 @@ void AddExternalServerScreen::setupPositions() {
 	this->field_9C->posY = this->field_5C->height + 10;
 	this->field_9C->setWidth(this->width / 2 - 20);
 	this->field_9C->setupPositions();
+	this->javaToggleButton->posX = this->width / 2 + 10;
+	this->javaToggleButton->posY = this->field_9C->posY + this->field_9C->height + 10;
+	this->javaToggleButton->width = this->width / 2 - 20;
 	this->addServerButton->posX = this->addServerButton->width / -2 + 3 * ((this->width - 10) / 4);
-	this->addServerButton->posY = this->field_9C->posY + this->field_9C->height + 30;
+	this->addServerButton->posY = this->javaToggleButton->posY + this->javaToggleButton->height + 14;
 	this->field_A4->setSize((float)this->width - 10.0, (float)(this->height - this->field_5C->height - 10));
 }
 bool_t AddExternalServerScreen::handleBackEvent(bool_t a2) {
@@ -113,12 +136,25 @@ bool_t AddExternalServerScreen::handleBackEvent(bool_t a2) {
 void AddExternalServerScreen::buttonClicked(Button* a2) {
 	if(a2 == this->closeScreenButton.get()) {
 		this->closeScreen();
+	} else if(a2 == this->javaToggleButton.get()) {
+		this->isJavaServer = !this->isJavaServer;
+		// Nudge the port to the right default, but only while it still holds the
+		// other edition's one - a port the player typed is left alone.
+		if(this->isJavaServer) {
+			if(this->field_94->text == "19132") {
+				this->field_94->setText("25565");
+			}
+		} else if(this->field_94->text == "25565") {
+			this->field_94->setText("19132");
+		}
+		this->refreshJavaToggle();
+		this->setupPositions();
 	} else if(a2 == this->addServerButton.get()) {
 		long v3 = strtol(this->field_94->text.c_str(), 0, 0);
 		if(v3 > 0) {
 			if(this->serverNameTextBox->text.size()) {
 				if(this->serverAddressTextBox->text.size()) {
-					this->minecraft->externalServerFile->addServer(this->serverNameTextBox->text, this->serverAddressTextBox->text, v3);
+					this->minecraft->externalServerFile->addServer(this->serverNameTextBox->text, this->serverAddressTextBox->text, v3, this->isJavaServer);
 					this->minecraft->setScreen(new PlayScreen(1));
 				}
 			}
diff --git a/modifiedeight-newadditions/impl/gui/screens/ChatScreen.cpp b/modifiedeight-newadditions/impl/gui/screens/ChatScreen.cpp
index 5ef53969..ffde775e 100644
--- a/modifiedeight-newadditions/impl/gui/screens/ChatScreen.cpp
+++ b/modifiedeight-newadditions/impl/gui/screens/ChatScreen.cpp
@@ -8,6 +8,7 @@
 #include <gui/buttons/Touch_TButton.hpp>
 #include <network/RakNetInstance.hpp>
 #include <network/packet/MessagePacket.hpp>
+#include <java/JavaBridge.hpp>
 #include <rendering/Font.hpp>
 #include <util/Util.hpp>
 #include <sstream>
@@ -423,13 +424,16 @@ static bool executeCommand(Minecraft* mc, const std::string& line) {
 
 void ChatScreen::sendChatMessage() {
 	if(this->field_54.size()) {
-		if (this->field_54[0] == '/') {
-			if (!this->minecraft->isOnlineClient()) {
-				executeCommand(this->minecraft, this->field_54);
-			} else {
-				MessagePacket v7(this->field_54, this->minecraft->player->username);
-				this->minecraft->rakNetInstance->send(v7);
-			}
+		/*
+		 * A Java Edition session takes the line verbatim, slash commands
+		 * included: on a Java server those belong to the server, not to the
+		 * local handler below.  sendChat returns 0 when no session is up, so
+		 * MCPE servers and single player keep the original behaviour.
+		 */
+		if(JavaBridge::sendChat(this->field_54)) {
+			// The server echoes our own message back, so nothing to add here.
+		} else if (this->field_54[0] == '/') {
+			executeCommand(this->minecraft, this->field_54);
 		} else {
 			MessagePacket v7(this->field_54, this->minecraft->player->username);
 			this->minecraft->rakNetInstance->send(v7);
diff --git a/modifiedeight-newadditions/impl/gui/screens/EditExternalServerScreen.cpp b/modifiedeight-newadditions/impl/gui/screens/EditExternalServerScreen.cpp
index 8918a2b5..54bcf2f1 100644
--- a/modifiedeight-newadditions/impl/gui/screens/EditExternalServerScreen.cpp
+++ b/modifiedeight-newadditions/impl/gui/screens/EditExternalServerScreen.cpp
@@ -6,12 +6,26 @@
 #include <gui/screens/PlayScreen.hpp>
 #include <rendering/Tesselator.hpp>
 #include <gui/NinePatchFactory.hpp>
+#include <gui/buttons/Touch_TButton.hpp>
 #include <util/IntRectangle.hpp>
 #include <stdlib.h>
 #include <sstream>
 
 EditExternalServerScreen::EditExternalServerScreen(const ExternalServer& a2)
 	: server(a2) {
+	this->isJavaServer = a2.isJava;
+}
+
+void EditExternalServerScreen::refreshJavaToggle() {
+	if(this->javaToggleButton) {
+		this->javaToggleButton->setMsg(this->isJavaServer ? "Java Server (1.8.x): YES"
+		                                                 : "Java Server (1.8.x): NO");
+	}
+	if(this->field_9C) {
+		this->field_9C->setText(this->isJavaServer
+			? "Edit a Minecraft Java Edition 1.8.x server. The default port is 25565."
+			: "Edit server by IP/Address.");
+	}
 }
 
 void EditExternalServerScreen::closeScreen() {
@@ -56,12 +70,14 @@ void EditExternalServerScreen::init() {
 	this->field_94->setText(ss.str());
 
 	this->field_9C = std::shared_ptr<Label>(new Label("Edit server by IP/Address.", this->minecraft, -1, 0, 0, 0, 1));
+	this->javaToggleButton = std::shared_ptr<Button>(new Touch::TButton(3, "Java Server (1.8.x): NO", this->minecraft));
 	NinePatchFactory factory(this->minecraft->texturesPtr, "gui/spritesheet.png");
 	this->field_A4 = std::shared_ptr<NinePatchLayer>(factory.createSymmetrical(IntRectangle{34, 43, 14, 14}, 3, 3, 32, 32));
 	
 	this->buttons.emplace_back(this->field_5C.get());
 	this->buttons.emplace_back(this->closeScreenButton.get());
 	this->buttons.emplace_back(this->saveServerButton.get());
+	this->buttons.emplace_back(this->javaToggleButton.get());
 	
 	this->elements.emplace_back(this->serverNameLabel.get());
 	this->elements.emplace_back(this->serverNameTextBox.get());
@@ -70,6 +86,7 @@ void EditExternalServerScreen::init() {
 	this->elements.emplace_back(this->portLabel.get());
 	this->elements.emplace_back(this->field_94.get());
 	this->elements.emplace_back(this->field_9C.get());
+	this->refreshJavaToggle();
 }
 
 void EditExternalServerScreen::setupPositions() {
@@ -109,8 +126,11 @@ void EditExternalServerScreen::setupPositions() {
 	this->field_9C->posY = this->field_5C->height + 10;
 	this->field_9C->setWidth(this->width / 2 - 20);
 	this->field_9C->setupPositions();
+	this->javaToggleButton->posX = this->width / 2 + 10;
+	this->javaToggleButton->posY = this->field_9C->posY + this->field_9C->height + 10;
+	this->javaToggleButton->width = this->width / 2 - 20;
 	this->saveServerButton->posX = this->saveServerButton->width / -2 + 3 * ((this->width - 10) / 4);
-	this->saveServerButton->posY = this->field_9C->posY + this->field_9C->height + 30;
+	this->saveServerButton->posY = this->javaToggleButton->posY + this->javaToggleButton->height + 14;
 	this->field_A4->setSize((float)this->width - 10.0, (float)(this->height - this->field_5C->height - 10));
 }
 
@@ -133,12 +153,23 @@ bool_t EditExternalServerScreen::handleBackEvent(bool_t a2) {
 void EditExternalServerScreen::buttonClicked(Button* a2) {
 	if(a2 == this->closeScreenButton.get()) {
 		this->closeScreen();
+	} else if(a2 == this->javaToggleButton.get()) {
+		this->isJavaServer = !this->isJavaServer;
+		if(this->isJavaServer) {
+			if(this->field_94->text == "19132") {
+				this->field_94->setText("25565");
+			}
+		} else if(this->field_94->text == "25565") {
+			this->field_94->setText("19132");
+		}
+		this->refreshJavaToggle();
+		this->setupPositions();
 	} else if(a2 == this->saveServerButton.get()) {
 		long v3 = strtol(this->field_94->text.c_str(), 0, 0);
 		if(v3 > 0) {
 			if(this->serverNameTextBox->text.size()) {
 				if(this->serverAddressTextBox->text.size()) {
-					this->minecraft->externalServerFile->editServer(this->server.field_0, this->serverNameTextBox->text, this->serverAddressTextBox->text, v3);
+					this->minecraft->externalServerFile->editServer(this->server.field_0, this->serverNameTextBox->text, this->serverAddressTextBox->text, v3, this->isJavaServer);
 					this->minecraft->setScreen(new PlayScreen(1));
 				}
 			}
diff --git a/modifiedeight-newadditions/impl/item/ItemInstance.cpp b/modifiedeight-newadditions/impl/item/ItemInstance.cpp
index 4de9be57..d94695f3 100644
--- a/modifiedeight-newadditions/impl/item/ItemInstance.cpp
+++ b/modifiedeight-newadditions/impl/item/ItemInstance.cpp
@@ -108,6 +108,18 @@ float ItemInstance::getDestroySpeed(Tile* a2) {
 	return this->itemClass->getDestroySpeed(this, a2);
 }
 TextureUVCoordinateSet* ItemInstance::getIcon(int32_t a2, bool_t a3) const{
+	/*
+	 * Item::items[] is sparse.  A tile with no TileItem registered for it - or an
+	 * id translated in from a Java server that this build does not carry - leaves
+	 * itemClass null while isValid stays set, and every caller dereferences what
+	 * comes back from here.  Fall back to the tile's own carried texture, and to
+	 * an empty set when there is not even that.
+	 */
+	if(!this->itemClass) {
+		if(this->tileClass) return this->tileClass->getCarriedTexture(0, this->metadata);
+		static TextureUVCoordinateSet blank;
+		return &blank;
+	}
 	return this->itemClass->getIcon(this->metadata, a2, a3);
 }
 int32_t ItemInstance::getId() const {
diff --git a/modifiedeight-newadditions/impl/item/WaterLilyTileItem.cpp b/modifiedeight-newadditions/impl/item/WaterLilyTileItem.cpp
index 67618d33..52421185 100644
--- a/modifiedeight-newadditions/impl/item/WaterLilyTileItem.cpp
+++ b/modifiedeight-newadditions/impl/item/WaterLilyTileItem.cpp
@@ -1,4 +1,5 @@
 #include <item/WaterLilyTileItem.hpp>
+#include <level/LevelHeight.hpp>
 #include <level/Level.hpp>
 #include <tile/Tile.hpp>
 #include <tile/material/Material.hpp>
@@ -26,7 +27,7 @@ bool_t WaterLilyTileItem::useOn(ItemInstance* item, Player* player, Level* level
 	int32_t curTile = level->getTile(targetX, targetY, targetZ);
 	Material* curMat = level->getMaterial(targetX, targetY, targetZ);
 	if (curTile == Tile::water->blockID || curTile == Tile::calmWater->blockID || (curMat && curMat == Material::water)) {
-		while (targetY < 127) {
+		while (targetY < LevelHeight::maxY()) {
 			int32_t t = level->getTile(targetX, targetY + 1, targetZ);
 			Material* m = level->getMaterial(targetX, targetY + 1, targetZ);
 			if (t == Tile::water->blockID || t == Tile::calmWater->blockID || (m && m == Material::water)) {
diff --git a/modifiedeight-newadditions/impl/java/JavaBridge.cpp b/modifiedeight-newadditions/impl/java/JavaBridge.cpp
new file mode 100644
index 00000000..127b0011
--- /dev/null
+++ b/modifiedeight-newadditions/impl/java/JavaBridge.cpp
@@ -0,0 +1,104 @@
+#include <java/JavaBridge.hpp>
+#include <java/JavaSession.hpp>
+#include <java/JavaLog.hpp>
+#include <Minecraft.hpp>
+#include <entity/player/User.hpp>
+
+static JavaSession* gJavaSession = 0;
+
+JavaSession* JavaBridge::session() {
+	return gJavaSession;
+}
+
+bool_t JavaBridge::isActive() {
+	return gJavaSession && gJavaSession->isActive();
+}
+
+bool_t JavaBridge::begin(Minecraft* minecraft, const std::string& displayName,
+                         const std::string& host, int32_t typedPort) {
+	JavaBridge::shutdown();
+	if(!minecraft) {
+		return 0;
+	}
+	std::string user;
+	if(minecraft->user) {
+		user = minecraft->user->username;
+	}
+	if(user.empty()) {
+		user = "Steve";
+	}
+	// Java 1.8 caps names at 16 characters and rejects anything outside
+	// [A-Za-z0-9_], which m8 does allow in its profile name.
+	std::string clean;
+	for(size_t i = 0; i < user.size() && clean.size() < 16; ++i) {
+		char c = user[i];
+		if((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')
+		   || (c >= '0' && c <= '9') || c == '_') {
+			clean += c;
+		}
+	}
+	if(clean.empty()) {
+		clean = "Steve";
+	}
+
+	if(clean != user) {
+		javaLog("profile name \"%s\" is not valid on a Java server, joining as \"%s\"",
+		        user.c_str(), clean.c_str());
+	}
+
+	gJavaSession = new JavaSession();
+	/*
+	 * Even a session that could not get off the ground is worth keeping: it
+	 * holds the reason, and pump() turns that into a DisconnectionScreen on the
+	 * next frame.  Reporting success here means the caller shows the progress
+	 * screen and the player gets the real message instead of a generic one.
+	 */
+	gJavaSession->begin(minecraft, displayName, host, typedPort, clean);
+	return 1;
+}
+
+void JavaBridge::pump() {
+	if(!gJavaSession) {
+		return;
+	}
+	gJavaSession->pump();
+	// Do not reap until the session has had the chance to put its failure on
+	// screen - fail() closes the phase, and the *next* pump is what reports it.
+	if(!gJavaSession->isActive()
+	   && (gJavaSession->failure.empty() || gJavaSession->reportedFailure)) {
+		delete gJavaSession;
+		gJavaSession = 0;
+	}
+}
+
+void JavaBridge::playerTick() {
+	if(!JavaBridge::isActive()) {
+		return;
+	}
+	gJavaSession->playerTick();
+}
+
+void JavaBridge::shutdown() {
+	if(!gJavaSession) {
+		return;
+	}
+	JavaSession* s = gJavaSession;
+	gJavaSession = 0;
+	s->shutdown();
+	delete s;
+}
+
+bool_t JavaBridge::interceptSend(Packet* pk) {
+	if(!gJavaSession) {
+		return 0;
+	}
+	return gJavaSession->interceptSend(pk);
+}
+
+bool_t JavaBridge::sendChat(const std::string& text) {
+	if(!JavaBridge::isActive()) {
+		return 0;
+	}
+	gJavaSession->sendChatLine(text);
+	return 1;
+}
diff --git a/modifiedeight-newadditions/impl/java/JavaByteBuf.cpp b/modifiedeight-newadditions/impl/java/JavaByteBuf.cpp
new file mode 100644
index 00000000..2d04bbd0
--- /dev/null
+++ b/modifiedeight-newadditions/impl/java/JavaByteBuf.cpp
@@ -0,0 +1,265 @@
+#include <java/JavaByteBuf.hpp>
+#include <string.h>
+
+JavaByteBuf::JavaByteBuf() {
+	this->readPos = 0;
+	this->bad = 0;
+}
+
+JavaByteBuf::JavaByteBuf(const uint8_t* src, size_t len) {
+	this->readPos = 0;
+	this->bad = 0;
+	if(src && len) {
+		this->bytes.assign(src, src + len);
+	}
+}
+
+void JavaByteBuf::clear() {
+	this->bytes.clear();
+	this->readPos = 0;
+	this->bad = 0;
+}
+
+void JavaByteBuf::reset() {
+	this->readPos = 0;
+	this->bad = 0;
+}
+
+size_t JavaByteBuf::remaining() const {
+	if(this->readPos >= this->bytes.size()) return 0;
+	return this->bytes.size() - this->readPos;
+}
+
+bool_t JavaByteBuf::failed() const {
+	return this->bad;
+}
+
+const uint8_t* JavaByteBuf::data() const {
+	return this->bytes.empty() ? 0 : &this->bytes[0];
+}
+
+size_t JavaByteBuf::size() const {
+	return this->bytes.size();
+}
+
+uint8_t JavaByteBuf::readByte() {
+	if(this->readPos >= this->bytes.size()) {
+		this->bad = 1;
+		return 0;
+	}
+	return this->bytes[this->readPos++];
+}
+
+int8_t JavaByteBuf::readSByte() {
+	return (int8_t)this->readByte();
+}
+
+bool_t JavaByteBuf::readBool() {
+	return this->readByte() != 0;
+}
+
+int16_t JavaByteBuf::readShort() {
+	return (int16_t)this->readUShort();
+}
+
+uint16_t JavaByteBuf::readUShort() {
+	uint16_t hi = this->readByte();
+	uint16_t lo = this->readByte();
+	return (uint16_t)((hi << 8) | lo);
+}
+
+int32_t JavaByteBuf::readInt() {
+	uint32_t v = 0;
+	for(int32_t i = 0; i < 4; ++i) v = (v << 8) | this->readByte();
+	return (int32_t)v;
+}
+
+int64_t JavaByteBuf::readLong() {
+	uint64_t v = 0;
+	for(int32_t i = 0; i < 8; ++i) v = (v << 8) | (uint64_t)this->readByte();
+	return (int64_t)v;
+}
+
+float JavaByteBuf::readFloat() {
+	uint32_t bits = (uint32_t)this->readInt();
+	float out;
+	memcpy(&out, &bits, 4);
+	return out;
+}
+
+double JavaByteBuf::readDouble() {
+	uint64_t bits = (uint64_t)this->readLong();
+	double out;
+	memcpy(&out, &bits, 8);
+	return out;
+}
+
+int32_t JavaByteBuf::readVarInt() {
+	int32_t result = 0;
+	int32_t shift = 0;
+	for(int32_t i = 0; i < 5; ++i) {
+		uint8_t b = this->readByte();
+		if(this->bad) return 0;
+		result |= (int32_t)(b & 0x7F) << shift;
+		if(!(b & 0x80)) return result;
+		shift += 7;
+	}
+	this->bad = 1; // VarInt longer than 5 bytes is malformed
+	return 0;
+}
+
+int64_t JavaByteBuf::readVarLong() {
+	int64_t result = 0;
+	int32_t shift = 0;
+	for(int32_t i = 0; i < 10; ++i) {
+		uint8_t b = this->readByte();
+		if(this->bad) return 0;
+		result |= (int64_t)(b & 0x7F) << shift;
+		if(!(b & 0x80)) return result;
+		shift += 7;
+	}
+	this->bad = 1;
+	return 0;
+}
+
+std::string JavaByteBuf::readString(int32_t maxLen) {
+	int32_t len = this->readVarInt();
+	if(this->bad || len < 0 || len > maxLen * 4 || (size_t)len > this->remaining()) {
+		this->bad = 1;
+		return std::string();
+	}
+	std::string out((const char*)&this->bytes[this->readPos], (size_t)len);
+	this->readPos += (size_t)len;
+	return out;
+}
+
+void JavaByteBuf::readUUID(uint64_t* hi, uint64_t* lo) {
+	uint64_t a = (uint64_t)this->readLong();
+	uint64_t b = (uint64_t)this->readLong();
+	if(hi) *hi = a;
+	if(lo) *lo = b;
+}
+
+/* 1.8 packs a block position into a single long: 26 bits X, 12 bits Y, 26 bits Z. */
+void JavaByteBuf::readPosition(int32_t* x, int32_t* y, int32_t* z) {
+	uint64_t v = (uint64_t)this->readLong();
+	int32_t px = (int32_t)(v >> 38);
+	int32_t py = (int32_t)((v >> 26) & 0xFFF);
+	int32_t pz = (int32_t)(v & 0x3FFFFFF);
+	if(px >= (1 << 25)) px -= (1 << 26);
+	if(py >= (1 << 11)) py -= (1 << 12);
+	if(pz >= (1 << 25)) pz -= (1 << 26);
+	if(x) *x = px;
+	if(y) *y = py;
+	if(z) *z = pz;
+}
+
+void JavaByteBuf::readBytes(uint8_t* dst, size_t len) {
+	if(len > this->remaining()) {
+		this->bad = 1;
+		if(dst && len) memset(dst, 0, len);
+		return;
+	}
+	if(dst && len) memcpy(dst, &this->bytes[this->readPos], len);
+	this->readPos += len;
+}
+
+void JavaByteBuf::skip(size_t len) {
+	if(len > this->remaining()) {
+		this->bad = 1;
+		this->readPos = this->bytes.size();
+		return;
+	}
+	this->readPos += len;
+}
+
+void JavaByteBuf::writeByte(uint8_t v) {
+	this->bytes.push_back(v);
+}
+
+void JavaByteBuf::writeSByte(int8_t v) {
+	this->bytes.push_back((uint8_t)v);
+}
+
+void JavaByteBuf::writeBool(bool_t v) {
+	this->bytes.push_back(v ? 1 : 0);
+}
+
+void JavaByteBuf::writeShort(int16_t v) {
+	this->writeUShort((uint16_t)v);
+}
+
+void JavaByteBuf::writeUShort(uint16_t v) {
+	this->bytes.push_back((uint8_t)(v >> 8));
+	this->bytes.push_back((uint8_t)(v & 0xFF));
+}
+
+void JavaByteBuf::writeInt(int32_t v) {
+	uint32_t u = (uint32_t)v;
+	for(int32_t i = 3; i >= 0; --i) this->bytes.push_back((uint8_t)((u >> (i * 8)) & 0xFF));
+}
+
+void JavaByteBuf::writeLong(int64_t v) {
+	uint64_t u = (uint64_t)v;
+	for(int32_t i = 7; i >= 0; --i) this->bytes.push_back((uint8_t)((u >> (i * 8)) & 0xFF));
+}
+
+void JavaByteBuf::writeFloat(float v) {
+	uint32_t bits;
+	memcpy(&bits, &v, 4);
+	this->writeInt((int32_t)bits);
+}
+
+void JavaByteBuf::writeDouble(double v) {
+	uint64_t bits;
+	memcpy(&bits, &v, 8);
+	this->writeLong((int64_t)bits);
+}
+
+void JavaByteBuf::writeVarInt(int32_t v) {
+	uint32_t u = (uint32_t)v;
+	do {
+		uint8_t b = (uint8_t)(u & 0x7F);
+		u >>= 7;
+		if(u) b |= 0x80;
+		this->bytes.push_back(b);
+	} while(u);
+}
+
+void JavaByteBuf::writeVarLong(int64_t v) {
+	uint64_t u = (uint64_t)v;
+	do {
+		uint8_t b = (uint8_t)(u & 0x7F);
+		u >>= 7;
+		if(u) b |= 0x80;
+		this->bytes.push_back(b);
+	} while(u);
+}
+
+void JavaByteBuf::writeString(const std::string& s) {
+	this->writeVarInt((int32_t)s.size());
+	if(s.size()) this->bytes.insert(this->bytes.end(), s.begin(), s.end());
+}
+
+void JavaByteBuf::writePosition(int32_t x, int32_t y, int32_t z) {
+	uint64_t v = ((uint64_t)(x & 0x3FFFFFF) << 38) | ((uint64_t)(y & 0xFFF) << 26) | (uint64_t)(z & 0x3FFFFFF);
+	this->writeLong((int64_t)v);
+}
+
+void JavaByteBuf::writeBytes(const uint8_t* src, size_t len) {
+	if(src && len) this->bytes.insert(this->bytes.end(), src, src + len);
+}
+
+void JavaByteBuf::writeBuf(const JavaByteBuf& other) {
+	if(other.bytes.size()) this->bytes.insert(this->bytes.end(), other.bytes.begin(), other.bytes.end());
+}
+
+int32_t JavaByteBuf::varIntSize(int32_t v) {
+	uint32_t u = (uint32_t)v;
+	int32_t n = 0;
+	do {
+		++n;
+		u >>= 7;
+	} while(u);
+	return n;
+}
diff --git a/modifiedeight-newadditions/impl/java/JavaChat.cpp b/modifiedeight-newadditions/impl/java/JavaChat.cpp
new file mode 100644
index 00000000..b3d734b7
--- /dev/null
+++ b/modifiedeight-newadditions/impl/java/JavaChat.cpp
@@ -0,0 +1,66 @@
+#include <java/JavaChat.hpp>
+
+/*
+ * Java sends chat as a JSON text component tree. Flatten it into the plain text
+ * m8's chat line renderer can take: concatenate "text" and "extra", and for a
+ * "translate" component fall back to the key plus its arguments rather than
+ * dropping the message entirely (that is what carries join/leave/death notices).
+ */
+void javaChatFlatten(const Json::Value& node, std::string* out) {
+	if(node.isString()) {
+		*out += node.asString();
+		return;
+	}
+	if(node.isArray()) {
+		for(Json::ArrayIndex i = 0; i < node.size(); ++i) {
+			javaChatFlatten(node[i], out);
+		}
+		return;
+	}
+	if(!node.isObject()) {
+		return;
+	}
+	if(node.isMember("text") && node["text"].isString()) {
+		*out += node["text"].asString();
+	}
+	if(node.isMember("translate") && node["translate"].isString()) {
+		const Json::Value& with = node["with"];
+		if(with.isArray() && with.size()) {
+			for(Json::ArrayIndex i = 0; i < with.size(); ++i) {
+				if(i) *out += " ";
+				javaChatFlatten(with[i], out);
+			}
+		} else {
+			*out += node["translate"].asString();
+		}
+	}
+	if(node.isMember("extra")) {
+		javaChatFlatten(node["extra"], out);
+	}
+}
+
+std::string javaChatToText(const Json::Value& node) {
+	std::string out;
+	javaChatFlatten(node, &out);
+	// Strip the section-sign colour codes m8's font does not understand.
+	std::string clean;
+	clean.reserve(out.size());
+	for(size_t i = 0; i < out.size(); ++i) {
+		if((uint8_t)out[i] == 0xC2 && i + 2 < out.size() && (uint8_t)out[i + 1] == 0xA7) {
+			i += 2;
+			continue;
+		}
+		clean += out[i];
+	}
+	return clean;
+}
+
+std::string javaChatToText(const std::string& json) {
+	Json::Value root;
+	Json::Reader reader;
+	if(!reader.parse(json, root, false)) {
+		// Some servers send a bare string for disconnect reasons.
+		return json;
+	}
+	return javaChatToText(root);
+}
diff --git a/modifiedeight-newadditions/impl/java/JavaChunkData.cpp b/modifiedeight-newadditions/impl/java/JavaChunkData.cpp
new file mode 100644
index 00000000..716053ac
--- /dev/null
+++ b/modifiedeight-newadditions/impl/java/JavaChunkData.cpp
@@ -0,0 +1,191 @@
+#include <java/JavaChunkData.hpp>
+#include <level/LevelHeight.hpp>
+#include <java/JavaIdMap.hpp>
+#include <java/JavaY.hpp>
+#include <level/Level.hpp>
+#include <level/chunk/LevelChunk.hpp>
+#include <level/storage/DataLayer.hpp>
+#include <tile/Tile.hpp>
+#include <string.h>
+
+static const size_t JAVA_SECTION_BLOCK_BYTES = 4096 * 2;
+static const size_t JAVA_SECTION_NIBBLE_BYTES = 2048;
+static const size_t JAVA_BIOME_BYTES = 256;
+
+static int32_t javaSectionCount(int32_t sectionMask) {
+	int32_t n = 0;
+	for(int32_t i = 0; i < 16; ++i) {
+		if(sectionMask & (1 << i)) ++n;
+	}
+	return n;
+}
+
+// m8 column index: y in the low bits, then z, then x - one bit wider each for
+// x and z in a 256 tall level.  See LevelHeight.
+static inline int32_t m8Index(int32_t x, int32_t y, int32_t z) {
+	return LevelHeight::index(x, y, z);
+}
+
+static inline void nibbleSet(uint8_t* data, int32_t index, int32_t value) {
+	uint8_t b = data[index >> 1];
+	if((index & 1) != 0) {
+		data[index >> 1] = (uint8_t)((b & 0x0F) | ((value & 0x0F) << 4));
+	} else {
+		data[index >> 1] = (uint8_t)((b & 0xF0) | (value & 0x0F));
+	}
+}
+
+static void writeSectionBlocks(LevelChunk* chunk, int32_t section, const uint8_t* src) {
+	uint8_t* tiles = chunk->tiles;
+	uint8_t* meta = chunk->tileMeta.data;
+	int32_t sectionBase = section * 16;
+
+	for(int32_t yl = 0; yl < 16; ++yl) {
+		int32_t javaY = sectionBase + yl;
+		if(!JavaY::inRange(javaY)) continue;
+		int32_t m8y = JavaY::toM8(javaY);
+
+		for(int32_t z = 0; z < 16; ++z) {
+			for(int32_t x = 0; x < 16; ++x) {
+				int32_t ji = (yl << 8) | (z << 4) | x;
+				int32_t state = (int32_t)src[ji * 2] | ((int32_t)src[ji * 2 + 1] << 8);
+				int32_t id = 0, mt = 0;
+				if(state) {
+					JavaIdMap::javaBlockToM8(state >> 4, state & 0xF, &id, &mt);
+				}
+				int32_t mi = m8Index(x, m8y, z);
+				tiles[mi] = (uint8_t)id;
+				nibbleSet(meta, mi, mt);
+			}
+		}
+	}
+}
+
+static void writeSectionNibbles(DataLayer* layer, int32_t section, const uint8_t* src) {
+	uint8_t* dst = layer->data;
+	int32_t sectionBase = section * 16;
+
+	for(int32_t yl = 0; yl < 16; ++yl) {
+		int32_t javaY = sectionBase + yl;
+		if(!JavaY::inRange(javaY)) continue;
+		int32_t m8y = JavaY::toM8(javaY);
+
+		for(int32_t z = 0; z < 16; ++z) {
+			for(int32_t x = 0; x < 16; ++x) {
+				int32_t ji = (yl << 8) | (z << 4) | x;
+				int32_t v;
+				if((ji & 1) != 0) {
+					v = (src[ji >> 1] >> 4) & 0x0F;
+				} else {
+					v = src[ji >> 1] & 0x0F;
+				}
+				nibbleSet(dst, m8Index(x, m8y, z), v);
+			}
+		}
+	}
+}
+
+/*
+ * A "ground up" send means the sections missing from the mask are empty, not
+ * unchanged, so they have to be cleared. Sky light there goes to full: those
+ * sections are above the terrain, and leaving them at 0 would put the player
+ * under a black ceiling.
+ */
+static void clearSection(LevelChunk* chunk, int32_t section, bool_t hasSkyLight) {
+	int32_t sectionBase = section * 16;
+	for(int32_t yl = 0; yl < 16; ++yl) {
+		int32_t javaY = sectionBase + yl;
+		if(!JavaY::inRange(javaY)) continue;
+		int32_t m8y = JavaY::toM8(javaY);
+
+		for(int32_t z = 0; z < 16; ++z) {
+			for(int32_t x = 0; x < 16; ++x) {
+				int32_t mi = m8Index(x, m8y, z);
+				chunk->tiles[mi] = 0;
+				nibbleSet(chunk->tileMeta.data, mi, 0);
+				nibbleSet(chunk->blockLight.data, mi, 0);
+				nibbleSet(chunk->skyLight.data, mi, hasSkyLight ? 15 : 0);
+			}
+		}
+	}
+}
+
+size_t JavaChunkData::payloadSize(int32_t sectionMask, bool_t hasSkyLight, bool_t groundUp) {
+	size_t bits = (size_t)javaSectionCount(sectionMask);
+	size_t n = bits * JAVA_SECTION_BLOCK_BYTES + bits * JAVA_SECTION_NIBBLE_BYTES;
+	if(hasSkyLight) n += bits * JAVA_SECTION_NIBBLE_BYTES;
+	if(groundUp) n += JAVA_BIOME_BYTES;
+	return n;
+}
+
+size_t JavaChunkData::apply(Level* level, LevelChunk* chunk, const uint8_t* data, size_t len,
+                            int32_t sectionMask, bool_t groundUp, bool_t hasSkyLight) {
+	sectionMask &= 0xFFFF;
+	size_t need = JavaChunkData::payloadSize(sectionMask, hasSkyLight, groundUp);
+	if(need > len) return 0;
+	if(!chunk || !chunk->tiles) return need;
+
+	size_t off = 0;
+	int32_t s;
+
+	for(s = 0; s < 16; ++s) {
+		if(sectionMask & (1 << s)) {
+			if(JavaY::sectionVisible(s)) {
+				writeSectionBlocks(chunk, s, data + off);
+			}
+			off += JAVA_SECTION_BLOCK_BYTES;
+		} else if(groundUp && JavaY::sectionVisible(s)) {
+			clearSection(chunk, s, hasSkyLight);
+		}
+	}
+	for(s = 0; s < 16; ++s) {
+		if(!(sectionMask & (1 << s))) continue;
+		if(JavaY::sectionVisible(s)) {
+			writeSectionNibbles(&chunk->blockLight, s, data + off);
+		}
+		off += JAVA_SECTION_NIBBLE_BYTES;
+	}
+	if(hasSkyLight) {
+		for(s = 0; s < 16; ++s) {
+			if(!(sectionMask & (1 << s))) continue;
+			if(JavaY::sectionVisible(s)) {
+				writeSectionNibbles(&chunk->skyLight, s, data + off);
+			}
+			off += JAVA_SECTION_NIBBLE_BYTES;
+		}
+	}
+	// The 256 biome bytes are the tail of a ground up send. m8's LevelChunk has
+	// nowhere to put them - biomes only ever reach it through its own generator -
+	// so they are consumed and dropped.
+	if(groundUp) off += JAVA_BIOME_BYTES;
+
+	JavaChunkData::recomputeHeights(chunk);
+	return off;
+}
+
+/*
+ * LevelChunk::recalcHeightmap would do this, but it also overwrites skyLight
+ * with its own straight-down attenuation, which would throw away the light the
+ * server computed for overhangs and caves, and it calls lightGaps() 256 times,
+ * which walks into Level::updateLight for neighbours that may not be resident.
+ * heightMap[x | 16*z] is the lowest y with nothing but transparent blocks above
+ * it, i.e. one past the highest light blocking block; topBlockY is the minimum
+ * across the column.
+ */
+void JavaChunkData::recomputeHeights(LevelChunk* chunk) {
+	if(!chunk || !chunk->tiles) return;
+
+	int32_t lowest = LevelHeight::maxY();
+	for(int32_t x = 0; x < 16; ++x) {
+		for(int32_t z = 0; z < 16; ++z) {
+			int32_t base = m8Index(x, 0, z);
+			int32_t y = LevelHeight::maxY();
+			while(y > 0 && !Tile::lightBlock[chunk->tiles[base + y - 1]]) {
+				--y;
+			}
+			chunk->heightMap[x | (16 * z)] = (uint16_t)y;
+			if(y < lowest) lowest = y;
+		}
+	}
+	chunk->topBlockY = lowest;
+}
diff --git a/modifiedeight-newadditions/impl/java/JavaChunkSource.cpp b/modifiedeight-newadditions/impl/java/JavaChunkSource.cpp
new file mode 100644
index 00000000..d3a6eddf
--- /dev/null
+++ b/modifiedeight-newadditions/impl/java/JavaChunkSource.cpp
@@ -0,0 +1,216 @@
+#include <java/JavaChunkSource.hpp>
+#include <level/LevelHeight.hpp>
+#include <java/JavaY.hpp>
+#include <level/Level.hpp>
+#include <level/chunk/LevelChunk.hpp>
+#include <level/chunk/EmptyLevelChunk.hpp>
+#include <level/storage/DataLayer.hpp>
+#include <level/dimension/Dimension.hpp>
+#include <tile/Tile.hpp>
+#include <tile/entity/TileEntity.hpp>
+#include <string.h>
+
+// A column the server has not described yet.  See the header for why this is
+// not simply all air.
+static void javaBlankColumn(LevelChunk* chunk, bool_t hasSky) {
+	if(!chunk || !chunk->tiles) {
+		return;
+	}
+	memset(chunk->tiles, 0, LevelHeight::tiles);
+	memset(chunk->tileMeta.data, 0, LevelHeight::tiles / 2);
+	memset(chunk->blockLight.data, 0, LevelHeight::tiles / 2);
+	memset(chunk->skyLight.data, hasSky ? 0xFF : 0x00, LevelHeight::tiles / 2);
+
+	int32_t bedrock = Tile::unbreakable ? Tile::unbreakable->blockID : 7;
+	for(int32_t x = 0; x < 16; ++x) {
+		for(int32_t z = 0; z < 16; ++z) {
+			chunk->tiles[LevelHeight::index(x, 0, z)] = (uint8_t)bedrock;
+			chunk->heightMap[x | (16 * z)] = 1;
+			if(hasSky) {
+				chunk->skyLight.set(x, 0, z, 0);
+			}
+		}
+	}
+	chunk->topBlockY = 1;
+}
+
+/*
+ * Tile entities outlive their column otherwise.  Level::tick is what normally
+ * frees them - it sweeps level->tileEntities and drops whatever is marked
+ * removed - and a client level never runs it: MultiPlayerLevel::tick only moves
+ * time and the sky along.  LevelRenderer walks that same list with no interest
+ * in whether the column is still resident, so a recycled slot would leave signs
+ * hanging in mid air at coordinates the server has long stopped talking about.
+ */
+static void javaReleaseTileEntities(Level* level, LevelChunk* chunk) {
+	if(!chunk || chunk->tileEntities.empty()) {
+		return;
+	}
+	for(auto&& entry: chunk->tileEntities) {
+		TileEntity* te = entry.second;
+		if(!te) {
+			continue;
+		}
+		if(level) {
+			for(size_t i = 0; i < level->tileEntities.size();) {
+				if(level->tileEntities[i] == te) {
+					level->tileEntities.erase(level->tileEntities.begin() + i);
+				} else {
+					++i;
+				}
+			}
+			for(size_t i = 0; i < level->field_50.size();) {
+				if(level->field_50[i] == te) {
+					level->field_50.erase(level->field_50.begin() + i);
+				} else {
+					++i;
+				}
+			}
+		}
+		delete te;
+	}
+	chunk->tileEntities.clear();
+}
+
+JavaChunkSource::JavaChunkSource(Level* level) {
+	this->level = level;
+	this->emptyChunk = new EmptyLevelChunk(level);
+	memset(this->chunks, 0, sizeof(this->chunks));
+	this->lastChunkX = 0x7FFFFFFF;
+	this->lastChunkZ = 0x7FFFFFFF;
+	this->lastChunk = 0;
+	this->residentCount = 0;
+}
+
+JavaChunkSource::~JavaChunkSource() {
+	this->dropAll();
+	if(this->emptyChunk) {
+		delete this->emptyChunk;
+		this->emptyChunk = 0;
+	}
+}
+
+int32_t JavaChunkSource::slotOf(int32_t x, int32_t z) {
+	return (x & JavaChunkSource::GRID_MASK) + JavaChunkSource::GRID * (z & JavaChunkSource::GRID_MASK);
+}
+
+LevelChunk* JavaChunkSource::find(int32_t x, int32_t z) {
+	LevelChunk* chunk = this->chunks[JavaChunkSource::slotOf(x, z)];
+	if(chunk && chunk->chunkX == x && chunk->chunkZ == z) {
+		return chunk;
+	}
+	return 0;
+}
+
+LevelChunk* JavaChunkSource::obtain(int32_t x, int32_t z) {
+	if(x == this->lastChunkX && z == this->lastChunkZ && this->lastChunk) {
+		return this->lastChunk;
+	}
+
+	int32_t slot = JavaChunkSource::slotOf(x, z);
+	LevelChunk* chunk = this->chunks[slot];
+	if(chunk) {
+		if(chunk->chunkX == x && chunk->chunkZ == z) {
+			this->lastChunkX = x;
+			this->lastChunkZ = z;
+			this->lastChunk = chunk;
+			return chunk;
+		}
+		// Slot collision: this is how ChunkCache recycles too.  The column is
+		// server owned, so there is nothing to write back.
+		chunk->unload();
+		javaReleaseTileEntities(this->level, chunk);
+		delete chunk;
+		this->chunks[slot] = 0;
+		--this->residentCount;
+	}
+
+	bool_t hasSky = this->level && this->level->dimensionPtr ? !this->level->dimensionPtr->hasNoSkyMaybe : 1;
+	chunk = new LevelChunk(this->level, x, z);
+	javaBlankColumn(chunk, hasSky);
+	// Nothing here is ever generated or decorated locally, and nothing is ever
+	// written to disk.
+	chunk->decorated = 1;
+	chunk->unsaved = 0;
+	chunk->clearUpdateMap();
+	chunk->load();
+
+	this->chunks[slot] = chunk;
+	++this->residentCount;
+	this->lastChunkX = x;
+	this->lastChunkZ = z;
+	this->lastChunk = chunk;
+	return chunk;
+}
+
+void JavaChunkSource::drop(int32_t x, int32_t z) {
+	int32_t slot = JavaChunkSource::slotOf(x, z);
+	LevelChunk* chunk = this->chunks[slot];
+	if(!chunk || chunk->chunkX != x || chunk->chunkZ != z) {
+		return;
+	}
+	if(this->lastChunk == chunk) {
+		this->lastChunk = 0;
+		this->lastChunkX = 0x7FFFFFFF;
+		this->lastChunkZ = 0x7FFFFFFF;
+	}
+	chunk->unload();
+	javaReleaseTileEntities(this->level, chunk);
+	delete chunk;
+	this->chunks[slot] = 0;
+	--this->residentCount;
+}
+
+void JavaChunkSource::dropAll() {
+	for(int32_t i = 0; i < JavaChunkSource::SLOTS; ++i) {
+		LevelChunk* chunk = this->chunks[i];
+		if(chunk) {
+			chunk->unload();
+			javaReleaseTileEntities(this->level, chunk);
+			delete chunk;
+			this->chunks[i] = 0;
+		}
+	}
+	this->residentCount = 0;
+	this->lastChunk = 0;
+	this->lastChunkX = 0x7FFFFFFF;
+	this->lastChunkZ = 0x7FFFFFFF;
+}
+
+// Level::hasChunkAt / hasChunksAt gate entity movement, tile writes and light
+// updates on this.  Answering "no" for a column the server has not sent yet
+// would freeze the player in place mid air, so every column inside the height
+// range counts as present - getChunk() makes that true on demand.
+bool_t JavaChunkSource::hasChunk(int32_t, int32_t) {
+	return 1;
+}
+
+LevelChunk* JavaChunkSource::getChunk(int32_t x, int32_t z) {
+	return this->obtain(x, z);
+}
+
+LevelChunk* JavaChunkSource::create(int32_t x, int32_t z) {
+	return this->obtain(x, z);
+}
+
+void JavaChunkSource::postProcess(ChunkSource*, int32_t, int32_t) {
+}
+
+bool_t JavaChunkSource::tick() {
+	return 0;
+}
+
+bool_t JavaChunkSource::shouldSave() {
+	return 0;
+}
+
+void JavaChunkSource::saveAll(bool_t) {
+}
+
+std::vector<Biome::MobSpawnerData> JavaChunkSource::getMobsAt(const MobCategory&, int32_t, int32_t, int32_t) {
+	return std::vector<Biome::MobSpawnerData>();
+}
+
+std::string JavaChunkSource::gatherStats() {
+	return "JavaChunkSource";
+}
diff --git a/modifiedeight-newadditions/impl/java/JavaIdMap.cpp b/modifiedeight-newadditions/impl/java/JavaIdMap.cpp
new file mode 100644
index 00000000..d1a79ee7
--- /dev/null
+++ b/modifiedeight-newadditions/impl/java/JavaIdMap.cpp
@@ -0,0 +1,662 @@
+#include <java/JavaIdMap.hpp>
+#include <item/Item.hpp>
+#include <tile/Tile.hpp>
+
+/*
+ * Per-block target for Java ids 0..197.
+ *
+ * A value of -1 means "handled specially below" (metadata has to be rewritten
+ * as well as the id). Everything else is a plain m8 tile id, with 0 for air.
+ */
+#define SPECIAL (-1)
+
+static const int16_t gJavaToM8Block[256] = {
+	/*   0 air                 */ 0,
+	/*   1 stone               */ 1,
+	/*   2 grass               */ 2,
+	/*   3 dirt                */ 3,
+	/*   4 cobblestone         */ 4,
+	/*   5 planks              */ SPECIAL,
+	/*   6 sapling             */ SPECIAL,
+	/*   7 bedrock             */ 7,
+	/*   8 flowing_water       */ 8,
+	/*   9 water               */ 9,
+	/*  10 flowing_lava        */ 10,
+	/*  11 lava                */ 11,
+	/*  12 sand                */ SPECIAL,   // red sand has no m8 tile
+	/*  13 gravel              */ 13,
+	/*  14 gold_ore            */ 14,
+	/*  15 iron_ore            */ 15,
+	/*  16 coal_ore            */ 16,
+	/*  17 log                 */ SPECIAL,   // strip the axis bits
+	/*  18 leaves              */ SPECIAL,   // strip decay/check bits
+	/*  19 sponge              */ 19,
+	/*  20 glass               */ 20,
+	/*  21 lapis_ore           */ 21,
+	/*  22 lapis_block         */ 22,
+	/*  23 dispenser           */ SPECIAL,   // -> furnace, remap facing
+	/*  24 sandstone           */ 24,
+	/*  25 noteblock           */ 5,         // -> planks
+	/*  26 bed                 */ 26,
+	/*  27 golden_rail         */ 27,
+	/*  28 detector_rail       */ 27,        // -> powered rail
+	/*  29 sticky_piston       */ 4,
+	/*  30 web                 */ 30,
+	/*  31 tallgrass           */ 31,
+	/*  32 deadbush            */ 32,
+	/*  33 piston              */ 4,
+	/*  34 piston_head         */ 4,
+	/*  35 wool                */ 35,
+	/*  36 piston_extension    */ 0,         // technical block
+	/*  37 yellow_flower       */ 37,
+	/*  38 red_flower          */ SPECIAL,   // spread over m8's separate flowers
+	/*  39 brown_mushroom      */ 39,
+	/*  40 red_mushroom        */ 40,
+	/*  41 gold_block          */ 41,
+	/*  42 iron_block          */ 42,
+	/*  43 double_stone_slab   */ SPECIAL,
+	/*  44 stone_slab          */ 44,
+	/*  45 brick_block         */ 45,
+	/*  46 tnt                 */ 46,
+	/*  47 bookshelf           */ 47,
+	/*  48 mossy_cobblestone   */ 48,
+	/*  49 obsidian            */ 49,
+	/*  50 torch               */ 50,
+	/*  51 fire                */ 51,
+	/*  52 mob_spawner         */ 4,
+	/*  53 oak_stairs          */ 53,
+	/*  54 chest               */ 54,
+	/*  55 redstone_wire       */ 0,
+	/*  56 diamond_ore         */ 56,        // m8's "emeraldOre" is diamond ore
+	/*  57 diamond_block       */ 57,
+	/*  58 crafting_table      */ 58,
+	/*  59 wheat               */ 59,
+	/*  60 farmland            */ 60,
+	/*  61 furnace             */ 61,
+	/*  62 lit_furnace         */ 62,
+	/*  63 standing_sign       */ 63,
+	/*  64 wooden_door         */ 64,
+	/*  65 ladder              */ 65,
+	/*  66 rail                */ 66,
+	/*  67 stone_stairs        */ 67,
+	/*  68 wall_sign           */ 68,
+	/*  69 lever               */ 69,
+	/*  70 stone_pressure_plate*/ 44,        // -> stone slab
+	/*  71 iron_door           */ 71,
+	/*  72 wooden_press_plate  */ 158,       // -> wooden slab
+	/*  73 redstone_ore        */ 73,
+	/*  74 lit_redstone_ore    */ 74,
+	/*  75 unlit_rs_torch      */ 50,
+	/*  76 redstone_torch      */ 50,
+	/*  77 stone_button        */ 0,
+	/*  78 snow_layer          */ 78,
+	/*  79 ice                 */ 79,
+	/*  80 snow                */ 80,
+	/*  81 cactus              */ 81,
+	/*  82 clay                */ 82,
+	/*  83 reeds               */ 83,
+	/*  84 jukebox             */ 47,        // -> bookshelf
+	/*  85 fence               */ 85,
+	/*  86 pumpkin             */ 86,
+	/*  87 netherrack          */ 87,
+	/*  88 soul_sand           */ 12,        // -> sand
+	/*  89 glowstone           */ 89,
+	/*  90 portal              */ 0,
+	/*  91 lit_pumpkin         */ 91,
+	/*  92 cake                */ 92,
+	/*  93 unpowered_repeater  */ 0,
+	/*  94 powered_repeater    */ 0,
+	/*  95 stained_glass       */ 195,       // m8 95 is invisible_bedrock
+	/*  96 trapdoor            */ 96,
+	/*  97 monster_egg         */ SPECIAL,
+	/*  98 stonebrick          */ 98,
+	/*  99 brown_mushroom_block*/ 17,        // -> log
+	/* 100 red_mushroom_block  */ 45,        // -> brick
+	/* 101 iron_bars           */ 101,
+	/* 102 glass_pane          */ 102,
+	/* 103 melon_block         */ 103,
+	/* 104 pumpkin_stem        */ 104,
+	/* 105 melon_stem          */ 105,
+	/* 106 vine                */ 106,
+	/* 107 fence_gate          */ 107,
+	/* 108 brick_stairs        */ 108,
+	/* 109 stone_brick_stairs  */ 109,
+	/* 110 mycelium            */ 2,         // -> grass
+	/* 111 waterlily           */ 111,
+	/* 112 nether_brick        */ 112,
+	/* 113 nether_brick_fence  */ 85,        // -> fence
+	/* 114 nether_brick_stairs */ 114,
+	/* 115 nether_wart         */ 59,        // m8 115 is a coloured log
+	/* 116 enchanting_table    */ 47,
+	/* 117 brewing_stand       */ 58,
+	/* 118 cauldron            */ 42,
+	/* 119 end_portal          */ 0,
+	/* 120 end_portal_frame    */ 24,
+	/* 121 end_stone           */ 24,
+	/* 122 dragon_egg          */ 49,
+	/* 123 redstone_lamp       */ 123,
+	/* 124 lit_redstone_lamp   */ 124,
+	/* 125 double_wooden_slab  */ 157,       // m8 125 is a coloured log
+	/* 126 wooden_slab         */ 158,       // m8 126 is the activator rail
+	/* 127 cocoa               */ 0,
+	/* 128 sandstone_stairs    */ 128,
+	/* 129 emerald_ore         */ 56,        // m8 has no emerald ore
+	/* 130 ender_chest         */ 54,
+	/* 131 tripwire_hook       */ 0,
+	/* 132 tripwire            */ 0,
+	/* 133 emerald_block       */ 57,
+	/* 134 spruce_stairs       */ 134,
+	/* 135 birch_stairs        */ 135,
+	/* 136 jungle_stairs       */ 136,
+	/* 137 command_block       */ 4,         // m8 137 is a coloured log
+	/* 138 beacon              */ 20,
+	/* 139 cobblestone_wall    */ 139,
+	/* 140 flower_pot          */ 0,
+	/* 141 carrots             */ 141,
+	/* 142 potatoes            */ 142,
+	/* 143 wooden_button       */ 0,         // 143-166 are m8 coloured brick stairs
+	/* 144 skull               */ 0,
+	/* 145 anvil               */ 42,
+	/* 146 trapped_chest       */ 54,
+	/* 147 light_weighted_pp   */ 0,
+	/* 148 heavy_weighted_pp   */ 0,
+	/* 149 unpowered_comparator*/ 0,
+	/* 150 powered_comparator  */ 0,
+	/* 151 daylight_detector   */ 158,
+	/* 152 redstone_block      */ 45,
+	/* 153 quartz_ore          */ 87,
+	/* 154 hopper              */ 42,
+	/* 155 quartz_block        */ 155,
+	/* 156 quartz_stairs       */ 156,
+	/* 157 activator_rail      */ 126,       // m8 157 is the wooden slab
+	/* 158 dropper             */ 61,        // m8 158 is the wooden half slab
+	/* 159 stained_hardened_cl */ 238,       // -> m8 coloured bricks
+	/* 160 stained_glass_pane  */ 196,
+	/* 161 leaves2             */ SPECIAL,
+	/* 162 log2                */ SPECIAL,
+	/* 163 acacia_stairs       */ 53,
+	/* 164 dark_oak_stairs     */ 134,
+	/* 165 slime               */ 20,
+	/* 166 barrier             */ 95,       // m8 95 is invisible_bedrock: invisible, solid, unbreakable
+	/* 167 iron_trapdoor       */ 96,
+	/* 168 prismarine          */ 98,
+	/* 169 sea_lantern         */ 89,
+	/* 170 hay_block           */ 170,
+	/* 171 carpet              */ 171,
+	/* 172 hardened_clay       */ 45,
+	/* 173 coal_block          */ 173,
+	/* 174 packed_ice          */ 79,        // 174-189 are m8 coloured fences
+	/* 175 double_plant        */ 190,
+	/* 176 standing_banner     */ 0,
+	/* 177 wall_banner         */ 0,
+	/* 178 daylight_det_inv    */ 158,
+	/* 179 red_sandstone       */ 24,
+	/* 180 red_sandstone_stairs*/ 128,
+	/* 181 double_stone_slab2  */ SPECIAL,
+	/* 182 stone_slab2         */ SPECIAL,
+	/* 183 spruce_fence_gate   */ 107,
+	/* 184 birch_fence_gate    */ 107,
+	/* 185 jungle_fence_gate   */ 107,
+	/* 186 dark_oak_fence_gate */ 107,
+	/* 187 acacia_fence_gate   */ 107,
+	/* 188 spruce_fence        */ 197,
+	/* 189 birch_fence         */ 198,
+	/* 190 jungle_fence        */ 85,        // m8 190 is the double plant
+	/* 191 dark_oak_fence      */ 197,       // m8 191 is a flower
+	/* 192 acacia_fence        */ 85,        // m8 192 is a flower
+	/* 193 spruce_door         */ 193,
+	/* 194 birch_door          */ 194,
+	/* 195 jungle_door         */ 64,        // m8 195 is stained glass
+	/* 196 acacia_door         */ 64,        // m8 196 is stained glass pane
+	/* 197 dark_oak_door       */ 193,
+	/* 198..255 unused in 1.8  */ 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+};
+
+void JavaIdMap::javaBlockToM8(int32_t javaId, int32_t javaMeta, int32_t* outId, int32_t* outMeta) {
+	int32_t id = 0, meta = 0;
+
+	if(javaId >= 0 && javaId < 256) {
+		int32_t mapped = gJavaToM8Block[javaId];
+		if(mapped != SPECIAL) {
+			id = mapped;
+			meta = javaMeta & 0xF;
+
+			// A few straight mappings still need their metadata clamped,
+			// because m8 indexes texture arrays by it.
+			switch(javaId) {
+				case 35:  // wool, stained glass and carpets share the 16 dye slots
+				case 95:
+				case 171:
+				case 159:
+				case 160:
+					break;
+				case 44:  // slabs: low 3 bits pick the material, bit 3 is "upper half"
+					if((meta & 7) > 6) meta = (meta & 8);
+					break;
+				case 125: // double wooden slab
+				case 126: // wooden slab
+					/*
+					 * Tile::WOOD_NAMES has four entries and WoodSlabTile indexes
+					 * it with "meta & 7", so acacia (4) and dark oak (5) - which
+					 * a 1.8 server hands out freely, they grow in savannas and
+					 * roofed forests - would read a std::string off the end of
+					 * the array.  Fold them onto oak and keep the upper-half bit,
+					 * which is the part that decides whether you can walk on it.
+					 */
+					if((meta & 7) > 3) meta = (meta & 8);
+					break;
+				case 17:
+				case 18:
+					meta &= 3;
+					break;
+				default:
+					break;
+			}
+		} else {
+			// Cases where the metadata has to be rewritten too.
+			switch(javaId) {
+				case 5:   // planks: acacia/dark oak fall back to oak
+					id = 5;
+					meta = (javaMeta & 0xF) > 3 ? 0 : (javaMeta & 3);
+					break;
+				case 6:   // sapling: drop the growth-stage bit, clamp species
+					id = 6;
+					meta = (javaMeta & 7) > 3 ? 0 : (javaMeta & 3);
+					break;
+				case 12:  // red sand -> plain sand
+					id = 12;
+					meta = 0;
+					break;
+				case 17:  // log: low 2 bits species, high bits axis
+					id = 17;
+					meta = javaMeta & 3;
+					break;
+				case 18:  // leaves: low 2 bits species
+					id = 18;
+					meta = javaMeta & 3;
+					break;
+				case 23:  // dispenser -> furnace; furnaces only face sideways
+					id = 61;
+					meta = (javaMeta & 7) < 2 ? 3 : (javaMeta & 7);
+					break;
+				case 38:  // red_flower spreads over m8's individual flower tiles
+					switch(javaMeta & 0xF) {
+						case 1: id = 240; meta = 0; break; // blue orchid
+						case 2: id = 241; meta = 0; break; // allium
+						case 3: id = 239; meta = 0; break; // azure bluet
+						case 8: id = 192; meta = 0; break; // oxeye daisy
+						default: id = 38; meta = 0; break; // poppy and the tulips
+					}
+					break;
+				case 43:  // double stone slab: bit 3 is "seamless", not a material
+					id = 43;
+					meta = javaMeta & 7;
+					if(meta > 6) meta = 0;
+					break;
+				case 97:  // monster_egg mimics whatever it is hiding in
+					switch(javaMeta & 0xF) {
+						case 0: id = 1; break;
+						case 1: id = 4; break;
+						default: id = 98; break;
+					}
+					meta = 0;
+					break;
+				case 161: // leaves2 (acacia, dark oak) -> oak leaves
+					id = 18;
+					meta = 0;
+					break;
+				case 162: // log2: acacia -> oak, dark oak -> spruce
+					id = 17;
+					meta = (javaMeta & 1) ? 1 : 0;
+					break;
+				case 181: // red sandstone double slab -> sandstone slab
+					id = 43;
+					meta = 1;
+					break;
+				case 182: // red sandstone slab, keeping the upper-half bit
+					id = 44;
+					meta = 1 | (javaMeta & 8);
+					break;
+				default:
+					id = 0;
+					meta = 0;
+					break;
+			}
+		}
+	}
+
+	/*
+	 * Last line of defence.  A mapping typo, or a target this build does not
+	 * register, would otherwise hand Level::setTileAndData an id whose
+	 * Tile::tiles[] slot is null, and the first onPlace / neighbourChanged /
+	 * getAABB call on it takes the game down - which is exactly what "some
+	 * special blocks crash the game" looks like from the outside.  Degrade to
+	 * stone instead of crashing.
+	 */
+	if(id < 0 || id > 255) {
+		id = 0;
+		meta = 0;
+	} else if(id != 0 && !Tile::tiles[id]) {
+		id = 1;
+		meta = 0;
+	}
+
+	if(outId) *outId = id;
+	if(outMeta) *outMeta = meta;
+}
+
+void JavaIdMap::m8BlockToJava(int32_t m8Id, int32_t m8Meta, int32_t* outId, int32_t* outMeta) {
+	int32_t id = m8Id, meta = m8Meta & 0xF;
+
+	// Undo the remaps above for the ids where m8 and Java disagree. Everything
+	// not listed here shares its id with vanilla 1.8.
+	switch(m8Id) {
+		case 115: case 116: case 117: case 118: case 119: case 120:
+		case 121: case 122: case 125: case 127: case 129: case 130:
+		case 131: case 132: case 133: case 137:
+			id = 17; meta = 0; break;            // coloured logs -> oak log
+		case 126: id = 157; break;               // activator rail
+		case 157: id = 125; break;               // double wooden slab
+		case 158: id = 126; break;               // wooden slab
+		case 159: case 160: case 161: case 162:
+			id = 44; meta = 0; break;            // coloured brick slabs -> stone slab
+		case 143: case 144: case 145: case 146: case 147: case 148:
+		case 149: case 150: case 151: case 152: case 153: case 154:
+		case 163: case 164: case 165: case 166:
+			id = 108; meta = m8Meta & 3; break;  // coloured brick stairs -> brick stairs
+		case 174: case 175: case 176: case 177: case 178: case 179:
+		case 180: case 181: case 182: case 183: case 184: case 185:
+		case 186: case 187: case 188: case 189:
+			id = 85; meta = 0; break;            // coloured fences -> oak fence
+		case 190: id = 175; break;               // double plant
+		case 191: case 192: case 239: case 240: case 241:
+			id = 38; meta = 0; break;            // extra flowers -> poppy
+		case 193: id = 193; break;               // spruce door
+		case 194: id = 194; break;               // birch door
+		case 95:  id = 166; meta = 0; break;     // invisible bedrock -> barrier
+		case 195: id = 95; break;                // stained glass
+		case 196: id = 160; break;               // stained glass pane
+		case 197: id = 188; break;               // spruce fence
+		case 198: id = 189; break;               // birch fence
+		case 201: case 202: case 203: case 204: case 205: case 206:
+		case 207: case 208: case 209: case 210: case 211: case 212:
+		case 213: case 214: case 215: case 216:
+			id = 26; meta = 0; break;            // coloured beds -> bed
+		case 217: id = 5; meta = 0; break;       // coloured planks -> oak planks
+		case 218: case 219: case 220: case 221: case 222: case 223:
+		case 224: case 225: case 226: case 227: case 228: case 229:
+		case 230: case 231: case 232: case 233:
+			id = 53; meta = m8Meta & 3; break;   // coloured stairs -> oak stairs
+		case 234: case 235: case 236: case 237:
+			id = 126; break;                     // coloured slabs -> wooden slab
+		case 238: id = 159; break;               // coloured bricks -> stained clay
+		case 244: id = 141; break;               // beetroot -> carrots
+		case 245: id = 58; meta = 0; break;      // stonecutter -> crafting table
+		case 246: id = 49; meta = 0; break;      // glowing obsidian -> obsidian
+		case 247: id = 4; meta = 0; break;       // nether reactor -> cobblestone
+		case 248: case 249: case 255:
+			id = 1; meta = 0; break;             // info blocks -> stone
+		case 250: id = 3; meta = 1; break;       // grass path -> coarse dirt
+		case 251: id = 44; break;                // mixed slab -> stone slab
+		case 252: id = 31; meta = 1; break;       // seagrass -> tall grass
+		default:
+			if(m8Id > 197) { id = 1; meta = 0; }
+			break;
+	}
+
+	if(outId) *outId = id;
+	if(outMeta) *outMeta = meta;
+}
+
+// ---------------------------------------------------------------------------
+// Items
+// ---------------------------------------------------------------------------
+
+/*
+ * m8's item ids line up with vanilla for everything it implements (256 iron
+ * shovel through 406 quartz), so translation is mostly the identity with a
+ * substitute for what m8 is missing. m8's own additions live at 456+.
+ */
+static int32_t javaItemFallback(int32_t javaItemId) {
+	switch(javaItemId) {
+		case 322: return 260; // golden_apple    -> apple
+		case 326: return 325; // water_bucket    -> bucket
+		case 327: return 325; // lava_bucket     -> bucket
+		case 333: return 280; // boat            -> stick
+		case 335: return 325; // milk_bucket     -> bucket
+		case 342: return 328; // chest_minecart  -> minecart
+		case 343: return 328; // furnace_minecart-> minecart
+		case 346: return 280; // fishing_rod     -> stick
+		case 349: return 319; // fish            -> raw porkchop
+		case 350: return 320; // cooked_fish     -> cooked porkchop
+		case 356: return 331; // repeater        -> redstone
+		case 357: return 297; // cookie          -> bread
+		case 358: return 339; // filled_map      -> paper
+		case 367: return 319; // rotten_flesh    -> raw porkchop
+		case 368: return 332; // ender_pearl     -> snowball
+		case 369: return 280; // blaze_rod       -> stick
+		case 370: return 341; // ghast_tear      -> slimeball
+		case 371: return 266; // gold_nugget     -> gold ingot
+		case 372: return 351; // nether_wart     -> dye
+		case 373: return 374; // potion          -> glass bottle (also missing, caught below)
+		case 375: return 351; // spider_eye      -> dye
+		case 376: return 351;
+		case 377: return 348; // blaze_powder    -> glowstone dust
+		case 378: return 341; // magma_cream     -> slimeball
+		case 379: return 340; // brewing_stand   -> book
+		case 380: return 265; // cauldron        -> iron ingot
+		case 381: return 264; // ender_eye       -> diamond
+		case 382: return 360; // speckled_melon  -> melon
+		case 384: return 332; // xp bottle       -> snowball
+		case 385: return 259; // fire_charge     -> flint and steel
+		case 386: return 340; // writable_book   -> book
+		case 387: return 340; // written_book    -> book
+		case 388: return 264; // emerald         -> diamond
+		case 389: return 321; // item_frame      -> painting
+		case 390: return 337; // flower_pot      -> clay
+		case 394: return 392; // poisonous_potato-> potato
+		case 395: return 339; // map             -> paper
+		case 396: return 391; // golden_carrot   -> carrot
+		case 397: return 352; // skull           -> bone
+		case 398: return 391; // carrot_on_stick -> carrot
+		case 399: return 348; // nether_star     -> glowstone dust
+		case 401: return 289; // fireworks       -> gunpowder
+		case 402: return 289;
+		case 403: return 340; // enchanted_book  -> book
+		case 404: return 331; // comparator      -> redstone
+		case 407: return 328; // tnt_minecart    -> minecart
+		case 408: return 328; // hopper_minecart -> minecart
+		case 409: return 406; // prismarine_shard-> quartz
+		case 410: return 406;
+		case 411: return 365; // rabbit          -> raw chicken
+		case 412: return 366; // cooked_rabbit    -> cooked chicken
+		case 413: return 282; // rabbit_stew     -> mushroom stew
+		case 414: return 341; // rabbit_foot     -> slimeball
+		case 415: return 334; // rabbit_hide     -> leather
+		case 416: return 280; // armor_stand     -> stick
+		case 417: return 306; // horse armor     -> iron chestplate
+		case 418: return 314;
+		case 419: return 310;
+		case 420: return 287; // lead            -> string
+		case 421: return 339; // name_tag        -> paper
+		case 422: return 328; // cmd minecart    -> minecart
+		case 423: return 319; // mutton          -> raw porkchop
+		case 424: return 320; // cooked_mutton   -> cooked porkchop
+		case 425: return 287; // banner          -> string
+		case 427: return 460; // spruce_door     -> m8 door_spruce
+		case 428: return 461; // birch_door      -> m8 door_birch
+		case 429: return 324; // jungle_door     -> wooden door
+		case 430: return 324; // acacia_door     -> wooden door
+		case 431: return 460; // dark_oak_door   -> m8 door_spruce
+		default:  return 0;
+	}
+}
+
+// The item ids m8 actually implements above 255, so we never hand Item::items
+// an index that is null.
+static bool_t m8HasItem(int32_t id) {
+	if(id < 256) return 0;
+	int32_t n = id - 256;
+	if(n <= 64) return 1;                                     // 256..320
+	switch(n) {
+		case 65: case 67: case 68: case 69: case 72: case 73: case 74:
+		case 75: case 76: case 78: case 80: case 81: case 82: case 83:
+		case 84: case 85: case 88: case 89: case 91: case 92: case 95:
+		case 96: case 97: case 98: case 99: case 103: case 104: case 105:
+		case 106: case 107: case 108: case 109: case 110: case 127:
+		case 135: case 136: case 137: case 144: case 149: case 150:
+		case 200: case 201: case 202: case 203: case 204: case 205:
+			return 1;
+		default:
+			return 0;
+	}
+}
+
+/*
+ * A tile existing is not the same as it being carryable: Item::items[] has no
+ * entry for the blocks 0.8.1 never handed the player (pressure plates, fire,
+ * flowing water...), and neither does it have one for every id m8HasItem's
+ * table claims.  An ItemInstance built on such an id still reports itself
+ * valid but leaves itemClass null, and the first getIcon / getName /
+ * getMaxStackSize on it takes the game down.  So nothing leaves this function
+ * without a registered Item behind it.
+ */
+static bool_t m8ItemRegistered(int32_t id) {
+	return id > 0 && id < 512 && Item::items[id] != 0;
+}
+
+int32_t JavaIdMap::javaItemToM8(int32_t javaItemId) {
+	if(javaItemId <= 0) return 0;
+
+	// Block items translate through the block table.
+	if(javaItemId < 256) {
+		int32_t id = 0, meta = 0;
+		JavaIdMap::javaBlockToM8(javaItemId, 0, &id, &meta);
+		if(!m8ItemRegistered(id) && !(id > 0 && id < 256 && Tile::tiles[id])) {
+			/*
+			 * Either the block has no item behind it, or - and this is the one
+			 * that took the game down - the block itself translates to air.  A
+			 * barrier used to land here: nothing in 0.8.1 looks like it, so the
+			 * table answered 0, and ItemInstance(0) reports itself *valid* with
+			 * both itemClass and tileClass null, because id 0 is how an empty
+			 * slot is spelled.  Hand that to ItemRenderer as a dropped stack
+			 * with a count and it dereferences itemClass->itemTexture on the
+			 * first frame it is on screen.  Anything holdable is better than
+			 * that, and it is a block either way.
+			 */
+			return m8ItemRegistered(1) ? 1 : 0;
+		}
+		return id;
+	}
+
+	if(m8HasItem(javaItemId) && m8ItemRegistered(javaItemId)) return javaItemId;
+
+	int32_t sub = javaItemFallback(javaItemId);
+	if(m8ItemRegistered(sub)) return sub;
+	return 0;
+}
+
+int32_t JavaIdMap::m8ItemToJava(int32_t m8ItemId) {
+	if(m8ItemId <= 0) return 0;
+
+	if(m8ItemId < 256) {
+		int32_t id = 0, meta = 0;
+		JavaIdMap::m8BlockToJava(m8ItemId, 0, &id, &meta);
+		return id;
+	}
+
+	switch(m8ItemId) {
+		case 456: return 280; // camera         -> stick
+		case 457: return 391; // beetroot       -> carrot
+		case 458: return 361; // beetroot seeds -> pumpkin seeds
+		case 459: return 282; // beetroot soup  -> mushroom stew
+		case 460: return 427; // door_spruce
+		case 461: return 428; // door_birch
+		case 383: return 383; // spawn egg
+		default:  return m8ItemId <= 406 ? m8ItemId : 0;
+	}
+}
+
+// ---------------------------------------------------------------------------
+// Entities
+// ---------------------------------------------------------------------------
+
+int32_t JavaIdMap::javaMobToM8(int32_t javaType) {
+	switch(javaType) {
+		case 50: return 33;  // creeper
+		case 51: return 34;  // skeleton
+		case 52: return 35;  // spider
+		case 53: return 32;  // giant       -> zombie
+		case 54: return 32;  // zombie
+		case 55: return 33;  // slime       -> creeper
+		case 56: return 33;  // ghast       -> creeper
+		case 57: return 36;  // zombie pigman
+		case 58: return 32;  // enderman    -> zombie
+		case 59: return 35;  // cave spider
+		case 60: return 35;  // silverfish  -> spider
+		case 61: return 34;  // blaze       -> skeleton
+		case 62: return 33;  // magma cube  -> creeper
+		case 63: return 35;  // ender dragon-> spider
+		case 64: return 34;  // wither      -> skeleton
+		case 65: return 10;  // bat         -> chicken
+		case 66: return 32;  // witch       -> zombie
+		case 67: return 35;  // endermite   -> spider
+		case 68: return 35;  // guardian    -> spider
+		case 90: return 12;  // pig
+		case 91: return 13;  // sheep
+		case 92: return 11;  // cow
+		case 93: return 10;  // chicken
+		case 94: return 35;  // squid       -> spider
+		case 95: return 12;  // wolf        -> pig
+		case 96: return 11;  // mooshroom   -> cow
+		case 97: return 13;  // snow golem  -> sheep
+		case 98: return 12;  // ocelot      -> pig
+		case 99: return 32;  // iron golem  -> zombie
+		case 100: return 12; // horse       -> pig
+		case 101: return 10; // rabbit      -> chicken
+		case 120: return 36; // villager    -> zombie pigman (neutral humanoid)
+		default: return 0;
+	}
+}
+
+/*
+ * The numbers here are EntityTrackerEntry.createSpawnPacket()'s, not the ones
+ * the wiki tables tend to imply - 70 is a falling block and 71 is an item
+ * frame, and paintings and XP orbs never travel in a Spawn Object packet at
+ * all (they have their own 0x10 and 0x11).  Getting this off by one slot is
+ * how a falling sand block used to arrive as a Painting with no motive, which
+ * crashed PaintingRenderer the moment it came into view.
+ *
+ * Anything with no plausible stand-in returns 0, and spawnObject() then skips
+ * it: an entity that is invisible is a cosmetic loss, an entity whose renderer
+ * dereferences a field m8 never filled in is a crash.
+ */
+int32_t JavaIdMap::javaObjectToM8(int32_t javaObjectType) {
+	switch(javaObjectType) {
+		case 1:  return 84; // boat            -> minecart
+		case 2:  return 64; // dropped item
+		case 10: return 84; // minecart
+		case 50: return 65; // primed tnt
+		case 51: return 0;  // ender crystal   -> nothing close enough
+		case 60: return 80; // arrow
+		case 61: return 81; // snowball
+		case 62: return 82; // thrown egg
+		case 63: return 81; // ghast fireball  -> snowball
+		case 64: return 81; // blaze fireball  -> snowball
+		case 65: return 81; // ender pearl     -> snowball
+		case 66: return 81; // wither skull    -> snowball
+		case 70: return 66; // falling block   (data is a Java block state id)
+		case 71: return 0;  // item frame      -> m8 has none
+		case 72: return 81; // eye of ender    -> snowball
+		case 73: return 81; // thrown potion   -> snowball
+		case 75: return 81; // xp bottle       -> snowball
+		case 76: return 81; // firework        -> snowball
+		case 77: return 0;  // leash knot
+		case 78: return 0;  // armor stand
+		case 90: return 0;  // fishing bobber
+		default: return 0;
+	}
+}
diff --git a/modifiedeight-newadditions/impl/java/JavaPing.cpp b/modifiedeight-newadditions/impl/java/JavaPing.cpp
new file mode 100644
index 00000000..84a14889
--- /dev/null
+++ b/modifiedeight-newadditions/impl/java/JavaPing.cpp
@@ -0,0 +1,281 @@
+#include <java/JavaPing.hpp>
+#include <java/JavaByteBuf.hpp>
+#include <java/JavaChat.hpp>
+#include <java/JavaLog.hpp>
+#include <java/JavaSession.hpp>
+#include <java/JavaSocket.hpp>
+#include <utils.h>
+#include <stdio.h>
+
+#include <map>
+#include <mutex>
+#include <thread>
+
+/*
+ * How long an answer is trusted before get() asks again.  The vanilla server
+ * list pings once when it opens and then only on demand; re-asking every few
+ * seconds while the screen is up costs one short-lived socket and keeps the
+ * player counts moving, which is nicer to look at.
+ */
+#define PING_TTL_MS      6000
+#define PING_CONNECT_MS  5000
+#define PING_READ_MS     5000
+// A status blob is a MOTD plus, usually, a 64x64 base64 favicon. 512 KiB is
+// several times more than any real server sends and stops a hostile or broken
+// one from making us allocate for ever.
+#define PING_MAX_FRAME   (512 * 1024)
+
+JavaPingResult::JavaPingResult() {
+	this->state = PENDING;
+	this->protocol = 0;
+	this->online = 0;
+	this->max = 0;
+	this->latencyMs = 0;
+}
+
+namespace {
+
+struct Entry
+{
+	JavaPingResult result;
+	// A thread is out asking right now; do not start a second one.
+	bool_t inFlight;
+	// getTimeMs() when the answer landed. Zero means "never answered".
+	int32_t answeredMs;
+
+	Entry() {
+		this->inFlight = 0;
+		this->answeredMs = 0;
+	}
+};
+
+/*
+ * Heap allocated and never freed on purpose.  The worker threads are detached,
+ * so one can still be finishing while the process shuts down, and a cache that
+ * is never destroyed cannot be written to after destruction.
+ */
+std::map<std::string, Entry>* cache() {
+	static std::map<std::string, Entry>* c = new std::map<std::string, Entry>();
+	return c;
+}
+
+std::mutex& cacheLock() {
+	static std::mutex* m = new std::mutex();
+	return *m;
+}
+
+// Length-prefixed, uncompressed: status never negotiates compression.
+bool_t sendPacket(JavaSocket* sock, const JavaByteBuf& body) {
+	JavaByteBuf frame;
+	frame.writeVarInt((int32_t)body.size());
+	frame.writeBuf(body);
+
+	int32_t sent = 0;
+	int32_t waited = 0;
+	while(sent < (int32_t)frame.size()) {
+		int32_t n = sock->sendSome(frame.data() + sent, (int32_t)frame.size() - sent);
+		if(n < 0) return 0;
+		if(n == 0) {
+			if(waited >= PING_READ_MS) return 0;
+			sleepMs(10);
+			waited += 10;
+			continue;
+		}
+		waited = 0;
+		sent += n;
+	}
+	return 1;
+}
+
+/*
+ * Reads one whole packet: a VarInt length, then that many bytes.  The length
+ * itself arrives a byte at a time, so read into a buffer and re-try the decode
+ * until it succeeds rather than assuming the first recv holds all of it.
+ */
+bool_t readPacket(JavaSocket* sock, std::vector<uint8_t>* out) {
+	std::vector<uint8_t> buf;
+	int32_t waited = 0;
+	int32_t frameLen = -1;
+	size_t headerLen = 0;
+
+	for(;;) {
+		if(frameLen < 0 && buf.size()) {
+			JavaByteBuf probe(&buf[0], buf.size());
+			int32_t len = probe.readVarInt();
+			if(!probe.failed()) {
+				if(len <= 0 || len > PING_MAX_FRAME) return 0;
+				frameLen = len;
+				headerLen = probe.readPos;
+			} else if(buf.size() >= 5) {
+				// Five bytes is the widest a VarInt gets; this is not one.
+				return 0;
+			}
+		}
+		if(frameLen >= 0 && buf.size() >= headerLen + (size_t)frameLen) {
+			out->assign(buf.begin() + headerLen, buf.begin() + headerLen + frameLen);
+			return 1;
+		}
+
+		uint8_t chunk[4096];
+		int32_t n = sock->recvSome(chunk, (int32_t)sizeof(chunk));
+		if(n < 0) return 0;
+		if(n == 0) {
+			if(waited >= PING_READ_MS) return 0;
+			sleepMs(10);
+			waited += 10;
+			continue;
+		}
+		waited = 0;
+		buf.insert(buf.end(), chunk, chunk + n);
+	}
+}
+
+// The blocking half, run on its own thread. Fills in *out and returns 1 on success.
+bool_t askServer(const std::string& host, int32_t typedPort, JavaPingResult* out) {
+	char_t portTxt[24];
+	sprintf(portTxt, ":%d", (int)typedPort);
+	// What the player typed, which is also what keys the cache.
+	std::string label = host + portTxt;
+
+	std::string ip, handshakeHost;
+	int32_t port = typedPort;
+	if(!JavaSocket::resolveMinecraftHost(host, typedPort, &ip, &port, &handshakeHost)) {
+		javaDebug("ping %s: could not resolve", label.c_str());
+		return 0;
+	}
+
+	JavaSocket sock;
+	if(!sock.beginConnect(ip, port)) {
+		javaDebug("ping %s: %s", label.c_str(), sock.lastError.c_str());
+		return 0;
+	}
+	int32_t waited = 0;
+	while(sock.state == JavaSocket::CONNECTING) {
+		if(waited >= PING_CONNECT_MS) {
+			javaDebug("ping %s: connect timed out", label.c_str());
+			return 0;
+		}
+		sock.pumpConnect();
+		if(sock.state == JavaSocket::CONNECTING) {
+			sleepMs(20);
+			waited += 20;
+		}
+	}
+	if(sock.state != JavaSocket::CONNECTED) {
+		javaDebug("ping %s: %s", label.c_str(), sock.lastError.c_str());
+		return 0;
+	}
+
+	int32_t sentAt = getTimeMs();
+
+	// Handshake, next state 1 (status) rather than the 2 that joining uses.
+	JavaByteBuf pk;
+	pk.writeVarInt(0x00);
+	pk.writeVarInt(JavaSession::PROTOCOL);
+	pk.writeString(handshakeHost);
+	pk.writeUShort((uint16_t)port);
+	pk.writeVarInt(1);
+	if(!sendPacket(&sock, pk)) return 0;
+
+	// Status Request: an id and nothing else.
+	pk.clear();
+	pk.writeVarInt(0x00);
+	if(!sendPacket(&sock, pk)) return 0;
+
+	std::vector<uint8_t> body;
+	if(!readPacket(&sock, &body)) {
+		javaDebug("ping %s: no status response", label.c_str());
+		return 0;
+	}
+
+	JavaByteBuf in(&body[0], body.size());
+	int32_t id = in.readVarInt();
+	std::string json = in.readString(PING_MAX_FRAME);
+	if(in.failed() || id != 0x00) {
+		javaDebug("ping %s: unexpected status packet 0x%02X", label.c_str(), (int)id);
+		return 0;
+	}
+
+	Json::Value root;
+	Json::Reader reader;
+	if(!reader.parse(json, root, false) || !root.isObject()) {
+		javaDebug("ping %s: status response is not JSON", label.c_str());
+		return 0;
+	}
+
+	out->state = JavaPingResult::ONLINE;
+	out->latencyMs = getTimeMs() - sentAt;
+	out->motd = javaChatToText(root["description"]);
+	// Only the first line fits in a list row.
+	size_t nl = out->motd.find('\n');
+	if(nl != std::string::npos) out->motd = out->motd.substr(0, nl);
+
+	const Json::Value& players = root["players"];
+	if(players.isObject()) {
+		out->online = players["online"].isIntegral() ? players["online"].asInt() : 0;
+		out->max = players["max"].isIntegral() ? players["max"].asInt() : 0;
+	}
+	const Json::Value& version = root["version"];
+	if(version.isObject()) {
+		// A version name is a plain string, but it is allowed to carry colour
+		// codes, and aternos in particular does.
+		if(version["name"].isString()) out->version = javaChatToText(version["name"]);
+		if(version["protocol"].isIntegral()) out->protocol = version["protocol"].asInt();
+	}
+
+	/*
+	 * A protocol of -1 (or 0) is how a front end says "there is no server behind
+	 * me": aternos answers for a stopped server with protocol -1, version
+	 * "\u00a7c\u25cf Offline" and 0/20 players, and a proxy in maintenance does
+	 * much the same. It answered, but nothing can be joined, so the honest thing
+	 * to show is Offline rather than a player count nobody is in.
+	 */
+	if(out->protocol <= 0) {
+		javaDebug("ping %s: answered with protocol %d (\"%s\") - not a joinable server",
+		          label.c_str(), (int)out->protocol, out->version.c_str());
+		out->state = JavaPingResult::OFFLINE;
+	}
+
+	if(out->state == JavaPingResult::ONLINE) {
+		javaDebug("ping %s: online %d/%d, %s (protocol %d), %d ms, motd \"%s\"",
+		          label.c_str(), (int)out->online, (int)out->max, out->version.c_str(),
+		          (int)out->protocol, (int)out->latencyMs, out->motd.c_str());
+	}
+	return 1;
+}
+
+void askAndStore(std::string key, std::string host, int32_t typedPort) {
+	JavaPingResult r;
+	if(!askServer(host, typedPort, &r)) {
+		r = JavaPingResult();
+		r.state = JavaPingResult::OFFLINE;
+	}
+
+	std::lock_guard<std::mutex> lock(cacheLock());
+	std::map<std::string, Entry>::iterator it = cache()->find(key);
+	if(it == cache()->end()) return;
+	it->second.result = r;
+	it->second.answeredMs = getTimeMs();
+	// getTimeMs() is a millisecond count that starts at zero, so it really can
+	// be zero here, and zero is the "never answered" marker.
+	if(it->second.answeredMs == 0) it->second.answeredMs = 1;
+	it->second.inFlight = 0;
+}
+
+} // namespace
+
+JavaPingResult JavaPing::get(const std::string& host, int32_t typedPort) {
+	char_t portTxt[24];
+	sprintf(portTxt, ":%d", (int)typedPort);
+	std::string key = host + portTxt;
+
+	std::lock_guard<std::mutex> lock(cacheLock());
+	Entry& e = (*cache())[key];
+
+	bool_t stale = e.answeredMs != 0 && (int32_t)(getTimeMs() - e.answeredMs) >= PING_TTL_MS;
+	if(!e.inFlight && (e.answeredMs == 0 || stale)) {
+		e.inFlight = 1;
+		std::thread(askAndStore, key, host, typedPort).detach();
+	}
+	return e.result;
+}
diff --git a/modifiedeight-newadditions/impl/java/JavaSession.cpp b/modifiedeight-newadditions/impl/java/JavaSession.cpp
new file mode 100644
index 00000000..4fb77dc5
--- /dev/null
+++ b/modifiedeight-newadditions/impl/java/JavaSession.cpp
@@ -0,0 +1,2541 @@
+#include <java/JavaSession.hpp>
+#include <level/LevelHeight.hpp>
+#include <java/JavaChunkData.hpp>
+#include <java/JavaLog.hpp>
+#include <java/JavaChunkSource.hpp>
+#include <java/JavaIdMap.hpp>
+#include <java/JavaY.hpp>
+
+#include <Minecraft.hpp>
+#include <entity/player/User.hpp>
+#include <gui/Gui.hpp>
+#include <gui/screens/DisconnectionScreen.hpp>
+#include <entity/LocalPlayer.hpp>
+#include <level/MultiPlayerLevel.hpp>
+#include <level/LevelSettings.hpp>
+#include <level/chunk/LevelChunk.hpp>
+#include <level/dimension/Dimension.hpp>
+#include <level/storage/LevelStorageSource.hpp>
+#include <tile/Tile.hpp>
+#include <tile/entity/SignTileEntity.hpp>
+#include <item/Item.hpp>
+#include <item/ItemInstance.hpp>
+#include <inventory/Inventory.hpp>
+#include <entity/Mob.hpp>
+#include <entity/MobFactory.hpp>
+#include <entity/EntityFactory.hpp>
+#include <entity/RemotePlayer.hpp>
+#include <entity/ItemEntity.hpp>
+#include <entity/FallingTile.hpp>
+#include <entity/Painting.hpp>
+#include <entity/player/gamemode/GameMode.hpp>
+#include <util/Util.hpp>
+#include <utils.h>
+
+#include <java/JavaChat.hpp>
+#include <zlib.h>
+#include <math.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <string.h>
+
+/*
+ * Connection milestones go to stdout unconditionally - there are only a handful
+ * per session and they are the first thing anyone needs when a join goes wrong.
+ * Per packet noise is behind M8_JAVA_DEBUG=1 in the environment.
+ */
+void javaLog(const char_t* fmt, ...) {
+	va_list ap;
+	va_start(ap, fmt);
+	fputs("[java] ", stdout);
+	vprintf(fmt, ap);
+	fputc('\n', stdout);
+	fflush(stdout);
+	va_end(ap);
+}
+
+bool_t javaDebugEnabled() {
+	static int32_t cached = -1;
+	if(cached < 0) {
+		const char_t* v = getenv("M8_JAVA_DEBUG");
+		cached = (v && v[0] && v[0] != '0') ? 1 : 0;
+	}
+	return (bool_t)cached;
+}
+
+/*
+ * M8_JAVA_DEBUG=2 additionally names every packet that crosses the wire in
+ * either direction.  A verification lobby is a conversation held entirely in
+ * packets nothing on screen ever mentions, and this is the only way to see it.
+ */
+bool_t javaTraceEnabled() {
+	static int32_t cached = -1;
+	if(cached < 0) {
+		const char_t* v = getenv("M8_JAVA_DEBUG");
+		cached = (v && v[0] && v[0] != '0' && v[0] != '1') ? 1 : 0;
+	}
+	return (bool_t)cached;
+}
+
+void javaDebug(const char_t* fmt, ...) {
+	if(!javaDebugEnabled()) {
+		return;
+	}
+	va_list ap;
+	va_start(ap, fmt);
+	fputs("[java] ", stdout);
+	vprintf(fmt, ap);
+	fputc('\n', stdout);
+	fflush(stdout);
+	va_end(ap);
+}
+
+JavaSession::JavaSession() {
+	this->inOff = 0;
+	this->outOff = 0;
+	this->compressionThreshold = -1;
+	this->phase = JavaSession::IDLE;
+	this->port = 0;
+	this->reportedFailure = 0;
+	this->minecraft = 0;
+	this->level = 0;
+	this->chunkSource = 0;
+	this->player = 0;
+	this->levelRequested = 0;
+	this->levelLive = 0;
+	this->serverEid = 0;
+	this->gamemode = 0;
+	this->dimension = 0;
+	this->hasSkyLight = 1;
+	this->posX = 0.0;
+	this->posY = 64.0;
+	this->posZ = 0.0;
+	this->rotYaw = 0.0f;
+	this->rotPitch = 0.0f;
+	this->havePosition = 0;
+	this->deferredBytes = 0;
+	this->deferredOverflowed = 0;
+	this->tickCounter = 0;
+	this->sentX = 0.0;
+	this->sentY = 0.0;
+	this->sentZ = 0.0;
+	this->sentYaw = 0.0f;
+	this->sentPitch = 0.0f;
+	this->sentGround = 0;
+	this->everSentPosition = 0;
+	this->positionUpdateTicks = 0;
+	this->sentSprint = 0;
+	this->sentSneak = 0;
+	this->lastMoveSentMs = 0;
+	this->moveWindowMs = 0;
+	memset(this->moveWindow, 0, sizeof(this->moveWindow));
+	this->selectedSlot = 0;
+	this->nextParkedEid = -2;
+	this->respawnHold = 0;
+	this->abilityFlags = 0;
+	this->hasAbilityFlags = 0;
+}
+
+JavaSession::~JavaSession() {
+	this->socket.close();
+}
+
+bool_t JavaSession::isActive() const {
+	return this->phase != JavaSession::IDLE && this->phase != JavaSession::CLOSED;
+}
+
+bool_t JavaSession::begin(Minecraft* mc, const std::string& name, const std::string& host,
+                          int32_t typedPort, const std::string& user) {
+	JavaSocket::globalInit();
+
+	this->minecraft = mc;
+	this->displayName = name;
+	this->username = user;
+	this->phase = JavaSession::IDLE;
+	this->failure = "";
+	this->reportedFailure = 0;
+
+	std::string connectHost;
+	if(!JavaSocket::resolveMinecraftHost(host, typedPort, &this->ip, &this->port, &connectHost)) {
+		this->fail("Could not resolve " + host);
+		return 0;
+	}
+	this->handshakeHost = connectHost;
+	javaLog("connecting to %s:%d (handshake host \"%s\") as \"%s\"", this->ip.c_str(),
+	        (int)this->port, this->handshakeHost.c_str(), this->username.c_str());
+
+	if(!this->socket.beginConnect(this->ip, this->port)) {
+		this->fail("Could not connect to " + this->ip + ": " + this->socket.lastError);
+		return 0;
+	}
+	this->phase = JavaSession::CONNECTING;
+	return 1;
+}
+
+void JavaSession::fail(const std::string& why) {
+	if(this->failure.size()) {
+		return;
+	}
+	this->failure = why;
+	this->phase = JavaSession::CLOSED;
+	this->socket.close();
+	javaLog("session ended: %s", why.c_str());
+}
+
+void JavaSession::shutdown() {
+	this->socket.close();
+	this->phase = JavaSession::CLOSED;
+	this->inBuf.clear();
+	this->outBuf.clear();
+	this->inOff = 0;
+	this->outOff = 0;
+	this->deferred.clear();
+	this->deferredBytes = 0;
+	this->level = 0;
+	this->chunkSource = 0;
+	this->player = 0;
+	this->levelRequested = 0;
+	this->levelLive = 0;
+	this->knownEntities.clear();
+	this->pendingItems.clear();
+	this->playerNames.clear();
+	this->nextParkedEid = -2;
+	this->respawnHold = 0;
+	this->abilityFlags = 0;
+	this->hasAbilityFlags = 0;
+}
+
+// ---------------------------------------------------------------- wire ------
+
+void JavaSession::compactIn() {
+	if(this->inOff == 0) {
+		return;
+	}
+	if(this->inOff >= this->inBuf.size()) {
+		this->inBuf.clear();
+		this->inOff = 0;
+		return;
+	}
+	// Only pay for the move once the dead prefix is worth reclaiming.
+	if(this->inOff < 65536 && this->inOff * 2 < this->inBuf.size()) {
+		return;
+	}
+	this->inBuf.erase(this->inBuf.begin(), this->inBuf.begin() + (long)this->inOff);
+	this->inOff = 0;
+}
+
+void JavaSession::flushOut() {
+	while(this->outOff < this->outBuf.size()) {
+		int32_t chunk = (int32_t)(this->outBuf.size() - this->outOff);
+		if(chunk > 32768) chunk = 32768;
+		int32_t n = this->socket.sendSome(&this->outBuf[this->outOff], chunk);
+		if(n < 0) {
+			this->fail("Connection lost: " + this->socket.lastError);
+			return;
+		}
+		if(n == 0) {
+			break; // socket buffer full, try again next frame
+		}
+		this->outOff += (size_t)n;
+	}
+	if(this->outOff >= this->outBuf.size()) {
+		this->outBuf.clear();
+		this->outOff = 0;
+	} else if(this->outOff >= 65536) {
+		this->outBuf.erase(this->outBuf.begin(), this->outBuf.begin() + (long)this->outOff);
+		this->outOff = 0;
+	}
+}
+
+void JavaSession::beginPacket(JavaByteBuf* out, int32_t id) {
+	out->clear();
+	out->writeVarInt(id);
+}
+
+void JavaSession::send(const JavaByteBuf& payload) {
+	if(this->phase == JavaSession::CLOSED || this->phase == JavaSession::IDLE) {
+		return;
+	}
+	if(javaTraceEnabled() && payload.size()) {
+		int32_t id = payload.data()[0];
+		// The four movement ids go out twenty times a second and the air trace
+		// already accounts for them.
+		if(id < 0x03 || id > 0x06) {
+			javaDebug("-> 0x%02X (%d bytes)", (int)id, (int)payload.size());
+		}
+	}
+	JavaByteBuf frame;
+	if(this->compressionThreshold < 0) {
+		frame.writeVarInt((int32_t)payload.size());
+		frame.writeBytes(payload.data(), payload.size());
+	} else if((int32_t)payload.size() >= this->compressionThreshold) {
+		uLongf cap = compressBound((uLong)payload.size());
+		std::vector<uint8_t> comp((size_t)cap);
+		if(compress2(&comp[0], &cap, payload.data(), (uLong)payload.size(), Z_DEFAULT_COMPRESSION) != Z_OK) {
+			this->fail("Could not compress an outgoing packet");
+			return;
+		}
+		JavaByteBuf inner;
+		inner.writeVarInt((int32_t)payload.size());
+		inner.writeBytes(&comp[0], (size_t)cap);
+		frame.writeVarInt((int32_t)inner.size());
+		frame.writeBytes(inner.data(), inner.size());
+	} else {
+		// Under the threshold: the length prefix stays, the data does not get
+		// deflated, and a zero uncompressed-length says so.
+		frame.writeVarInt((int32_t)payload.size() + 1);
+		frame.writeVarInt(0);
+		frame.writeBytes(payload.data(), payload.size());
+	}
+	this->outBuf.insert(this->outBuf.end(), frame.bytes.begin(), frame.bytes.end());
+}
+
+bool_t JavaSession::decodeFrame(const uint8_t* raw, size_t rawLen, JavaByteBuf* out) {
+	if(this->compressionThreshold < 0) {
+		out->bytes.assign(raw, raw + rawLen);
+		out->reset();
+		return 1;
+	}
+
+	JavaByteBuf head(raw, rawLen);
+	int32_t uncompressedLen = head.readVarInt();
+	if(head.failed()) {
+		return 0;
+	}
+	size_t consumed = head.readPos;
+	if(uncompressedLen == 0) {
+		out->bytes.assign(raw + consumed, raw + rawLen);
+		out->reset();
+		return 1;
+	}
+	if(uncompressedLen < 0 || uncompressedLen > JavaSession::MAX_FRAME) {
+		return 0;
+	}
+	out->bytes.resize((size_t)uncompressedLen);
+	uLongf destLen = (uLongf)uncompressedLen;
+	int rc = uncompress(&out->bytes[0], &destLen, raw + consumed, (uLong)(rawLen - consumed));
+	if(rc != Z_OK || destLen != (uLongf)uncompressedLen) {
+		return 0;
+	}
+	out->reset();
+	return 1;
+}
+
+void JavaSession::pumpSocket() {
+	uint8_t buf[16384];
+	for(int32_t guard = 0; guard < 256; ++guard) {
+		int32_t n = this->socket.recvSome(buf, (int32_t)sizeof(buf));
+		if(n < 0) {
+			this->fail(this->socket.lastError.size() ? ("Connection lost: " + this->socket.lastError)
+			                                        : std::string("Server closed the connection"));
+			return;
+		}
+		if(n == 0) {
+			return;
+		}
+		this->inBuf.insert(this->inBuf.end(), buf, buf + n);
+		if(n < (int32_t)sizeof(buf)) {
+			return;
+		}
+	}
+}
+
+void JavaSession::dispatchFrames() {
+	while(1) {
+		size_t avail = this->inBuf.size() - this->inOff;
+		if(avail == 0) {
+			break;
+		}
+		const uint8_t* p = &this->inBuf[this->inOff];
+
+		// Frame length, as a VarInt that may not have arrived in full yet.
+		int32_t length = 0;
+		size_t lenBytes = 0;
+		bool_t complete = 0;
+		while(lenBytes < avail && lenBytes < 5) {
+			uint8_t b = p[lenBytes];
+			length |= (int32_t)(b & 0x7F) << (int32_t)(7 * lenBytes);
+			++lenBytes;
+			if((b & 0x80) == 0) {
+				complete = 1;
+				break;
+			}
+		}
+		if(!complete) {
+			if(lenBytes >= 5) {
+				this->fail("Malformed packet length from server");
+			}
+			break;
+		}
+		if(length < 0 || length > JavaSession::MAX_FRAME) {
+			this->fail("Server sent an implausible packet length");
+			break;
+		}
+		if(avail < lenBytes + (size_t)length) {
+			break; // rest of the frame still in flight
+		}
+
+		JavaByteBuf frame;
+		bool_t ok = this->decodeFrame(p + lenBytes, (size_t)length, &frame);
+		this->inOff += lenBytes + (size_t)length;
+		if(!ok) {
+			this->fail("Could not decompress a packet from the server");
+			break;
+		}
+
+		int32_t id = frame.readVarInt();
+		if(frame.failed()) {
+			continue;
+		}
+		if(this->phase == JavaSession::LOGIN) {
+			this->handleLoginPacket(&frame, id);
+		} else if(this->phase == JavaSession::PLAY) {
+			this->handlePlayPacket(&frame, id);
+		}
+		if(this->phase == JavaSession::CLOSED) {
+			break;
+		}
+	}
+	this->compactIn();
+}
+
+void JavaSession::sendHandshakeAndLogin() {
+	JavaByteBuf pk;
+	this->beginPacket(&pk, 0x00);
+	pk.writeVarInt(JavaSession::PROTOCOL);
+	pk.writeString(this->handshakeHost);
+	pk.writeUShort((uint16_t)this->port);
+	pk.writeVarInt(2); // next state: login
+	this->send(pk);
+	javaLog("tcp up, sending handshake (protocol %d) + login start", (int)JavaSession::PROTOCOL);
+
+	this->beginPacket(&pk, 0x00);
+	pk.writeString(this->username);
+	this->send(pk);
+
+	this->phase = JavaSession::LOGIN;
+}
+
+void JavaSession::pump() {
+	if(this->phase == JavaSession::IDLE) {
+		return;
+	}
+
+	if(this->phase == JavaSession::CLOSED) {
+		if(this->failure.size() && !this->reportedFailure && this->minecraft) {
+			this->reportedFailure = 1;
+			if(this->levelLive) {
+				this->minecraft->gui.addMessage("", this->failure, 2400);
+				this->minecraft->setScreen(new DisconnectionScreen(this->failure));
+				this->minecraft->setLeaveGame();
+			} else {
+				this->minecraft->setScreen(new DisconnectionScreen(this->failure));
+			}
+		}
+		return;
+	}
+
+	if(this->phase == JavaSession::CONNECTING) {
+		this->socket.pumpConnect();
+		if(this->socket.state == JavaSocket::FAILED) {
+			this->fail("Could not connect to " + this->ip + ": " + this->socket.lastError);
+			return;
+		}
+		if(this->socket.state != JavaSocket::CONNECTED) {
+			return;
+		}
+		this->sendHandshakeAndLogin();
+	}
+
+	this->pumpSocket();
+	if(this->phase == JavaSession::CLOSED) {
+		return;
+	}
+	this->dispatchFrames();
+	if(this->phase == JavaSession::CLOSED) {
+		return;
+	}
+
+	// The level finished building on the worker thread; everything held back
+	// while that was happening can be applied now.
+	if(this->levelRequested && !this->levelLive && this->minecraft &&
+	   this->minecraft->levelGenerated && !this->minecraft->field_CF4) {
+		this->levelLive = 1;
+		javaLog("level live, world is now server driven");
+		this->player = this->minecraft->player;
+		/*
+		 * Both of these describe a player that did not exist when the server
+		 * described it.  Gamemode first, because it is the default the abilities
+		 * packet is allowed to override.
+		 */
+		this->applyGameMode();
+		this->flushDeferred();
+		this->pushCreativeInventory();
+	}
+
+	if(this->levelLive) {
+		++this->tickCounter;
+		this->holdPlayerForTerrain();
+		/*
+		 * Movement is reported from playerTick(), once per game tick, exactly
+		 * like a Java client.  This is only the safety net for the stretches
+		 * where the player is not being ticked at all - a screen open over the
+		 * world, terrain still loading, the death screen - so that the server
+		 * still hears where we are about once a second.
+		 */
+		if((int32_t)(getTimeMs() - this->lastMoveSentMs) > 1000) {
+			this->sendPositionNow(1);
+		}
+		this->syncHeldSlot();
+		if(javaDebugEnabled() && (this->tickCounter % 200) == 0) {
+			double px = 0, py = 0, pz = 0;
+			if(this->player) {
+				px = this->player->posX;
+				py = JavaY::toJavad(this->player->boundingBox.minY);
+				pz = this->player->posZ;
+			}
+			javaDebug("t=%d pos %.1f %.1f %.1f entities=%d chunks=%d",
+			          (int)this->tickCounter, px, py, pz,
+			          (int)this->knownEntities.size(),
+			          this->chunkSource ? (int)this->chunkSource->residentCount : 0);
+		}
+	}
+
+	this->flushOut();
+}
+
+void JavaSession::deferFrame(const JavaByteBuf& frame, int32_t id) {
+	if(this->deferredBytes > JavaSession::MAX_DEFERRED) {
+		if(!this->deferredOverflowed) {
+			this->deferredOverflowed = 1;
+			printf("[java] deferred packet buffer full, dropping world data\n");
+		}
+		return;
+	}
+	std::vector<uint8_t> keep;
+	keep.reserve(frame.bytes.size() + 5);
+	JavaByteBuf head;
+	head.writeVarInt(id);
+	keep.insert(keep.end(), head.bytes.begin(), head.bytes.end());
+	keep.insert(keep.end(), frame.bytes.begin() + (long)frame.readPos, frame.bytes.end());
+	this->deferredBytes += keep.size();
+	this->deferred.push_back(keep);
+}
+
+void JavaSession::flushDeferred() {
+	// Swap first: a handler could in principle defer again, and it must not
+	// append into the container being walked.
+	std::vector<std::vector<uint8_t> > pending;
+	pending.swap(this->deferred);
+	this->deferredBytes = 0;
+	for(size_t i = 0; i < pending.size(); ++i) {
+		JavaByteBuf frame(&pending[i][0], pending[i].size());
+		int32_t id = frame.readVarInt();
+		if(frame.failed()) continue;
+		this->handlePlayPacket(&frame, id);
+		if(this->phase == JavaSession::CLOSED) {
+			return;
+		}
+	}
+}
+
+// --------------------------------------------------------------- login ------
+
+void JavaSession::handleLoginPacket(JavaByteBuf* in, int32_t id) {
+	switch(id) {
+	case 0x00: { // Disconnect
+		std::string json = in->readString();
+		std::string why = javaChatToText(json);
+		this->fail(why.size() ? why : std::string("Server refused the connection"));
+		break;
+	}
+	case 0x01: // Encryption Request
+		this->fail("This server is in online mode. m8 can only join offline-mode (cracked) Java servers.");
+		break;
+	case 0x02: { // Login Success
+		in->readString(); // uuid
+		std::string name = in->readString(16);
+		if(name.size()) {
+			this->username = name;
+		}
+		this->phase = JavaSession::PLAY;
+		javaLog("login accepted as \"%s\"", this->username.c_str());
+		break;
+	}
+	case 0x03: { // Set Compression
+		int32_t threshold = in->readVarInt();
+		if(!in->failed()) {
+			this->compressionThreshold = threshold;
+			javaLog("compression enabled, threshold %d", (int)threshold);
+		}
+		break;
+	}
+	default:
+		break;
+	}
+}
+
+// ---------------------------------------------------------------- play ------
+
+void JavaSession::handlePlayPacket(JavaByteBuf* in, int32_t id) {
+	if(javaTraceEnabled()) {
+		javaDebug("<- 0x%02X (%d bytes)", (int)id, (int)(in->bytes.size() - in->readPos));
+	}
+	// A handful of packets must run whatever state the level is in: the
+	// keepalive keeps us connected, the disconnect reason has to be shown, the
+	// compression switch changes how every later frame is framed, and the join
+	// plus first position are what build the level in the first place.
+	switch(id) {
+	case 0x00: { // Keep Alive
+		int32_t token = in->readVarInt();
+		if(!in->failed()) this->sendKeepAlive(token);
+		return;
+	}
+	case 0x40: { // Disconnect
+		std::string why = javaChatToText(in->readString());
+		this->fail(why.size() ? why : std::string("Disconnected by server"));
+		return;
+	}
+	case 0x46: { // Set Compression (play state)
+		int32_t threshold = in->readVarInt();
+		if(!in->failed()) this->compressionThreshold = threshold;
+		return;
+	}
+	case 0x01: { // Join Game
+		this->serverEid = in->readInt();
+		this->gamemode = in->readByte() & 0x7;
+		this->dimension = in->readSByte();
+		in->readByte();   // difficulty
+		in->readByte();   // max players
+		in->readString(); // level type
+		this->hasSkyLight = this->dimension != -1;
+		javaLog("join game: eid=%d gamemode=%d dimension=%d skylight=%d",
+		        (int)this->serverEid, (int)this->gamemode, (int)this->dimension,
+		        (int)this->hasSkyLight);
+		/*
+		 * NetHandlerPlayClient.handleJoinGame ends with exactly these two
+		 * packets - settings first, then the brand - and it sends them there and
+		 * not later, before a single chunk has arrived.  The order and the
+		 * timing both matter: the anti-bot front ends public servers put in
+		 * front of the real server (Sonar and the like) hold every new
+		 * connection in a limbo world and wait for that pair before they will
+		 * hand it on, and a client that never sends them is dropped as a bot.
+		 * That is why joining used to work only after a real Java client had
+		 * been on the same address - the check remembers verified addresses for
+		 * a while, and m8 was riding on that rather than passing.
+		 */
+		this->sendClientSettings();
+		this->sendClientBrand();
+		return;
+	}
+	case 0x08: { // Player Position And Look
+		double x = in->readDouble();
+		double y = in->readDouble();
+		double z = in->readDouble();
+		float yaw = in->readFloat();
+		float pitch = in->readFloat();
+		int32_t flags = in->readByte();
+		if(in->failed()) return;
+
+		// Relative bits: 0x01 X, 0x02 Y, 0x04 Z, 0x08 yaw, 0x10 pitch.
+		if(flags & 0x01) x += this->posX;
+		if(flags & 0x02) y += this->posY;
+		if(flags & 0x04) z += this->posZ;
+		if(flags & 0x08) yaw += this->rotYaw;
+		if(flags & 0x10) pitch += this->rotPitch;
+
+		this->posX = x;
+		this->posY = y;
+		this->posZ = z;
+		this->rotYaw = yaw;
+		this->rotPitch = pitch;
+		this->havePosition = 1;
+
+		if(!this->levelRequested) {
+			this->createLevel();
+			return;
+		}
+		javaDebug("in teleport %.2f %.2f %.2f (was %.2f %.2f %.2f, d=%.3f) flags=%d",
+		          x, y, z, this->sentX, this->sentY, this->sentZ,
+		          sqrt((x - this->sentX) * (x - this->sentX)
+		             + (y - this->sentY) * (y - this->sentY)
+		             + (z - this->sentZ) * (z - this->sentZ)),
+		          (int)flags);
+
+		if(this->levelLive && this->player) {
+			// setPos() offsets the box by ySize, so a step still in progress would
+			// shift a server teleport up by as much as half a block.  The server
+			// has just told us exactly where we are; there is nothing left to
+			// smooth over.
+			this->player->ySize = 0.0f;
+			this->player->moveTo((float)x, (float)JavaY::toM8d(y), (float)z, yaw, pitch);
+			this->player->motionX = 0.0;
+			this->player->motionY = 0.0;
+			this->player->motionZ = 0.0;
+			this->sentX = x;
+			this->sentY = y;
+			this->sentZ = z;
+			this->sentYaw = yaw;
+			this->sentPitch = pitch;
+			this->everSentPosition = 1;
+		}
+		// 1.8 wants the exact same values echoed back to confirm the teleport.
+		JavaByteBuf pk;
+		this->beginPacket(&pk, 0x06);
+		pk.writeDouble(x);
+		pk.writeDouble(y);
+		pk.writeDouble(z);
+		pk.writeFloat(yaw);
+		pk.writeFloat(pitch);
+		pk.writeBool(1);
+		this->send(pk);
+		return;
+	}
+	case 0x3F: { // Plugin Message
+		/*
+		 * Nothing here speaks any of these channels, but which channel a server
+		 * opens says a lot about what it is running, and that is the first thing
+		 * worth knowing when a login is being refused.
+		 */
+		std::string channel = in->readString();
+		if(!in->failed()) {
+			javaDebug("in plugin message '%s' (%d bytes)", channel.c_str(),
+			          (int)(in->bytes.size() - in->readPos));
+		}
+		return;
+	}
+	case 0x48: { // Resource Pack Send
+		std::string url = in->readString();
+		std::string hash = in->readString();
+		if(in->failed()) return;
+		javaLog("server offers resource pack %s", url.c_str());
+		/*
+		 * m8 cannot load a Java resource pack, but the reply is not about the
+		 * pack: a server that sends this and hears nothing back is entitled to
+		 * assume the client is not a client at all, and some verification plugins
+		 * use exactly that.  Vanilla answers ACCEPTED and then, once the download
+		 * finishes, SUCCESSFULLY_LOADED, so answer both.
+		 */
+		this->sendResourcePackStatus(hash, 3); // ACCEPTED
+		this->sendResourcePackStatus(hash, 0); // SUCCESSFULLY_LOADED
+		return;
+	}
+	case 0x41: // Server Difficulty
+	case 0x37: // Statistics
+	case 0x44: // World Border
+	case 0x45: // Title
+	case 0x47: // Player List Header/Footer
+		return;
+	default:
+		break;
+	}
+
+	if(!this->levelLive) {
+		this->deferFrame(*in, id);
+		return;
+	}
+	if(!this->level) {
+		return;
+	}
+
+	switch(id) {
+	case 0x02: { // Chat Message
+		std::string json = in->readString(32767);
+		if(in->failed()) return;
+		javaDebug("in chat json: %s", json.c_str());
+		in->readByte(); // position: 0 chat, 1 system, 2 action bar
+		std::string text = javaChatToText(json);
+		if(text.size() && this->minecraft) {
+			this->minecraft->gui.addMessage("", text, 200);
+		}
+		return;
+	}
+	case 0x03: { // Time Update
+		int64_t worldAge = in->readLong();
+		int64_t timeOfDay = in->readLong();
+		if(in->failed()) return;
+		(void)worldAge;
+		/*
+		 * Two things had to be said in m8's own terms before the sun would move.
+		 *
+		 * A day is 24000 ticks in Java and 19200 in 0.8.1, and
+		 * NormalDayCycleDimension::getTimeOfDay divides by its own 19200, so the
+		 * raw server clock put the sun in the wrong place and slid it backwards
+		 * every time the server spoke.  Scale it.
+		 *
+		 * A negative time is how the server spells doDaylightCycle=false; the
+		 * magnitude is still the time of day.  m8 freezes its sky through
+		 * levelData.stopTime - Level::getTimeOfDay prefers stopTime over the
+		 * clock whenever it is not negative - so mirror the rule there instead
+		 * of dropping the sign on the floor.
+		 */
+		bool_t frozen = timeOfDay < 0;
+		if(frozen) timeOfDay = -timeOfDay;
+		int32_t m8Time = (int32_t)((timeOfDay % 24000) * 19200 / 24000);
+		this->level->setTime(m8Time);
+		this->level->levelData.setStopTime(frozen ? m8Time : -1);
+		this->level->adventureSettings.daylightCycle = frozen ? 0 : 1;
+		return;
+	}
+	case 0x04: { // Entity Equipment
+		int32_t eid = in->readVarInt();
+		int32_t slot = in->readShort();
+		int32_t itemId = 0, count = 0, damage = 0;
+		if(!this->readSlot(in, &itemId, &count, &damage, 0)) return;
+		if(slot != 0) return; // only the held item is renderable here
+		Entity* e = this->findEntity(eid);
+		if(e && e->isPlayer()) {
+			Player* p = (Player*)e;
+			if(p->inventory) {
+				if(itemId > 0) {
+					ItemInstance ii(JavaIdMap::javaItemToM8(itemId), count > 0 ? count : 1, damage);
+					p->inventory->replaceSlot(9, &ii);
+				} else {
+					p->inventory->clearSlot(9);
+				}
+				p->inventory->moveToSelectedSlot(9);
+			}
+		}
+		return;
+	}
+	case 0x05: { // Spawn Position
+		int32_t x = 0, y = 0, z = 0;
+		in->readPosition(&x, &y, &z);
+		if(in->failed()) return;
+		Pos spawn;
+		spawn.x = x;
+		spawn.y = JavaY::clampM8(JavaY::toM8(y));
+		spawn.z = z;
+		this->level->setSpawnPos(spawn);
+		return;
+	}
+	case 0x06: { // Update Health
+		float health = in->readFloat();
+		in->readVarInt();  // food
+		in->readFloat();   // saturation
+		if(in->failed()) return;
+		if(this->player) {
+			int32_t hp = (int32_t)(health + 0.5f);
+			if(hp < 0) hp = 0;
+			if(hp > 20) hp = 20;
+			this->player->hurtTo(hp);
+		}
+		return;
+	}
+	case 0x07: { // Respawn
+		this->dimension = in->readInt();
+		in->readByte();   // difficulty
+		this->gamemode = in->readByte() & 0x7;
+		in->readString(); // level type
+		if(in->failed()) return;
+		this->hasSkyLight = this->dimension != -1;
+		this->resetForRespawn();
+		if(this->minecraft) {
+			this->applyGameMode();
+			if(this->minecraft->currentScreen) this->minecraft->setScreen(0);
+		}
+		return;
+	}
+	case 0x09: { // Held Item Change
+		int32_t slot = in->readSByte();
+		if(in->failed() || slot < 0 || slot > 8) return;
+		this->selectedSlot = slot;
+		if(this->player && this->player->inventory) {
+			this->player->inventory->selectSlot(slot);
+		}
+		return;
+	}
+	case 0x0B: { // Animation
+		int32_t eid = in->readVarInt();
+		int32_t action = in->readByte();
+		if(in->failed()) return;
+		Entity* e = this->findEntity(eid);
+		if(e && action == 0 && e->isPlayer() && e != (Entity*)this->player) {
+			((Player*)e)->swing();
+		}
+		return;
+	}
+	case 0x0C:
+		this->spawnPlayer(in);
+		return;
+	case 0x0D: { // Collect Item
+		int32_t collected = in->readVarInt();
+		int32_t collector = in->readVarInt();
+		if(in->failed()) return;
+		Entity* e = this->findEntity(collected);
+		if(e) {
+			this->level->playSound(e, "random.pop", 0.2f, 2.0f);
+			this->destroyEntity(collected);
+		}
+		(void)collector;
+		return;
+	}
+	case 0x0E:
+		this->spawnObject(in);
+		return;
+	case 0x0F:
+		this->spawnMob(in);
+		return;
+	case 0x10: { // Spawn Painting
+		int32_t eid = in->readVarInt();
+		std::string title = in->readString(32);
+		int32_t x = 0, y = 0, z = 0;
+		in->readPosition(&x, &y, &z);
+		// EnumFacing's horizontal index runs S-W-N-E, which is exactly the
+		// order HangingEntity::setDir() expects, so the byte passes straight
+		// through.  MCPE inherited Java's motive names too, so the title is a
+		// direct lookup - anything m8 does not have (1.8 added "Wither") falls
+		// back to Kebab inside getMotiveByName rather than to a null motive.
+		int32_t facing = in->readByte() & 3;
+		if(in->failed() || !this->level || !JavaY::inRange(y)) return;
+		Painting* art = new Painting(this->level, x, JavaY::toM8(y), z, facing, title);
+		this->attachEntity(eid, art);
+		this->knownEntities[eid] = 1;
+		return;
+	}
+	case 0x11: { // Spawn Experience Orb - m8 has no orbs, but eat the bytes
+		in->readVarInt();
+		in->readInt();
+		in->readInt();
+		in->readInt();
+		in->readShort();
+		return;
+	}
+	case 0x12: { // Entity Velocity
+		int32_t eid = in->readVarInt();
+		int32_t vx = in->readShort();
+		int32_t vy = in->readShort();
+		int32_t vz = in->readShort();
+		if(in->failed()) return;
+		Entity* e = this->findEntity(eid);
+		if(e) {
+			e->lerpMotion((float)vx / 8000.0f, (float)vy / 8000.0f, (float)vz / 8000.0f);
+		}
+		return;
+	}
+	case 0x13: { // Destroy Entities
+		int32_t count = in->readVarInt();
+		if(in->failed() || count < 0) return;
+		for(int32_t i = 0; i < count; ++i) {
+			int32_t eid = in->readVarInt();
+			if(in->failed()) return;
+			this->destroyEntity(eid);
+		}
+		return;
+	}
+	case 0x14: // Entity (no movement, just a heartbeat)
+		in->readVarInt();
+		return;
+	case 0x15: { // Entity Relative Move
+		int32_t eid = in->readVarInt();
+		int32_t dx = in->readSByte();
+		int32_t dy = in->readSByte();
+		int32_t dz = in->readSByte();
+		in->readBool(); // on ground
+		if(in->failed()) return;
+		this->moveEntity(eid, (double)dx / 32.0, (double)dy / 32.0, (double)dz / 32.0, 0, 0.0f, 0.0f, 0);
+		return;
+	}
+	case 0x16: { // Entity Look
+		int32_t eid = in->readVarInt();
+		float yaw = (float)in->readSByte() * 360.0f / 256.0f;
+		float pitch = (float)in->readSByte() * 360.0f / 256.0f;
+		in->readBool();
+		if(in->failed()) return;
+		this->moveEntity(eid, 0.0, 0.0, 0.0, 1, yaw, pitch, 0);
+		return;
+	}
+	case 0x17: { // Entity Look And Relative Move
+		int32_t eid = in->readVarInt();
+		int32_t dx = in->readSByte();
+		int32_t dy = in->readSByte();
+		int32_t dz = in->readSByte();
+		float yaw = (float)in->readSByte() * 360.0f / 256.0f;
+		float pitch = (float)in->readSByte() * 360.0f / 256.0f;
+		in->readBool();
+		if(in->failed()) return;
+		this->moveEntity(eid, (double)dx / 32.0, (double)dy / 32.0, (double)dz / 32.0, 1, yaw, pitch, 0);
+		return;
+	}
+	case 0x18: { // Entity Teleport
+		int32_t eid = in->readVarInt();
+		double x = (double)in->readInt() / 32.0;
+		double y = (double)in->readInt() / 32.0;
+		double z = (double)in->readInt() / 32.0;
+		float yaw = (float)in->readSByte() * 360.0f / 256.0f;
+		float pitch = (float)in->readSByte() * 360.0f / 256.0f;
+		in->readBool();
+		if(in->failed()) return;
+		this->moveEntity(eid, x, y, z, 1, yaw, pitch, 1);
+		return;
+	}
+	case 0x19: { // Entity Head Look
+		int32_t eid = in->readVarInt();
+		float headYaw = (float)in->readSByte() * 360.0f / 256.0f;
+		if(in->failed()) return;
+		Entity* e = this->findEntity(eid);
+		if(e && e->isMob()) {
+			((Mob*)e)->setYHeadRot(headYaw);
+		}
+		return;
+	}
+	case 0x1A: { // Entity Status
+		int32_t eid = in->readInt();
+		int32_t status = in->readByte();
+		if(in->failed()) return;
+		Entity* e = this->findEntity(eid);
+		if(!e) return;
+		if(status == 2) {
+			// hurt
+			this->level->broadcastEntityEvent(e, 2);
+		} else if(status == 3) {
+			this->level->broadcastEntityEvent(e, 3);
+		}
+		return;
+	}
+	case 0x1C: { // Entity Metadata
+		int32_t eid = in->readVarInt();
+		if(in->failed()) return;
+		int32_t itemId = 0, count = 0, damage = 0;
+		if(!this->readMetadata(in, &itemId, &count, &damage)) return;
+		if(itemId > 0 && this->pendingItems.count(eid)) {
+			Entity* e = this->findEntity(eid);
+			if(e && e->isItemEntity()) {
+				((ItemEntity*)e)->itemInstance =
+					ItemInstance(JavaIdMap::javaItemToM8(itemId), count > 0 ? count : 1, damage);
+				this->pendingItems.erase(eid);
+			}
+		}
+		return;
+	}
+	case 0x1D: // Entity Effect
+		in->readVarInt(); in->readByte(); in->readByte(); in->readVarInt(); in->readBool();
+		return;
+	case 0x1E: // Remove Entity Effect
+		in->readVarInt(); in->readByte();
+		return;
+	case 0x21: { // Chunk Data
+		int32_t cx = in->readInt();
+		int32_t cz = in->readInt();
+		bool_t groundUp = in->readBool();
+		int32_t mask = in->readUShort();
+		int32_t len = in->readVarInt();
+		if(in->failed() || len < 0 || (size_t)len > in->remaining()) return;
+		const uint8_t* payload = in->data() + in->readPos;
+		if(mask == 0 && groundUp) {
+			// 1.8's chunk unload signal.
+			if(this->chunkSource) this->chunkSource->drop(cx, cz);
+		} else {
+			this->applyChunk(cx, cz, mask, groundUp, this->hasSkyLight, payload, (size_t)len);
+		}
+		in->skip((size_t)len);
+		return;
+	}
+	case 0x22: { // Multi Block Change
+		int32_t cx = in->readInt();
+		int32_t cz = in->readInt();
+		int32_t count = in->readVarInt();
+		if(in->failed() || count < 0) return;
+		for(int32_t i = 0; i < count; ++i) {
+			int32_t packed = in->readUShort();
+			int32_t state = in->readVarInt();
+			if(in->failed()) return;
+			int32_t lx = (packed >> 12) & 0xF;
+			int32_t lz = (packed >> 8) & 0xF;
+			int32_t jy = packed & 0xFF;
+			this->setJavaBlock((cx << 4) + lx, jy, (cz << 4) + lz, state);
+		}
+		return;
+	}
+	case 0x23: { // Block Change
+		int32_t x = 0, y = 0, z = 0;
+		in->readPosition(&x, &y, &z);
+		int32_t state = in->readVarInt();
+		if(in->failed()) return;
+		javaDebug("in block change %d %d %d -> java %d:%d", x, y, z, state >> 4, state & 0xF);
+		this->setJavaBlock(x, y, z, state);
+		return;
+	}
+	case 0x24: { // Block Action
+		int32_t bax = 0, bay = 0, baz = 0;
+		in->readPosition(&bax, &bay, &baz);
+		in->readByte(); in->readByte(); in->readVarInt();
+		return;
+	}
+	case 0x25: { // Block Break Animation
+		in->readVarInt();
+		int32_t x = 0, y = 0, z = 0;
+		in->readPosition(&x, &y, &z);
+		in->readByte();
+		return;
+	}
+	case 0x26: { // Map Chunk Bulk
+		bool_t sky = in->readBool();
+		int32_t count = in->readVarInt();
+		if(in->failed() || count < 0 || count > 4096) return;
+		std::vector<int32_t> cxs((size_t)count), czs((size_t)count), masks((size_t)count);
+		for(int32_t i = 0; i < count; ++i) {
+			cxs[(size_t)i] = in->readInt();
+			czs[(size_t)i] = in->readInt();
+			masks[(size_t)i] = in->readUShort();
+			if(in->failed()) return;
+		}
+		this->hasSkyLight = sky;
+		for(int32_t i = 0; i < count; ++i) {
+			size_t need = JavaChunkData::payloadSize(masks[(size_t)i], sky, 1);
+			if(need > in->remaining()) return;
+			const uint8_t* payload = in->data() + in->readPos;
+			this->applyChunk(cxs[(size_t)i], czs[(size_t)i], masks[(size_t)i], 1, sky, payload, need);
+			in->skip(need);
+		}
+		return;
+	}
+	case 0x27: { // Explosion
+		float x = in->readFloat();
+		float y = in->readFloat();
+		float z = in->readFloat();
+		float radius = in->readFloat();
+		int32_t count = in->readInt();
+		if(in->failed() || count < 0) return;
+		for(int32_t i = 0; i < count; ++i) {
+			int32_t ox = in->readSByte();
+			int32_t oy = in->readSByte();
+			int32_t oz = in->readSByte();
+			if(in->failed()) return;
+			// The server has already removed these; mirror it locally.
+			int32_t bx = (int32_t)x + ox;
+			int32_t by = JavaY::toM8((int32_t)y + oy);
+			int32_t bz = (int32_t)z + oz;
+			if(LevelHeight::inRange(by)) {
+				this->level->setTileAndData(bx, by, bz, 0, 0, 3);
+			}
+		}
+		in->readFloat(); in->readFloat(); in->readFloat(); // player motion
+		this->level->levelEvent(2001, (int32_t)x, (int32_t)JavaY::toM8d(y), (int32_t)z, (int32_t)radius);
+		return;
+	}
+	case 0x28: { // Effect
+		int32_t effectId = in->readInt();
+		int32_t x = 0, y = 0, z = 0;
+		in->readPosition(&x, &y, &z);
+		in->readInt();
+		in->readBool();
+		if(in->failed()) return;
+		(void)effectId;
+		return;
+	}
+	case 0x29: { // Sound Effect
+		std::string name = in->readString();
+		int32_t x = in->readInt();
+		int32_t y = in->readInt();
+		int32_t z = in->readInt();
+		float volume = in->readFloat();
+		int32_t pitch = in->readByte();
+		if(in->failed()) return;
+		this->level->playSound((float)x / 8.0f, (float)JavaY::toM8d((double)y / 8.0), (float)z / 8.0f,
+		                       name, volume, (float)pitch / 63.0f);
+		return;
+	}
+	case 0x2B: { // Change Game State
+		int32_t reason = in->readByte();
+		float value = in->readFloat();
+		if(in->failed()) return;
+		if(reason == 3) {
+			this->gamemode = (int32_t)value;
+			javaLog("server changed gamemode to %d", (int)this->gamemode);
+			this->applyGameMode();
+		} else if(reason == 4) {
+			/*
+			 * "Enter credits", sent by EntityPlayerMP::travelToDimension when you
+			 * step into the exit portal after the dragon is dead.  The server has
+			 * already taken the player entity out of the world at this point and
+			 * is waiting for a Client Status before it will put one back, so
+			 * ignoring this leaves us floating in a level nobody is ticking.
+			 *
+			 * Java answers with GuiWinGame, and closing that screen sends exactly
+			 * the packet below.  m8 has no credits screen and therefore nothing to
+			 * press to leave one, so skip straight to the part that matters.
+			 */
+			javaLog("server sent enter-credits, auto-skipping");
+			JavaByteBuf status;
+			this->beginPacket(&status, 0x16); // Client Status
+			status.writeVarInt(0);            // perform respawn
+			this->send(status);
+			if(this->minecraft) {
+				this->minecraft->gui.addMessage("", "You beat the dragon. Credits skipped.", 200);
+			}
+		}
+		return;
+	}
+	case 0x2F: { // Set Slot
+		int32_t window = in->readSByte();
+		int32_t slot = in->readShort();
+		std::vector<uint8_t> raw;
+		int32_t itemId = 0, count = 0, damage = 0;
+		if(!this->readSlot(in, &itemId, &count, &damage, &raw)) return;
+		if(window != 0) return;
+		javaDebug("in set slot %d -> java item %d x%d dmg %d", slot, itemId, count, damage);
+		this->applyInventorySlot(slot, itemId, count, damage, raw);
+		return;
+	}
+	case 0x30: { // Window Items
+		int32_t window = in->readByte();
+		int32_t count = in->readShort();
+		if(in->failed() || count < 0) return;
+		for(int32_t i = 0; i < count; ++i) {
+			std::vector<uint8_t> raw;
+			int32_t itemId = 0, cnt = 0, damage = 0;
+			if(!this->readSlot(in, &itemId, &cnt, &damage, &raw)) return;
+			if(window == 0) this->applyInventorySlot(i, itemId, cnt, damage, raw);
+		}
+		return;
+	}
+	case 0x33: { // Update Sign
+		int32_t x = 0, y = 0, z = 0;
+		in->readPosition(&x, &y, &z);
+		std::string lines[4];
+		for(int32_t i = 0; i < 4; ++i) {
+			lines[i] = javaChatToText(in->readString(384));
+		}
+		if(in->failed()) return;
+		this->applySignText(x, y, z, lines);
+		return;
+	}
+	case 0x35: { // Update Block Entity
+		int32_t x = 0, y = 0, z = 0;
+		int32_t action = 0;
+		in->readPosition(&x, &y, &z);
+		action = in->readByte();
+		/*
+		 * Action 9 is a sign, and a few server implementations answer a chunk
+		 * load with this instead of Update Sign.  The payload is a TileEntitySign
+		 * tag whose Text1..Text4 are chat JSON, exactly what 0x33 carries.
+		 */
+		if(action == 9) {
+			std::string lines[4];
+			if(this->readSignNbt(in, lines)) {
+				for(int32_t i = 0; i < 4; ++i) {
+					lines[i] = javaChatToText(lines[i]);
+				}
+				this->applySignText(x, y, z, lines);
+			}
+			return;
+		}
+		this->skipNbt(in);
+		return;
+	}
+	case 0x38: { // Player List Item
+		int32_t action = in->readVarInt();
+		int32_t count = in->readVarInt();
+		if(in->failed() || count < 0) return;
+		for(int32_t i = 0; i < count; ++i) {
+			uint64_t hi = 0, lo = 0;
+			in->readUUID(&hi, &lo);
+			if(in->failed()) return;
+			if(action == 0) { // add player
+				std::string name = in->readString(16);
+				int32_t props = in->readVarInt();
+				if(in->failed() || props < 0) return;
+				for(int32_t p = 0; p < props; ++p) {
+					in->readString();
+					in->readString();
+					if(in->readBool()) in->readString();
+					if(in->failed()) return;
+				}
+				in->readVarInt(); // gamemode
+				in->readVarInt(); // ping
+				if(in->readBool()) in->readString(); // display name
+				this->playerNames[lo] = name;
+			} else if(action == 1) {
+				in->readVarInt();
+			} else if(action == 2) {
+				in->readVarInt();
+			} else if(action == 3) {
+				if(in->readBool()) in->readString();
+			} else if(action == 4) {
+				this->playerNames.erase(lo);
+			}
+			if(in->failed()) return;
+		}
+		return;
+	}
+	case 0x39: { // Player Abilities
+		int32_t flags = in->readByte();
+		in->readFloat();
+		in->readFloat();
+		if(in->failed()) return;
+		this->abilityFlags = flags;
+		this->hasAbilityFlags = 1;
+		javaDebug("in abilities flags=0x%02X (invuln=%d fly=%d mayfly=%d instabuild=%d)",
+		          flags, (int)((flags & 1) != 0), (int)((flags & 2) != 0),
+		          (int)((flags & 4) != 0), (int)((flags & 8) != 0));
+		this->applyAbilities();
+		return;
+	}
+	default:
+		// Anything else is either cosmetic (scoreboards, particles, maps) or
+		// something m8 has no equivalent for.  Dropping it is safe because the
+		// frame boundary came from the length prefix, not from parsing.  Say so
+		// under M8_JAVA_DEBUG though: when a server is waiting on an answer we
+		// do not know how to give, this line is the only clue.
+		javaDebug("in unhandled packet 0x%02X (%d bytes)", (int)id,
+		          (int)(in->bytes.size() - in->readPos));
+		return;
+	}
+}
+
+// --------------------------------------------------------------- world ------
+
+/*
+ * Java's four game modes against m8's two.
+ *
+ * Survival (0) and adventure (2) both mean "no flying, no free blocks"; the
+ * difference between them is what you are allowed to break, which the server
+ * decides anyway.  Spectator (3) has no equivalent at all, and creative is the
+ * closest thing on offer.  The old test - anything but survival is creative -
+ * handed a fly button to every adventure lobby, and a lobby is exactly where a
+ * server is most likely to be watching how the client falls.
+ */
+bool_t JavaSession::isCreativeGamemode() const {
+	return this->gamemode == 1 || this->gamemode == 3;
+}
+
+void JavaSession::applyGameMode() {
+	bool_t creative = this->isCreativeGamemode();
+	if(this->minecraft) {
+		this->minecraft->setIsCreativeMode(creative);
+	}
+	if(!this->player) {
+		return;
+	}
+	/*
+	 * setIsCreativeMode runs GameMode::initAbilities for us, but only when a
+	 * player already exists, and CreativeMode::initAbilities deliberately leaves
+	 * abilities.flying alone.  Spelling all four out here means a gamemode
+	 * change can never leave a stale ability behind, whichever direction it
+	 * goes in.
+	 */
+	Abilities& ab = this->player->abilities;
+	ab.mayfly = creative;
+	ab.instabuild = creative;
+	ab.invulnerable = creative;
+	ab.flying = this->gamemode == 3;
+	// Whatever the server said last still wins over the defaults.
+	this->applyAbilities();
+}
+
+void JavaSession::applyAbilities() {
+	if(!this->player || !this->hasAbilityFlags) {
+		return;
+	}
+	Abilities& ab = this->player->abilities;
+	ab.invulnerable = (this->abilityFlags & 0x01) != 0;
+	ab.flying = (this->abilityFlags & 0x02) != 0;
+	ab.mayfly = (this->abilityFlags & 0x04) != 0;
+	ab.instabuild = (this->abilityFlags & 0x08) != 0;
+}
+
+void JavaSession::createLevel() {
+	if(this->levelRequested || !this->minecraft) {
+		return;
+	}
+	this->levelRequested = 1;
+
+	LevelStorageSource* source = this->minecraft->getLevelSource();
+	source->deleteLevel(LevelStorageSource::TempLevelId);
+
+	// generatorType/generatorVersion 1 == infinite, which is what a Java world
+	// looks like from m8's side.
+	LevelSettings settings;
+	settings.seed = 0;
+	settings.gameType = this->isCreativeGamemode();
+	settings.generatorType = 1;
+
+	/*
+	 * The one place in the game that asks for a tall world.  This has to happen
+	 * before the level exists, because every chunk it ever creates is allocated
+	 * and indexed for the height that was set here, and it is safe here because
+	 * Minecraft::leaveGame has already torn down whatever level came before.  The
+	 * level is a temp one that is never written back, so no save is at risk.
+	 */
+	LevelHeight::set(JAVA_HEIGHT);
+
+	MultiPlayerLevel* lvl = new MultiPlayerLevel(
+		source->selectLevel(LevelStorageSource::TempLevelId, 1), "java", settings, 1, 1, 0);
+
+	/*
+	 * Level::_init runs from the base constructor, so the virtual call it makes
+	 * lands on Level::createChunkSource and hands us a real terrain generating
+	 * ChunkCache regardless of what MultiPlayerLevel overrides.  Swap it for the
+	 * server authoritative source now, before Minecraft::setLevel starts the
+	 * prepareLevel worker: that worker sweeps the origin with getTile, and with
+	 * the cache still installed it would generate a whole local world we would
+	 * then immediately overwrite.
+	 */
+	JavaChunkSource* jcs = new JavaChunkSource(lvl);
+	ChunkSource* old = lvl->chunkSource;
+	lvl->chunkSource = jcs;
+	if(old) {
+		delete old;
+	}
+	this->chunkSource = jcs;
+
+	/*
+	 * field_B64 is "this level had no saved data", and prepareLevel reads it as
+	 * "generate a spawn point and flood the light engine".  Both are the local
+	 * generator's job, and setInitialSpawn spins until Dimension::isValidSpawn
+	 * likes a column - which it never will on a world the server has not sent
+	 * yet.  The server tells us where we spawn, so clear it.
+	 */
+	lvl->field_B64 = 0;
+
+	/*
+	 * LevelData's constructor freezes the sky at tick 5000 for any gameType but
+	 * survival - that is how 0.8.1 spells "creative worlds are always morning" -
+	 * and Level::getTimeOfDay honours stopTime over the clock, so no Time Update
+	 * could ever move the sun.  The server owns the clock on a Java world; the
+	 * 0x03 handler puts stopTime back if the server says the cycle is off.
+	 */
+	lvl->levelData.setStopTime(-1);
+	lvl->adventureSettings.daylightCycle = 1;
+
+	LocalPlayer* p = new LocalPlayer(this->minecraft, lvl, this->minecraft->user,
+	                                 lvl->dimensionPtr->id, this->isCreativeGamemode());
+	p->entityId = this->serverEid;
+	p->inventoryMenu.setListener(p);
+	p->username = this->username;
+	p->moveTo((float)this->posX, (float)JavaY::toM8d(this->posY), (float)this->posZ,
+	          this->rotYaw, this->rotPitch);
+
+	this->level = lvl;
+	this->sentX = this->posX;
+	this->sentY = this->posY;
+	this->sentZ = this->posZ;
+	this->sentYaw = this->rotYaw;
+	this->sentPitch = this->rotPitch;
+	this->everSentPosition = 1;
+
+	this->minecraft->setIsCreativeMode(this->isCreativeGamemode());
+	this->minecraft->setLevel(lvl, "JavaSession -> setLevel", p);
+
+	// Player::resetPos, which setLevel runs, zeroes the pitch.
+	p->pitch = this->rotPitch;
+	p->prevPitch = this->rotPitch;
+	javaLog("level built, spawning at %.2f %.2f %.2f (java y %.2f)", this->posX,
+	        JavaY::toM8d(this->posY), this->posZ, this->posY);
+}
+
+/*
+ * Undo a dimension, without leaving anything behind that used to live in it.
+ *
+ * Respawn (0x07) means "forget the world": every column and every entity the
+ * server described is gone, and the ids it used for them are free again the
+ * moment it says so.  Clearing knownEntities on its own is not enough - the
+ * Entity objects would stay in the level ticking against terrain that no longer
+ * exists, and the first mob the new dimension spawns would very likely arrive
+ * on a recycled id whose old owner is still sitting in Level::eid2entity.  That
+ * is exactly the collision retireEntity exists to prevent, so every entity goes
+ * out through destroyEntity, which parks it on a private id first.
+ *
+ * destroyEntity erases from knownEntities as it goes, so the walk is over a
+ * copy of the keys rather than the map itself.
+ */
+void JavaSession::resetForRespawn() {
+	if(this->level) {
+		std::vector<int32_t> stale;
+		stale.reserve(this->knownEntities.size());
+		for(std::map<int32_t, bool_t>::const_iterator it = this->knownEntities.begin();
+		    it != this->knownEntities.end(); ++it) {
+			stale.push_back(it->first);
+		}
+		for(size_t i = 0; i < stale.size(); ++i) {
+			this->destroyEntity(stale[i]);
+		}
+	}
+	this->knownEntities.clear();
+	this->pendingItems.clear();
+
+	// The columns are the server's to resend; dropping them also drops the
+	// render chunks, so nothing from the old dimension is left on screen.
+	if(this->chunkSource) {
+		this->chunkSource->dropAll();
+	}
+
+	/*
+	 * Two seconds of pinning at 20 frames a second.  It is a ceiling, not a
+	 * wait: holdPlayerForTerrain lets go as soon as the column under the player
+	 * has something in it, which on a local server is the very next frame.
+	 */
+	this->respawnHold = 40;
+	javaLog("respawn: dimension %d, holding player until terrain arrives", (int)this->dimension);
+}
+
+/*
+ * Keep the player where the server put them until there is a floor to stand on.
+ *
+ * pump() runs from RakNetInstance::runEvents, which Minecraft::update calls
+ * before Level::tick, so this is the last word on the player's position each
+ * frame and gravity gets at most one tick of it before being zeroed again.
+ * Pinning rather than freezing matters because the player is still a live
+ * entity: motion and fall distance both have to be cleared, or the fall damage
+ * banked while the world was blank would land the moment the hold ends.
+ */
+void JavaSession::holdPlayerForTerrain() {
+	if(this->respawnHold <= 0) {
+		return;
+	}
+	LocalPlayer* p = this->player;
+	if(!p) {
+		this->respawnHold = 0;
+		return;
+	}
+
+	--this->respawnHold;
+
+	// Real terrain under our feet means the wait is over.  Mth::floor takes a
+	// float and these are doubles, so the floor is done here.
+	bool_t haveTerrain = 0;
+	if(this->chunkSource) {
+		LevelChunk* c = this->chunkSource->find(
+			(int32_t)floor(this->posX) >> 4, (int32_t)floor(this->posZ) >> 4);
+		if(c && c->topBlockY > 1) {
+			this->respawnHold = 0;
+			haveTerrain = 1;
+		}
+	}
+
+	p->moveTo((float)this->posX, (float)JavaY::toM8d(this->posY), (float)this->posZ,
+	          p->yaw, p->pitch);
+	p->motionX = 0.0;
+	p->motionY = 0.0;
+	p->motionZ = 0.0;
+	p->fallDistance = 0.0f;
+	/*
+	 * Standing on nothing is not standing.  What the hold is for is keeping the
+	 * fall damage banked over a blank world from ever landing, and zeroing the
+	 * motion and the fall distance is what does that; claiming onGround as well
+	 * only changes what playerTick reports, and a client that says it is on the
+	 * ground while hanging in mid air over a void is a bot as far as any
+	 * verification lobby is concerned.
+	 */
+	p->onGround = haveTerrain;
+}
+
+void JavaSession::applyChunk(int32_t cx, int32_t cz, int32_t mask, bool_t groundUp,
+                             bool_t skyLight, const uint8_t* data, size_t len) {
+	if(!this->level || !this->chunkSource) {
+		return;
+	}
+	LevelChunk* chunk = this->chunkSource->obtain(cx, cz);
+	if(!chunk) {
+		return;
+	}
+	if(!JavaChunkData::apply(this->level, chunk, data, len, mask, groundUp, skyLight)) {
+		return;
+	}
+	// The column came from the server, so it is not ours to write back, and the
+	// tile updates the bulk write skipped must reach the renderer in one go.
+	chunk->unsaved = 0;
+	chunk->clearUpdateMap();
+	int32_t x0 = cx << 4;
+	int32_t z0 = cz << 4;
+	this->level->setTilesDirty(x0, 0, z0, x0 + 15, LevelHeight::maxY(), z0 + 15);
+}
+
+void JavaSession::setJavaBlock(int32_t jx, int32_t jy, int32_t jz, int32_t state) {
+	if(!this->level) {
+		return;
+	}
+	int32_t my = JavaY::toM8(jy);
+	if(!LevelHeight::inRange(my)) {
+		return;
+	}
+	int32_t id = 0;
+	int32_t meta = 0;
+	if(state > 0) {
+		JavaIdMap::javaBlockToM8(state >> 4, state & 0xF, &id, &meta);
+	}
+	this->level->setTileAndData(jx, my, jz, id, meta, 3);
+}
+
+/*
+ * A tile entity that has been marked removed is normally freed by Level::tick,
+ * which sweeps `tileEntities` and erases the matching chunk entry.  A client
+ * level never runs Level::tick - MultiPlayerLevel::tick only advances time and
+ * the sky - so a corpse sits in the chunk map forever, and because
+ * LevelChunk::getTileEntity answers 0 for a removed entry without replacing it,
+ * the position can never hold a live sign again.  Re-placing a sign is exactly
+ * the case that leaves one behind: LevelChunk::setTileAndData calls onRemove
+ * whenever the metadata changes, even when the block id does not.
+ */
+static void javaBurySignCorpse(Level* level, int32_t x, int32_t y, int32_t z) {
+	if(!level) {
+		return;
+	}
+	for(size_t i = 0; i < level->tileEntities.size();) {
+		TileEntity* te = level->tileEntities[i];
+		if(te && te->isRemoved() && te->posX == x && te->posY == y && te->posZ == z) {
+			level->tileEntities.erase(level->tileEntities.begin() + i);
+			for(size_t j = 0; j < level->field_50.size();) {
+				if(level->field_50[j] == te) {
+					level->field_50.erase(level->field_50.begin() + j);
+				} else {
+					++j;
+				}
+			}
+			LevelChunk* chunk = level->getChunk(x >> 4, z >> 4);
+			if(chunk) {
+				chunk->removeTileEntity(x & 0xF, y, z & 0xF);
+			}
+			delete te;
+		} else {
+			++i;
+		}
+	}
+}
+
+void JavaSession::applySignText(int32_t jx, int32_t jy, int32_t jz, const std::string* lines) {
+	if(!this->level || !JavaY::inRange(jy)) {
+		return;
+	}
+	int32_t my = JavaY::toM8(jy);
+	if(!LevelHeight::inRange(my)) {
+		return;
+	}
+
+	int32_t id = this->level->getTile(jx, my, jz);
+	int32_t standing = Tile::sign ? Tile::sign->blockID : 63;
+	int32_t wall = Tile::wallSign ? Tile::wallSign->blockID : 68;
+	if(id != standing && id != wall) {
+		// The block is not here (yet).  Nothing to hang the text on, and
+		// inventing a tile entity for whatever *is* here would only leak.
+		return;
+	}
+
+	javaBurySignCorpse(this->level, jx, my, jz);
+
+	/*
+	 * getTileEntity does the creation for us: LevelChunk::getTileEntity sees an
+	 * entity tile with no entry, asks the tile for a fresh one and registers it
+	 * through Level::setTileEntity, which is what puts it in the list
+	 * LevelRenderer walks.  That last part is the whole point - a sign that is
+	 * not in level->tileEntities is drawn by nobody.
+	 */
+	TileEntity* te = this->level->getTileEntity(jx, my, jz);
+	if(!te || te->type != 4) {
+		return;
+	}
+	SignTileEntity* sign = (SignTileEntity*)te;
+
+	bool_t incomingEmpty = 1;
+	bool_t localHasText = 0;
+	for(int32_t i = 0; i < 4; ++i) {
+		if(!lines[i].empty()) incomingEmpty = 0;
+		if(!sign->textLines[i].empty()) localHasText = 1;
+	}
+	/*
+	 * Placing a sign makes the server answer twice: Sign Editor Open, which is
+	 * what makes the sign ours to type into, and an Update Sign carrying four
+	 * empty lines because the board really is blank at that moment.  m8 has the
+	 * edit screen up by then and the player may already be typing, so an empty
+	 * update over text we hold locally is that echo, never an edit - 1.8 has no
+	 * way to blank a sign that already has text.
+	 */
+	if(incomingEmpty && localHasText) {
+		return;
+	}
+
+	for(int32_t i = 0; i < 4; ++i) {
+		std::string line = lines[i];
+		if(Util::utf8len(line) > 15) {
+			line = Util::utf8substring(line, 0, 15);
+		}
+		sign->textLines[i] = line;
+	}
+	// Same as SignTileEntity::load: text that came from outside is not ours to
+	// retype, which matches 1.8 - only the player who placed a sign may edit it.
+	sign->editable = 0;
+	this->level->setTileDirty(jx, my, jz);
+}
+
+/*
+ * Java window 0 slot numbering: 0 crafting result, 1-4 crafting grid, 5-8 armor
+ * (helmet first), 9-35 the backpack, 36-44 the hotbar.  m8 keeps its 36 storage
+ * slots at container indices 9-44 and points the nine linkedSlots at whichever
+ * of those the hotbar shows, so put the hotbar first (9-17) and link straight to
+ * it, then the backpack behind it (18-44).
+ */
+void JavaSession::applyInventorySlot(int32_t javaSlot, int32_t itemId, int32_t count,
+                                     int32_t damage, const std::vector<uint8_t>& raw) {
+	if(!this->player) {
+		return;
+	}
+	if(javaSlot >= 5 && javaSlot <= 8) {
+		int32_t piece = javaSlot - 5;
+		if(itemId > 0) {
+			ItemInstance ii(JavaIdMap::javaItemToM8(itemId), count > 0 ? count : 1, damage);
+			this->player->setArmor(piece, &ii);
+		} else {
+			this->player->setArmor(piece, 0);
+		}
+		return;
+	}
+
+	int32_t index;
+	if(javaSlot >= 36 && javaSlot <= 44) {
+		index = 9 + (javaSlot - 36);
+		this->hotbar[javaSlot - 36] = raw;
+	} else if(javaSlot >= 9 && javaSlot <= 35) {
+		index = 18 + (javaSlot - 9);
+	} else {
+		return; // crafting grid and result have no m8 equivalent
+	}
+
+	Inventory* inv = this->player->inventory;
+	if(!inv) {
+		return;
+	}
+	if((int32_t)inv->items.size() < 45) {
+		inv->items.resize(45, 0);
+	}
+	if(itemId > 0) {
+		int32_t m8Id = JavaIdMap::javaItemToM8(itemId);
+		if(m8Id > 0) {
+			ItemInstance ii(m8Id, count > 0 ? count : 1, damage);
+			inv->setItem(index, &ii);
+		} else {
+			inv->setItem(index, 0);
+		}
+	} else if(this->gamemode != 1) {
+		inv->setItem(index, 0);
+	}
+	/*
+	 * In creative the client is the author of its own inventory: m8 starts with
+	 * a filled hotbar and the palette screen writes straight into it, while a
+	 * Java server's creative window is empty until a Creative Inventory Action
+	 * tells it otherwise.  Letting its empty slots through here would wipe the
+	 * hotbar the moment Window Items arrives and leave nothing to place, eat or
+	 * hold - so an empty creative slot is ignored and pushCreativeInventory()
+	 * brings the server up to date instead.
+	 */
+	if(javaSlot >= 36 && javaSlot <= 44) {
+		inv->linkSlot(javaSlot - 36, index);
+	}
+}
+
+// ------------------------------------------------------------ entities ------
+
+Entity* JavaSession::findEntity(int32_t javaEid) {
+	if(!this->level) {
+		return 0;
+	}
+	if(this->player && javaEid == this->player->entityId) {
+		return 0; // the server never means "move yourself" with these
+	}
+	return this->level->getEntity(javaEid);
+}
+
+/*
+ * Take an entity out of play without ever handing its id to the level twice.
+ *
+ * Level::tickEntities sweeps a dead entity with
+ *
+ *     eid2entity.erase(eid2entity.find(entity->entityId))
+ *
+ * one tick after it dies and deletes it the tick after that, and
+ * std::map::erase(end()) is undefined - so the corpse's key has to stay in the
+ * table until the sweep, which means it cannot be the key the replacement
+ * entity needs.  Re-keying the corpse onto a private negative id satisfies
+ * both: the sweep still finds something to erase, and the real id is free
+ * immediately.
+ */
+void JavaSession::retireEntity(Entity* old) {
+	MultiPlayerLevel* lvl = this->level;
+	if(!lvl || !old || old == (Entity*)this->player) {
+		return;
+	}
+
+	int32_t oldId = old->entityId;
+	std::map<int32_t, Entity*>::iterator it = lvl->eid2entity.find(oldId);
+	if(it != lvl->eid2entity.end() && it->second == old) {
+		lvl->eid2entity.erase(it);
+	}
+	int32_t parkId = this->nextParkedEid;
+	// Wrapping would collide with a real id; parking stops mattering long
+	// before two billion entities have come and gone, so just stop moving.
+	if(this->nextParkedEid > -2000000000) {
+		--this->nextParkedEid;
+	}
+	old->entityId = parkId;
+	lvl->eid2entity[parkId] = old;
+
+	// A player corpse is only swept when this is set - see Level::tickEntities
+	// and ClientSideNetworkHandler's own remove-player path.
+	if(old->isPlayer()) {
+		old->field_108 = 1;
+	}
+	lvl->removeEntity(old);
+}
+
+/*
+ * Register a freshly spawned entity under the id the server gave it.
+ *
+ * This replaces MultiPlayerLevel::putEntity, which dereferences whatever
+ * pointer its own id map happens to hold - fine against an MCPE server that
+ * allocates ids monotonically, a use after free against a Java server that
+ * recycles them.
+ */
+void JavaSession::attachEntity(int32_t javaEid, Entity* e) {
+	MultiPlayerLevel* lvl = this->level;
+	if(!lvl || !e) {
+		return;
+	}
+
+	Entity* previous = 0;
+	std::map<int32_t, Entity*>::iterator mapped = lvl->field_BAC.find(javaEid);
+	if(mapped != lvl->field_BAC.end()) {
+		Entity* old = mapped->second;
+		lvl->field_BAC.erase(mapped);
+		lvl->field_BC4.erase(old);
+		lvl->field_BDC.erase(old);
+		// The level's id table is the only thing that says whether that
+		// pointer is still ours to touch: it loses the entry one tick before
+		// the entity is deleted, so a mismatch means "already gone".
+		if(lvl->getEntity(javaEid) == old) {
+			previous = old;
+		}
+	} else {
+		previous = lvl->getEntity(javaEid);
+	}
+	if(previous && previous != (Entity*)this->player) {
+		this->retireEntity(previous);
+	}
+
+	e->entityId = javaEid;
+	lvl->addEntity(e);
+	// Level::addEntity inserts, and std::map::insert leaves an existing value
+	// alone, so make the id point at the entity that actually owns it now.
+	lvl->eid2entity[javaEid] = e;
+	lvl->field_BAC[javaEid] = e;
+	lvl->field_BC4.insert(e);
+}
+
+void JavaSession::spawnMob(JavaByteBuf* in) {
+	int32_t eid = in->readVarInt();
+	int32_t type = in->readByte();
+	double x = (double)in->readInt() / 32.0;
+	double y = (double)in->readInt() / 32.0;
+	double z = (double)in->readInt() / 32.0;
+	float yaw = (float)in->readSByte() * 360.0f / 256.0f;
+	float pitch = (float)in->readSByte() * 360.0f / 256.0f;
+	float headYaw = (float)in->readSByte() * 360.0f / 256.0f;
+	int32_t vx = in->readShort();
+	int32_t vy = in->readShort();
+	int32_t vz = in->readShort();
+	if(in->failed()) {
+		return;
+	}
+	this->readMetadata(in, 0, 0, 0);
+
+	int32_t m8Type = JavaIdMap::javaMobToM8(type);
+	if(!m8Type || !this->level) {
+		return;
+	}
+	Mob* mob = MobFactory::CreateMob(m8Type, this->level);
+	if(!mob) {
+		return;
+	}
+	// Mob::moveTo takes feet level Y, which is what Java sends.
+	mob->moveTo((float)x, (float)JavaY::toM8d(y), (float)z, yaw, pitch);
+	mob->headYaw = headYaw;
+	mob->prevHeadYaw = headYaw;
+	mob->lerpMotion((float)vx / 8000.0f, (float)vy / 8000.0f, (float)vz / 8000.0f);
+	this->attachEntity(eid, mob);
+	this->knownEntities[eid] = 1;
+}
+
+void JavaSession::spawnObject(JavaByteBuf* in) {
+	int32_t eid = in->readVarInt();
+	int32_t type = in->readByte();
+	double x = (double)in->readInt() / 32.0;
+	double y = (double)in->readInt() / 32.0;
+	double z = (double)in->readInt() / 32.0;
+	float pitch = (float)in->readSByte() * 360.0f / 256.0f;
+	float yaw = (float)in->readSByte() * 360.0f / 256.0f;
+	int32_t data = in->readInt();
+	int32_t vx = 0, vy = 0, vz = 0;
+	if(data > 0) {
+		vx = in->readShort();
+		vy = in->readShort();
+		vz = in->readShort();
+	}
+	if(in->failed() || !this->level) {
+		return;
+	}
+
+	if(type == 2) {
+		// Dropped item.  The stack itself arrives in a later Entity Metadata,
+		// so start from an empty instance and remember to fill it in.
+		ItemEntity* item = new ItemEntity(this->level, (float)x, (float)JavaY::toM8d(y), (float)z,
+		                                 ItemInstance(Item::stick ? Item::stick->itemID : 280, 1, 0));
+		item->lerpMotion((float)vx / 8000.0f, (float)vy / 8000.0f, (float)vz / 8000.0f);
+		this->attachEntity(eid, item);
+		this->knownEntities[eid] = 1;
+		this->pendingItems[eid] = 1;
+		return;
+	}
+
+	int32_t m8Type = JavaIdMap::javaObjectToM8(type);
+	if(!m8Type) {
+		return;
+	}
+	Entity* e = EntityFactory::CreateEntity(m8Type, this->level);
+	if(!e) {
+		return;
+	}
+	if(e->isMob()) {
+		((Mob*)e)->moveTo((float)x, (float)JavaY::toM8d(y), (float)z, yaw, pitch);
+	} else {
+		e->moveTo((float)x, (float)JavaY::toM8d(y), (float)z, yaw, pitch);
+	}
+	if(type == 70) {
+		// Falling block: the data field is Block.getStateId(), which is
+		// id | (meta << 12).  FallingTile::tick() removes itself outright when
+		// blockID is 0, so an id m8 has no tile for falls back to sand rather
+		// than winking out of existence the tick after it spawns.
+		int32_t id = 0, meta = 0;
+		if(data > 0) {
+			JavaIdMap::javaBlockToM8(data & 0xFFF, (data >> 12) & 0xF, &id, &meta);
+		}
+		if(!id) {
+			id = Tile::sand ? Tile::sand->blockID : 12;
+			meta = 0;
+		}
+		((FallingTile*)e)->blockID = id;
+		((FallingTile*)e)->blockMetaMaybe = meta;
+	}
+	e->lerpMotion((float)vx / 8000.0f, (float)vy / 8000.0f, (float)vz / 8000.0f);
+	this->attachEntity(eid, e);
+	this->knownEntities[eid] = 1;
+}
+
+void JavaSession::spawnPlayer(JavaByteBuf* in) {
+	int32_t eid = in->readVarInt();
+	uint64_t hi = 0, lo = 0;
+	in->readUUID(&hi, &lo);
+	double x = (double)in->readInt() / 32.0;
+	double y = (double)in->readInt() / 32.0;
+	double z = (double)in->readInt() / 32.0;
+	float yaw = (float)in->readSByte() * 360.0f / 256.0f;
+	float pitch = (float)in->readSByte() * 360.0f / 256.0f;
+	int32_t heldItem = in->readShort();
+	if(in->failed() || !this->level || !this->minecraft) {
+		return;
+	}
+	this->readMetadata(in, 0, 0, 0);
+
+	RemotePlayer* p = new RemotePlayer(this->level, this->minecraft->isCreativeMode());
+	this->minecraft->gameMode->initAbilities(p->abilities);
+	p->moveTo((float)x, (float)JavaY::toM8d(y), (float)z, yaw, pitch);
+	p->headYaw = yaw;
+	p->prevHeadYaw = yaw;
+
+	std::string name;
+	std::map<uint64_t, std::string>::iterator it = this->playerNames.find(lo);
+	if(it != this->playerNames.end()) {
+		name = it->second;
+	}
+	p->username = name;
+
+	if(p->inventory) {
+		if(heldItem > 0) {
+			ItemInstance ii(JavaIdMap::javaItemToM8(heldItem), 1, 0);
+			p->inventory->replaceSlot(9, &ii);
+		} else {
+			p->inventory->clearSlot(9);
+		}
+		p->inventory->moveToSelectedSlot(9);
+	}
+	this->attachEntity(eid, p);
+	this->knownEntities[eid] = 1;
+}
+
+void JavaSession::moveEntity(int32_t javaEid, double dx, double dy, double dz,
+                             bool_t hasRot, float yaw, float pitch, bool_t absolute) {
+	Entity* e = this->findEntity(javaEid);
+	if(!e) {
+		return;
+	}
+	if(!hasRot) {
+		yaw = e->yaw;
+		pitch = e->pitch;
+	}
+
+	/*
+	 * lerpTo's Y argument is not the same thing on both sides of the hierarchy:
+	 * Mob::lerpTo adds ridingHeight itself (so it wants feet level) while
+	 * Entity::lerpTo assigns posY straight through (so it wants eye/centre
+	 * level).  Feed each the one it expects.
+	 */
+	bool_t isMob = e->isMob();
+	double baseY = isMob ? (double)(e->posY - e->ridingHeight) : (double)e->posY;
+	double targetY;
+	if(absolute) {
+		targetY = JavaY::toM8d(dy);
+		if(!isMob) {
+			targetY += (double)e->ridingHeight;
+		}
+	} else {
+		targetY = baseY + dy;
+	}
+	double targetX = absolute ? dx : (double)e->posX + dx;
+	double targetZ = absolute ? dz : (double)e->posZ + dz;
+
+	e->lerpTo((float)targetX, (float)targetY, (float)targetZ, yaw, pitch, 3);
+}
+
+void JavaSession::destroyEntity(int32_t javaEid) {
+	MultiPlayerLevel* lvl = this->level;
+	if(!lvl) {
+		return;
+	}
+	this->knownEntities.erase(javaEid);
+	this->pendingItems.erase(javaEid);
+
+	Entity* e = 0;
+	std::map<int32_t, Entity*>::iterator mapped = lvl->field_BAC.find(javaEid);
+	if(mapped != lvl->field_BAC.end()) {
+		Entity* old = mapped->second;
+		lvl->field_BAC.erase(mapped);
+		lvl->field_BC4.erase(old);
+		lvl->field_BDC.erase(old);
+		if(lvl->getEntity(javaEid) == old) {
+			e = old;
+		}
+	} else {
+		e = lvl->getEntity(javaEid);
+	}
+	if(!e || e == (Entity*)this->player) {
+		return;
+	}
+	this->retireEntity(e);
+}
+
+// -------------------------------------------------------- wire helpers ------
+
+static bool_t javaSkipNbtPayload(JavaByteBuf* in, int32_t type, int32_t depth) {
+	if(depth > 32 || in->failed()) {
+		return 0;
+	}
+	switch(type) {
+	case 0: return 1;
+	case 1: in->skip(1); return !in->failed();
+	case 2: in->skip(2); return !in->failed();
+	case 3: case 5: in->skip(4); return !in->failed();
+	case 4: case 6: in->skip(8); return !in->failed();
+	case 7: { // byte array
+		int32_t len = in->readInt();
+		if(in->failed() || len < 0) return 0;
+		in->skip((size_t)len);
+		return !in->failed();
+	}
+	case 8: { // string
+		int32_t len = in->readUShort();
+		if(in->failed()) return 0;
+		in->skip((size_t)len);
+		return !in->failed();
+	}
+	case 9: { // list
+		int32_t elem = in->readByte();
+		int32_t len = in->readInt();
+		if(in->failed() || len < 0) return 0;
+		for(int32_t i = 0; i < len; ++i) {
+			if(!javaSkipNbtPayload(in, elem, depth + 1)) return 0;
+		}
+		return 1;
+	}
+	case 10: { // compound
+		while(1) {
+			int32_t t = in->readByte();
+			if(in->failed()) return 0;
+			if(t == 0) return 1;
+			int32_t nameLen = in->readUShort();
+			if(in->failed()) return 0;
+			in->skip((size_t)nameLen);
+			if(!javaSkipNbtPayload(in, t, depth + 1)) return 0;
+		}
+	}
+	case 11: { // int array
+		int32_t len = in->readInt();
+		if(in->failed() || len < 0) return 0;
+		in->skip((size_t)len * 4);
+		return !in->failed();
+	}
+	default:
+		return 0;
+	}
+}
+
+/*
+ * Java's NBT is big endian and m8's is little endian, so CompoundTag cannot read
+ * a tile entity blob off the wire.  Nothing here needs the whole tree either -
+ * only the four strings - so this walks the tag the same way javaSkipNbtPayload
+ * does and keeps the names it recognises.
+ */
+static bool_t javaCollectSignText(JavaByteBuf* in, int32_t type, int32_t depth, std::string* lines);
+
+static std::string javaReadNbtString(JavaByteBuf* in) {
+	int32_t len = in->readUShort();
+	if(in->failed() || len < 0) {
+		return std::string();
+	}
+	std::string out;
+	out.resize((size_t)len);
+	if(len > 0) {
+		in->readBytes((uint8_t*)&out[0], (size_t)len);
+	}
+	if(in->failed()) {
+		return std::string();
+	}
+	return out;
+}
+
+static bool_t javaCollectSignText(JavaByteBuf* in, int32_t type, int32_t depth, std::string* lines) {
+	if(depth > 32 || in->failed()) {
+		return 0;
+	}
+	if(type != 10) {
+		return javaSkipNbtPayload(in, type, depth);
+	}
+	while(1) {
+		int32_t t = in->readByte();
+		if(in->failed()) return 0;
+		if(t == 0) return 1;
+		std::string name = javaReadNbtString(in);
+		if(in->failed()) return 0;
+		int32_t slot = -1;
+		if(t == 8 && name.size() == 5 && name.compare(0, 4, "Text") == 0
+		   && name[4] >= '1' && name[4] <= '4') {
+			slot = name[4] - '1';
+		}
+		if(slot >= 0) {
+			lines[slot] = javaReadNbtString(in);
+			if(in->failed()) return 0;
+		} else if(!javaCollectSignText(in, t, depth + 1, lines)) {
+			return 0;
+		}
+	}
+}
+
+bool_t JavaSession::readSignNbt(JavaByteBuf* in, std::string* lines) {
+	int32_t type = in->readByte();
+	if(in->failed() || type != 10) {
+		return 0;
+	}
+	int32_t nameLen = in->readUShort();
+	if(in->failed()) {
+		return 0;
+	}
+	in->skip((size_t)nameLen);
+	if(in->failed()) {
+		return 0;
+	}
+	return javaCollectSignText(in, type, 0, lines);
+}
+
+void JavaSession::skipNbt(JavaByteBuf* in) {
+	int32_t type = in->readByte();
+	if(in->failed() || type == 0) {
+		return;
+	}
+	int32_t nameLen = in->readUShort();
+	if(in->failed()) {
+		return;
+	}
+	in->skip((size_t)nameLen);
+	javaSkipNbtPayload(in, type, 0);
+}
+
+bool_t JavaSession::readSlot(JavaByteBuf* in, int32_t* outId, int32_t* outCount, int32_t* outDamage,
+                             std::vector<uint8_t>* rawOut) {
+	size_t start = in->readPos;
+	int32_t id = in->readShort();
+	if(in->failed()) {
+		return 0;
+	}
+	int32_t count = 0;
+	int32_t damage = 0;
+	if(id >= 0) {
+		count = in->readByte();
+		damage = in->readShort();
+		this->skipNbt(in);
+		if(in->failed()) {
+			return 0;
+		}
+	} else {
+		id = -1;
+	}
+	if(outId) *outId = id;
+	if(outCount) *outCount = count;
+	if(outDamage) *outDamage = damage;
+	if(rawOut) {
+		rawOut->assign(in->data() + start, in->data() + in->readPos);
+	}
+	return 1;
+}
+
+/*
+ * Walk a 1.8 DataWatcher blob.  We only actually want one field out of it - the
+ * ItemStack a dropped item carries at index 10 - but the whole list has to be
+ * consumed correctly because more packet fields can follow it.
+ */
+bool_t JavaSession::readMetadata(JavaByteBuf* in, int32_t* outItemId, int32_t* outCount,
+                                 int32_t* outDamage) {
+	while(1) {
+		int32_t header = in->readByte();
+		if(in->failed()) {
+			return 0;
+		}
+		if(header == 127) {
+			return 1;
+		}
+		int32_t type = (header & 0xE0) >> 5;
+		int32_t index = header & 0x1F;
+		switch(type) {
+		case 0: in->skip(1); break;
+		case 1: in->skip(2); break;
+		case 2: case 3: in->skip(4); break;
+		case 4: in->readString(); break;
+		case 5: {
+			int32_t id = 0, count = 0, damage = 0;
+			if(!this->readSlot(in, &id, &count, &damage, 0)) return 0;
+			if(index == 10 && outItemId) {
+				*outItemId = id;
+				if(outCount) *outCount = count;
+				if(outDamage) *outDamage = damage;
+			}
+			break;
+		}
+		case 6: in->skip(12); break;
+		case 7: in->skip(12); break;
+		default:
+			return 0;
+		}
+		if(in->failed()) {
+			return 0;
+		}
+	}
+}
+
+// ------------------------------------------------------- outbound helpers ---
+
+void JavaSession::sendKeepAlive(int32_t id) {
+	JavaByteBuf out;
+	this->beginPacket(&out, 0x00);
+	out.writeVarInt(id);
+	this->send(out);
+}
+
+void JavaSession::sendClientSettings() {
+	JavaByteBuf out;
+	this->beginPacket(&out, 0x15);
+	out.writeString("en_US");
+	int32_t view = 8;
+	if(this->minecraft) {
+		view = this->minecraft->options.renderDistance;
+		// m8's option is an enum (0 = far .. 3 = tiny); turn it into chunks.
+		switch(view) {
+		case 0: view = 10; break;
+		case 1: view = 8; break;
+		case 2: view = 6; break;
+		default: view = 4; break;
+		}
+	}
+	out.writeSByte((int8_t)view);
+	out.writeSByte(0);   // chat mode: enabled
+	out.writeBool(1);    // chat colours
+	out.writeByte(0x7F); // every skin layer on
+	this->send(out);
+	/*
+	 * No Client Status here.  It looked like the "I have finished loading"
+	 * handshake, but 1.8 has no such thing - the server starts ticking a player
+	 * the moment it lets them in - and the only value it can carry at this point
+	 * is PERFORM_RESPAWN, which a living player never sends.  A vanilla server
+	 * ignores it; a verification front end reasonably treats a packet no client
+	 * would send as proof that this is not one.
+	 */
+}
+
+void JavaSession::sendClientBrand() {
+	JavaByteBuf out;
+	this->beginPacket(&out, 0x17); // Plugin Message
+	out.writeString("MC|Brand");
+	/*
+	 * ClientBrandRetriever.getClientModName() is the literal "vanilla" in an
+	 * unmodified 1.8 client, and on the wire the payload is a length prefixed
+	 * string, not raw bytes (1.7 was the other way round).  The capitalised
+	 * "Vanilla" some tools send is a known bot signature, so keep it lowercase.
+	 */
+	out.writeString("vanilla");
+	this->send(out);
+}
+
+void JavaSession::sendResourcePackStatus(const std::string& hash, int32_t status) {
+	JavaByteBuf out;
+	this->beginPacket(&out, 0x19);
+	out.writeString(hash.size() > 40 ? hash.substr(0, 40) : hash);
+	out.writeVarInt(status);
+	this->send(out);
+}
+
+void JavaSession::sendEntityAction(int32_t action) {
+	JavaByteBuf out;
+	this->beginPacket(&out, 0x0B);
+	out.writeVarInt(this->serverEid);
+	out.writeVarInt(action);
+	out.writeVarInt(0); // aux data, only used by horse jumps
+	this->send(out);
+}
+
+/*
+ * EntityPlayerSP.onUpdateWalkingPlayer, packet for packet.
+ *
+ * A Java client reports itself once every tick and never more often than that,
+ * and which of the four movement packets it picks depends on what actually
+ * changed: position and rotation, position only, rotation only, or - standing
+ * perfectly still - the bare "on the ground" flag.  Getting this right is not
+ * cosmetic.  The server counts a player's ticks by these packets, so sending
+ * thirty a second (which is what a frame driven sender does at sixty frames)
+ * looks exactly like a speed hack, and sending none while standing still makes
+ * the fall and gravity checks of a verification plugin see a player who is not
+ * simulating physics.  Both get you thrown off a public server.
+ */
+void JavaSession::playerTick() {
+	if(this->phase != JavaSession::PLAY || !this->levelLive) {
+		return;
+	}
+	if(!this->player) {
+		this->player = this->minecraft ? this->minecraft->player : 0;
+		if(!this->player) {
+			return;
+		}
+	}
+
+	// Sneaking and sprinting are state rather than movement: they are reported
+	// once, when they change.  Without them the server has us walking upright
+	// forever, which costs the sprint speed it grants and the hitbox it shrinks.
+	bool_t sprint = this->player->isSprinting ? 1 : 0;
+	if(sprint != this->sentSprint) {
+		this->sentSprint = sprint;
+		this->sendEntityAction(sprint ? 3 : 4); // START_SPRINTING / STOP_SPRINTING
+	}
+	bool_t sneak = this->player->isSneaking() ? 1 : 0;
+	if(sneak != this->sentSneak) {
+		this->sentSneak = sneak;
+		this->sendEntityAction(sneak ? 0 : 1); // START_SNEAKING / STOP_SNEAKING
+	}
+
+	double x = (double)this->player->posX;
+	double feetY = (double)this->player->boundingBox.minY; // and not posY: see below
+	double z = (double)this->player->posZ;
+	float yaw = this->player->yaw;
+	float pitch = this->player->pitch;
+	bool_t ground = this->player->onGround;
+
+	double dx = x - this->sentX;
+	double dy = feetY - this->sentY;
+	double dz = z - this->sentZ;
+	bool_t moved = !this->everSentPosition
+		|| dx * dx + dy * dy + dz * dz > 9.0e-4
+		|| this->positionUpdateTicks >= 20;
+	bool_t turned = yaw != this->sentYaw || pitch != this->sentPitch;
+
+	int32_t kind = moved && turned ? 3 : (moved ? 1 : (turned ? 2 : 0));
+	if(javaDebugEnabled()) {
+		int32_t now = getTimeMs();
+		++this->moveWindow[kind];
+		if(this->moveWindowMs == 0) {
+			this->moveWindowMs = now;
+		} else if(now - this->moveWindowMs >= 1000) {
+			javaDebug("moves/s: %d bare, %d pos, %d look, %d both (%d ms)",
+			          (int)this->moveWindow[0], (int)this->moveWindow[1],
+			          (int)this->moveWindow[2], (int)this->moveWindow[3],
+			          (int)(now - this->moveWindowMs));
+			memset(this->moveWindow, 0, sizeof(this->moveWindow));
+			this->moveWindowMs = now;
+		}
+	}
+
+	JavaByteBuf out;
+	if(moved && turned) {
+		this->beginPacket(&out, 0x06); // Player Position And Look
+		out.writeDouble(x);
+		out.writeDouble(JavaY::toJavad(feetY));
+		out.writeDouble(z);
+		out.writeFloat(yaw);
+		out.writeFloat(pitch);
+	} else if(moved) {
+		this->beginPacket(&out, 0x04); // Player Position
+		out.writeDouble(x);
+		out.writeDouble(JavaY::toJavad(feetY));
+		out.writeDouble(z);
+	} else if(turned) {
+		this->beginPacket(&out, 0x05); // Player Look
+		out.writeFloat(yaw);
+		out.writeFloat(pitch);
+	} else {
+		this->beginPacket(&out, 0x03); // Player
+	}
+	out.writeBool(ground);
+	this->send(out);
+	this->lastMoveSentMs = getTimeMs();
+
+	/*
+	 * How the client falls is the one thing a verification lobby always looks
+	 * at, so while the debug log is on every airborne tick is written down.  A
+	 * vanilla 1.8 client loses 0.08 blocks a tick to gravity and two percent of
+	 * its speed to drag; anything else here is a physics bug worth seeing.
+	 */
+	if(javaDebugEnabled() && !ground) {
+		javaDebug("air y=%.3f dy=%+.4f my=%+.4f fall=%.1f fly=%d mayfly=%d hold=%d",
+		          JavaY::toJavad(feetY), dy, (double)this->player->motionY,
+		          this->player->fallDistance, (int)this->player->abilities.flying,
+		          (int)this->player->abilities.mayfly, (int)this->respawnHold);
+	}
+
+	++this->positionUpdateTicks;
+	if(moved) {
+		this->sentX = x;
+		this->sentY = feetY;
+		this->sentZ = z;
+		this->positionUpdateTicks = 0;
+	}
+	if(turned) {
+		this->sentYaw = yaw;
+		this->sentPitch = pitch;
+	}
+	this->sentGround = ground;
+	this->everSentPosition = 1;
+}
+
+/*
+ * A full position, unconditionally.  playerTick() carries the normal traffic;
+ * this is for the moments when the player is not being ticked at all - a screen
+ * open over the world, terrain still arriving, the death screen - where the
+ * server would otherwise hear nothing for as long as that lasts.
+ */
+void JavaSession::sendPositionNow(bool_t force) {
+	if(this->phase != JavaSession::PLAY || !this->levelLive) {
+		return;
+	}
+	if(!this->player) {
+		this->player = this->minecraft ? this->minecraft->player : 0;
+		if(!this->player) {
+			return;
+		}
+	}
+
+	/*
+	 * Java's posY is the bottom of the collision box.  m8's posY is eye level and,
+	 * crucially, it lags the box by ySize: Entity::move() raises boundingBox by
+	 * stepHeight when you step onto something, then sets
+	 *
+	 *     posY = boundingBox.minY + ridingHeight - ySize
+	 *
+	 * with ySize bumped by 0.5 so the camera glides up over the next few ticks
+	 * instead of snapping.  Subtracting only ridingHeight therefore reports the
+	 * height we were at *before* the step for as long as ySize is decaying, which
+	 * for a slab or a stair is a position squarely inside the block we just
+	 * climbed onto.  NetHandlerPlayServer checks exactly that - if the box we
+	 * claim collides with terrain and the box we came from did not, it answers
+	 * with a teleport back to where we were - so every attempt to walk up a step
+	 * was being undone a tick later.  Read the box directly and the two clients
+	 * agree; jumps never showed the bug because a jump leaves ySize at zero.
+	 */
+	double feetY = (double)this->player->boundingBox.minY;
+	double x = (double)this->player->posX;
+	double z = (double)this->player->posZ;
+	float yaw = this->player->yaw;
+	float pitch = this->player->pitch;
+	bool_t ground = this->player->onGround;
+
+	if(!force && (int32_t)(getTimeMs() - this->lastMoveSentMs) < 50) {
+		return;
+	}
+
+	JavaByteBuf out;
+	this->beginPacket(&out, 0x06); // Player Position And Look
+	out.writeDouble(x);
+	out.writeDouble(JavaY::toJavad(feetY));
+	out.writeDouble(z);
+	out.writeFloat(yaw);
+	out.writeFloat(pitch);
+	out.writeBool(ground);
+	this->send(out);
+	this->lastMoveSentMs = getTimeMs();
+
+	this->sentX = x;
+	this->sentY = feetY;
+	this->sentZ = z;
+	this->sentYaw = yaw;
+	this->sentPitch = pitch;
+	this->sentGround = ground;
+	this->everSentPosition = 1;
+	this->positionUpdateTicks = 0;
+}
+
+void JavaSession::sendDigging(int32_t status, int32_t jx, int32_t jy, int32_t jz, int32_t face) {
+	JavaByteBuf out;
+	this->beginPacket(&out, 0x07);
+	out.writeVarInt(status);
+	out.writePosition(jx, jy, jz);
+	out.writeByte((uint8_t)face);
+	this->send(out);
+}
+
+void JavaSession::sendHeldSlot(int32_t slot) {
+	if(slot < 0 || slot > 8) {
+		return;
+	}
+	this->selectedSlot = slot;
+	JavaByteBuf out;
+	this->beginPacket(&out, 0x09);
+	out.writeShort((int16_t)slot);
+	this->send(out);
+}
+
+/*
+ * Write the stack in the selected hotbar slot in Java's Slot encoding.  When the
+ * server told us what is in that slot we echo its bytes back verbatim, so any
+ * NBT (enchantments, custom names, ...) survives the round trip.  Otherwise fall
+ * back to whatever m8 thinks it is holding.
+ */
+void JavaSession::writeHeldStack(JavaByteBuf* out) {
+	int32_t slot = this->selectedSlot;
+	// ... except in creative, where m8 may be holding something the server has
+	// not been told about yet; see applyInventorySlot().
+	if(this->gamemode != 1 && slot >= 0 && slot <= 8 && this->hotbar[slot].size() >= 2) {
+		out->writeBytes(&this->hotbar[slot][0], this->hotbar[slot].size());
+		return;
+	}
+	ItemInstance* held = 0;
+	if(this->player) {
+		held = this->player->getSelectedItem();
+	}
+	if(!held || !held->isValid || held->count <= 0) {
+		out->writeShort(-1);
+		return;
+	}
+	int32_t id = held->itemClass ? held->itemClass->itemID
+	           : (held->tileClass ? held->tileClass->blockID : 0);
+	int32_t javaId = JavaIdMap::m8ItemToJava(id);
+	if(javaId <= 0) {
+		out->writeShort(-1);
+		return;
+	}
+	out->writeShort((int16_t)javaId);
+	out->writeByte((uint8_t)held->count);
+	out->writeShort((int16_t)held->metadata);
+	out->writeByte(0); // no NBT
+}
diff --git a/modifiedeight-newadditions/impl/java/JavaSessionOut.cpp b/modifiedeight-newadditions/impl/java/JavaSessionOut.cpp
new file mode 100644
index 00000000..26f9a046
--- /dev/null
+++ b/modifiedeight-newadditions/impl/java/JavaSessionOut.cpp
@@ -0,0 +1,414 @@
+#include <java/JavaSession.hpp>
+#include <java/JavaLog.hpp>
+#include <java/JavaIdMap.hpp>
+#include <java/JavaY.hpp>
+
+#include <Minecraft.hpp>
+#include <entity/LocalPlayer.hpp>
+#include <inventory/Inventory.hpp>
+#include <item/Item.hpp>
+#include <item/ItemInstance.hpp>
+#include <level/Level.hpp>
+#include <level/MultiPlayerLevel.hpp>
+#include <tile/Tile.hpp>
+#include <tile/entity/SignTileEntity.hpp>
+
+#include <network/Packet.hpp>
+#include <network/packet/AnimatePacket.hpp>
+#include <network/packet/ContainerSetSlotPacket.hpp>
+#include <network/packet/DropItemPacket.hpp>
+#include <network/packet/EntityDataPacket.hpp>
+#include <network/packet/InteractPacket.hpp>
+#include <network/packet/MessagePacket.hpp>
+#include <network/packet/MovePlayerPacket.hpp>
+#include <network/packet/PlayerActionPacket.hpp>
+#include <network/packet/PlayerEquipmentPacket.hpp>
+#include <network/packet/RemoveBlockPacket.hpp>
+#include <network/packet/RespawnPacket.hpp>
+#include <network/packet/UseItemPacket.hpp>
+
+#include <math.h>
+
+/*
+ * Everything m8 wants to say to a server goes through RakNetInstance::send.
+ * When a Java session owns the level there is no RakNet peer on the other end,
+ * so this is where MCPE packets are turned into protocol 47 ones.
+ *
+ * The contract is deliberately "swallow everything": any MCPE packet we do not
+ * translate must still be consumed, because letting it reach the dead RakNet
+ * peer is at best wasted work and at worst a crash (ClientSideNetworkHandler
+ * happily fires ReadyPacket and RequestChunkPackets at level-generated time).
+ */
+
+// m8 lays its inventory container out as 0..8 linked hotbar handles, 9..17 the
+// hotbar proper, then 18..44 the backpack. Java counts 9..35 backpack then
+// 36..44 hotbar. Returns -1 for a slot with no Java equivalent.
+static int32_t javaSlotForM8Container(int32_t m8Index) {
+	if(m8Index >= 9 && m8Index <= 17) {
+		return 36 + (m8Index - 9);
+	}
+	if(m8Index >= 18 && m8Index <= 44) {
+		return 9 + (m8Index - 18);
+	}
+	return -1;
+}
+
+static void javaWriteStack(JavaByteBuf* out, const ItemInstance& item) {
+	if(!item.isValid || item.count <= 0) {
+		out->writeShort(-1);
+		return;
+	}
+	int32_t id = 0;
+	if(item.itemClass) {
+		id = item.itemClass->itemID;
+	} else if(item.tileClass) {
+		id = item.tileClass->blockID;
+	}
+	int32_t javaId = JavaIdMap::m8ItemToJava(id);
+	if(javaId <= 0) {
+		out->writeShort(-1);
+		return;
+	}
+	out->writeShort((int16_t)javaId);
+	out->writeByte((uint8_t)item.count);
+	out->writeShort((int16_t)item.metadata);
+	out->writeByte(0); // no NBT
+}
+
+/*
+ * Creative content is client authored.  m8 fills its hotbar from its own palette
+ * screen, and a Java server only ever learns what is in a creative slot from a
+ * Creative Inventory Action - its own creative window starts empty.  This is the
+ * one push that makes the two agree, sent once the level goes live and then per
+ * slot as the player edits it (through ContainerSetSlotPacket above).
+ */
+void JavaSession::sendCreativeSlot(int32_t javaSlot, const ItemInstance* item) {
+	if(this->phase != JavaSession::PLAY || this->gamemode != 1) {
+		return;
+	}
+	JavaByteBuf out;
+	this->beginPacket(&out, 0x10); // Creative Inventory Action
+	out.writeShort((int16_t)javaSlot);
+	if(item) {
+		javaWriteStack(&out, *item);
+	} else {
+		out.writeShort(-1);
+	}
+	this->send(out);
+}
+
+void JavaSession::pushCreativeInventory() {
+	if(this->gamemode != 1 || !this->player || !this->player->inventory) {
+		return;
+	}
+	Inventory* inv = this->player->inventory;
+	int32_t size = (int32_t)inv->items.size();
+	int32_t pushed = 0;
+	for(int32_t i = 9; i < size && i <= 44; ++i) {
+		ItemInstance* item = inv->getItem(i);
+		if(!item || !item->isValid || item->count <= 0) {
+			continue;
+		}
+		int32_t javaSlot = javaSlotForM8Container(i);
+		if(javaSlot < 0) {
+			continue;
+		}
+		this->sendCreativeSlot(javaSlot, item);
+		++pushed;
+	}
+	if(pushed) {
+		javaLog("pushed %d creative inventory slot(s) to the server", pushed);
+	}
+}
+
+/*
+ * m8 only announces its held item when the *item* changes (LocalPlayer::tick
+ * compares ids), so switching between two slots holding the same thing would
+ * leave the server pointing at the old one.  Comparing the slot itself once a
+ * tick covers every way the selection can move: hotbar tap, palette pick, or
+ * scroll wheel.
+ */
+void JavaSession::syncHeldSlot() {
+	if(!this->player || !this->player->inventory) {
+		return;
+	}
+	int32_t slot = this->player->inventory->selectedSlot;
+	if(slot < 0 || slot > 8 || slot == this->selectedSlot) {
+		return;
+	}
+	this->sendHeldSlot(slot);
+}
+
+void JavaSession::sendChatLine(const std::string& text) {
+	if(this->phase != JavaSession::PLAY || text.empty()) {
+		return;
+	}
+	// 1.8 refuses anything over 100 characters and disconnects the sender.
+	std::string line = text;
+	if(line.size() > 100) {
+		line.resize(100);
+	}
+	JavaByteBuf out;
+	this->beginPacket(&out, 0x01);
+	out.writeString(line);
+	this->send(out);
+	this->flushOut();
+}
+
+/*
+ * 1.8 carries sign lines as chat components, and C12PacketUpdateSign hands each
+ * one straight to IChatComponent.Serializer.jsonToComponent, which answers null
+ * for an empty string and takes the server's packet thread down with it on the
+ * next getUnformattedText().  So every line is written, blank ones included, as
+ * a real object.  The server strips formatting codes itself, but the quotes and
+ * backslashes have to survive the trip as text rather than as JSON syntax.
+ */
+static void javaWriteSignLine(JavaByteBuf* out, const std::string& text) {
+	std::string json = "{\"text\":\"";
+	for(size_t i = 0; i < text.size(); ++i) {
+		unsigned char c = (unsigned char)text[i];
+		if(c == '"' || c == '\\') {
+			json += '\\';
+			json += (char)c;
+		} else if(c == '\n' || c == '\r' || c == '\t') {
+			json += ' ';
+		} else if(c >= 0x20) {
+			json += (char)c;
+		}
+	}
+	json += "\"}";
+	out->writeString(json);
+}
+
+/*
+ * The server only accepts this while the sign is still editable and still owned
+ * by us, which is the window it opens with Sign Editor Open right after we place
+ * one - the same moment m8 puts its TextEditScreen up.  Pressing Done is the one
+ * and only chance to say what the board reads.
+ */
+void JavaSession::sendSignText(int32_t mx, int32_t my, int32_t mz) {
+	if(!this->level) {
+		return;
+	}
+	int32_t jy = JavaY::toJava(my);
+	if(jy < 0 || jy > 255) {
+		return;
+	}
+	TileEntity* te = this->level->getTileEntity(mx, my, mz);
+	if(!te || te->type != 4) {
+		return;
+	}
+	SignTileEntity* sign = (SignTileEntity*)te;
+
+	JavaByteBuf out;
+	this->beginPacket(&out, 0x12); // Update Sign
+	out.writePosition(mx, jy, mz);
+	for(int32_t i = 0; i < 4; ++i) {
+		javaWriteSignLine(&out, sign->textLines[i]);
+	}
+	this->send(out);
+	javaDebug("out sign %d %d %d [%s|%s|%s|%s]", mx, jy, mz,
+	          sign->textLines[0].c_str(), sign->textLines[1].c_str(),
+	          sign->textLines[2].c_str(), sign->textLines[3].c_str());
+}
+
+bool_t JavaSession::interceptSend(Packet* pk) {
+	if(!this->isActive()) {
+		return 0;
+	}
+	if(!pk) {
+		return 1;
+	}
+	if(this->phase != JavaSession::PLAY || !this->levelLive) {
+		return 1; // still joining - nothing we send now would be understood
+	}
+
+	// ---- movement -----------------------------------------------------------
+	/*
+	 * Movement never comes through here: LocalPlayer::tick hands a Java session
+	 * to JavaSession::playerTick instead, which reports every tick the way a Java
+	 * client does.  This is only the backstop for anything else that reaches for
+	 * sendPosition(), and dropping it on the floor is the right answer twice
+	 * over.  MovePlayerPacket's y is posY - ridingHeight, and posY lags the
+	 * collision box by ySize for several ticks after a step up (Entity::move
+	 * raises the box immediately and lets the camera catch up), so relayed
+	 * verbatim it claims a position inside the slab or stair just climbed onto -
+	 * NetHandlerPlayServer sees a box that collides where the previous one did
+	 * not and answers with a teleport back, which was the shove on the first tick
+	 * of every step.  playerTick reads boundingBox.minY, the value Java actually
+	 * means.
+	 */
+	if(dynamic_cast<MovePlayerPacket*>(pk)) {
+		return 1;
+	}
+
+	// ---- breaking blocks ----------------------------------------------------
+	if(RemoveBlockPacket* p = dynamic_cast<RemoveBlockPacket*>(pk)) {
+		int32_t x = p->x;
+		int32_t y = (int32_t)p->y;
+		int32_t z = p->z;
+		int32_t face = 1;
+		if(this->minecraft && this->minecraft->selectedObject.hitType == 2
+		   && this->minecraft->selectedObject.field_4 == x
+		   && this->minecraft->selectedObject.field_8 == y
+		   && this->minecraft->selectedObject.field_C == z) {
+			face = this->minecraft->selectedObject.field_10;
+		}
+		int32_t jy = JavaY::toJava(y);
+		// m8 has already taken the block out locally, so announce both ends of
+		// the dig at once. If the server disagrees it answers with a Block
+		// Change and the world heals itself.
+		this->sendDigging(0, x, jy, z, face);
+		this->sendDigging(2, x, jy, z, face);
+		javaDebug("out dig %d %d %d face=%d", x, jy, z, face);
+		return 1;
+	}
+
+	// ---- using / placing ---------------------------------------------------
+	if(UseItemPacket* p = dynamic_cast<UseItemPacket*>(pk)) {
+		JavaByteBuf out;
+		this->beginPacket(&out, 0x08); // Player Block Placement
+		if(p->face == 255) {
+			// "used in air": 1.8 signals that with an impossible position and
+			// a direction of -1.
+			out.writePosition(-1, -1, -1);
+			out.writeByte(0xFF);
+			this->writeHeldStack(&out);
+			out.writeByte(0xFF);
+			out.writeByte(0xFF);
+			out.writeByte(0xFF);
+		} else {
+			int32_t jy = JavaY::toJava(p->y);
+			if(jy < 0 || jy > 255) {
+				return 1;
+			}
+			out.writePosition(p->x, jy, p->z);
+			out.writeByte((uint8_t)(p->face & 0xFF));
+			this->writeHeldStack(&out);
+			int32_t cx = (int32_t)(p->faceX * 16.0f);
+			int32_t cy = (int32_t)(p->faceY * 16.0f);
+			int32_t cz = (int32_t)(p->faceZ * 16.0f);
+			out.writeByte((uint8_t)(cx & 0xFF));
+			out.writeByte((uint8_t)(cy & 0xFF));
+			out.writeByte((uint8_t)(cz & 0xFF));
+		}
+		this->send(out);
+		javaDebug("out place %d %d %d face=%d cursor=%.2f,%.2f,%.2f held=%d",
+		          p->x, (int32_t)JavaY::toJava(p->y), p->z, p->face,
+		          p->faceX, p->faceY, p->faceZ, this->selectedSlot);
+		return 1;
+	}
+
+	// ---- sign text ----------------------------------------------------------
+	/*
+	 * TextEditScreen is the only thing in 0.8.1 that sends an EntityDataPacket,
+	 * and it sends exactly one: SignTileEntity::getUpdatePacket, when the player
+	 * closes the board.  The tag it carries is the same text the tile entity
+	 * still holds, so read it from there rather than unpicking the NBT.
+	 */
+	if(EntityDataPacket* p = dynamic_cast<EntityDataPacket*>(pk)) {
+		this->sendSignText(p->x, p->y, p->z);
+		return 1;
+	}
+
+	// ---- releasing a charged item (bow) -------------------------------------
+	if(PlayerActionPacket* p = dynamic_cast<PlayerActionPacket*>(pk)) {
+		if(p->action == 5) {
+			this->sendDigging(5, 0, 0, 0, 255);
+		}
+		return 1;
+	}
+
+	// ---- arm swing ----------------------------------------------------------
+	if(AnimatePacket* p = dynamic_cast<AnimatePacket*>(pk)) {
+		if(p->action == 1) {
+			JavaByteBuf out;
+			this->beginPacket(&out, 0x0A); // Animation - no payload
+			this->send(out);
+		}
+		return 1;
+	}
+
+	// ---- hitting / right-clicking an entity --------------------------------
+	if(InteractPacket* p = dynamic_cast<InteractPacket*>(pk)) {
+		JavaByteBuf out;
+		this->beginPacket(&out, 0x02); // Use Entity
+		out.writeVarInt(p->type);      // the *target* id, despite the name
+		out.writeVarInt(p->action == 2 ? 1 : 0); // 1 = ATTACK, 0 = INTERACT
+		this->send(out);
+		return 1;
+	}
+
+	// ---- chat ---------------------------------------------------------------
+	if(MessagePacket* p = dynamic_cast<MessagePacket*>(pk)) {
+		this->sendChatLine(std::string(p->message.C_String()));
+		return 1;
+	}
+
+	// ---- respawn ------------------------------------------------------------
+	if(dynamic_cast<RespawnPacket*>(pk)) {
+		JavaByteBuf out;
+		this->beginPacket(&out, 0x16); // Client Status
+		out.writeVarInt(0);            // perform respawn
+		this->send(out);
+		return 1;
+	}
+
+	// ---- dropping the held stack -------------------------------------------
+	if(dynamic_cast<DropItemPacket*>(pk)) {
+		this->sendDigging(3, 0, 0, 0, 255); // DROP_ALL_ITEMS
+		return 1;
+	}
+
+	// ---- switching hotbar slot ---------------------------------------------
+	if(PlayerEquipmentPacket* p = dynamic_cast<PlayerEquipmentPacket*>(pk)) {
+		// m8 reports the container index it linked; turn it back into 0..8.
+		int32_t slot = p->slot;
+		if(slot >= 9 && slot <= 17) {
+			slot -= 9;
+		}
+		if(slot >= 0 && slot <= 8 && slot != this->selectedSlot) {
+			javaDebug("out held slot %d (m8 index %d)", slot, p->slot);
+			this->sendHeldSlot(slot);
+		}
+		return 1;
+	}
+
+	// ---- creative inventory edits ------------------------------------------
+	if(ContainerSetSlotPacket* p = dynamic_cast<ContainerSetSlotPacket*>(pk)) {
+		if(this->gamemode != 1) {
+			return 1; // only creative mode may set slots directly
+		}
+		int32_t javaSlot;
+		if(p->field_D == 120) {
+			if(p->field_E < 0 || p->field_E > 3) {
+				return 1;
+			}
+			javaSlot = 5 + p->field_E; // helmet first, same order as m8
+		} else if(p->field_D == 0) {
+			/*
+			 * Container 0 is the player's own inventory menu, and its slot
+			 * numbers are menu indices, not container indices: InventoryMenu
+			 * enumerates container slots 9.. as menu slots 0.., which is why
+			 * ServerSideNetworkHandler stores into `field_E + 9`.
+			 */
+			javaSlot = javaSlotForM8Container(p->field_E + 9);
+			if(javaSlot < 0) {
+				return 1;
+			}
+		} else {
+			return 1;
+		}
+		JavaByteBuf out;
+		this->beginPacket(&out, 0x10); // Creative Inventory Action
+		out.writeShort((int16_t)javaSlot);
+		javaWriteStack(&out, p->field_10);
+		this->send(out);
+		return 1;
+	}
+
+	// Everything else is MCPE-only bookkeeping the Java server neither needs
+	// nor understands (chunk requests, ready handshakes, entity links, health
+	// echoes). Consume it silently.
+	return 1;
+}
diff --git a/modifiedeight-newadditions/impl/java/JavaSocket.cpp b/modifiedeight-newadditions/impl/java/JavaSocket.cpp
new file mode 100644
index 00000000..0e45ac04
--- /dev/null
+++ b/modifiedeight-newadditions/impl/java/JavaSocket.cpp
@@ -0,0 +1,419 @@
+#include <java/JavaSocket.hpp>
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#ifdef _WIN32
+#include <winsock2.h>
+#include <ws2tcpip.h>
+typedef int socklen_t_compat;
+#define JSOCK_ERRNO      WSAGetLastError()
+#define JSOCK_WOULDBLOCK WSAEWOULDBLOCK
+#define JSOCK_INPROGRESS WSAEWOULDBLOCK
+#define JSOCK_INVALID    ((int64_t)INVALID_SOCKET)
+#define JSOCK_CLOSE(s)   closesocket((SOCKET)(s))
+#else
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <netinet/tcp.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <sys/select.h>
+typedef socklen_t socklen_t_compat;
+#define JSOCK_ERRNO      errno
+#define JSOCK_WOULDBLOCK EAGAIN
+#define JSOCK_INPROGRESS EINPROGRESS
+#define JSOCK_INVALID    ((int64_t)-1)
+#define JSOCK_CLOSE(s)   ::close((int)(s))
+#endif
+
+static bool_t gJavaSocketInited = 0;
+
+void JavaSocket::globalInit() {
+	if(gJavaSocketInited) return;
+	gJavaSocketInited = 1;
+#ifdef _WIN32
+	WSADATA wsa;
+	WSAStartup(MAKEWORD(2, 2), &wsa);
+#endif
+}
+
+JavaSocket::JavaSocket() {
+	this->fd = JSOCK_INVALID;
+	this->state = CLOSED;
+}
+
+JavaSocket::~JavaSocket() {
+	this->close();
+}
+
+void JavaSocket::close() {
+	if(this->fd != JSOCK_INVALID) {
+		JSOCK_CLOSE(this->fd);
+		this->fd = JSOCK_INVALID;
+	}
+	this->state = CLOSED;
+}
+
+bool_t JavaSocket::beginConnect(const std::string& ip, int32_t port) {
+	JavaSocket::globalInit();
+	this->close();
+	this->lastError.clear();
+
+	int64_t s = (int64_t)socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
+	if(s == JSOCK_INVALID) {
+		this->lastError = "socket() failed";
+		this->state = FAILED;
+		return 0;
+	}
+
+#ifdef _WIN32
+	u_long nb = 1;
+	ioctlsocket((SOCKET)s, FIONBIO, &nb);
+#else
+	int flags = fcntl((int)s, F_GETFL, 0);
+	fcntl((int)s, F_SETFL, flags | O_NONBLOCK);
+#endif
+	int one = 1;
+	setsockopt((int)s, IPPROTO_TCP, TCP_NODELAY, (const char*)&one, sizeof(one));
+
+	struct sockaddr_in addr;
+	memset(&addr, 0, sizeof(addr));
+	addr.sin_family = AF_INET;
+	addr.sin_port = htons((uint16_t)port);
+	if(inet_pton(AF_INET, ip.c_str(), &addr.sin_addr) != 1) {
+		JSOCK_CLOSE(s);
+		this->lastError = "Bad server address";
+		this->state = FAILED;
+		return 0;
+	}
+
+	int rc = ::connect((int)s, (struct sockaddr*)&addr, sizeof(addr));
+	if(rc == 0) {
+		this->fd = s;
+		this->state = CONNECTED;
+		return 1;
+	}
+	int err = JSOCK_ERRNO;
+	if(err == JSOCK_INPROGRESS
+#ifndef _WIN32
+	   || err == EINTR
+#endif
+	) {
+		this->fd = s;
+		this->state = CONNECTING;
+		return 1;
+	}
+	JSOCK_CLOSE(s);
+	char buf[96];
+	snprintf(buf, sizeof(buf), "connect() failed (%d)", err);
+	this->lastError = buf;
+	this->state = FAILED;
+	return 0;
+}
+
+void JavaSocket::pumpConnect() {
+	if(this->state != CONNECTING || this->fd == JSOCK_INVALID) return;
+
+	fd_set wset, eset;
+	FD_ZERO(&wset);
+	FD_ZERO(&eset);
+	FD_SET((int)this->fd, &wset);
+	FD_SET((int)this->fd, &eset);
+	struct timeval tv;
+	tv.tv_sec = 0;
+	tv.tv_usec = 0;
+
+	int rc = select((int)this->fd + 1, 0, &wset, &eset, &tv);
+	if(rc <= 0) return; // still pending
+
+	int soErr = 0;
+	socklen_t_compat len = sizeof(soErr);
+	if(getsockopt((int)this->fd, SOL_SOCKET, SO_ERROR, (char*)&soErr, &len) != 0) soErr = JSOCK_ERRNO;
+
+	if(soErr != 0 || FD_ISSET((int)this->fd, &eset)) {
+		char buf[96];
+		snprintf(buf, sizeof(buf), "Could not reach server (%d)", soErr);
+		this->lastError = buf;
+		this->close();
+		this->state = FAILED;
+		return;
+	}
+	this->state = CONNECTED;
+}
+
+int32_t JavaSocket::recvSome(uint8_t* dst, int32_t cap) {
+	if(this->state != CONNECTED || this->fd == JSOCK_INVALID) return -1;
+	int n = (int)recv((int)this->fd, (char*)dst, cap, 0);
+	if(n > 0) return n;
+	if(n == 0) {
+		this->lastError = "Server closed the connection";
+		return -1;
+	}
+	int err = JSOCK_ERRNO;
+	if(err == JSOCK_WOULDBLOCK
+#ifndef _WIN32
+	   || err == EWOULDBLOCK || err == EINTR
+#endif
+	) return 0;
+	char buf[96];
+	snprintf(buf, sizeof(buf), "recv() failed (%d)", err);
+	this->lastError = buf;
+	return -1;
+}
+
+int32_t JavaSocket::sendSome(const uint8_t* src, int32_t len) {
+	if(this->state != CONNECTED || this->fd == JSOCK_INVALID) return -1;
+	int flags = 0;
+#if !defined(_WIN32) && defined(MSG_NOSIGNAL)
+	flags = MSG_NOSIGNAL;
+#endif
+	int n = (int)send((int)this->fd, (const char*)src, len, flags);
+	if(n >= 0) return n;
+	int err = JSOCK_ERRNO;
+	if(err == JSOCK_WOULDBLOCK
+#ifndef _WIN32
+	   || err == EWOULDBLOCK || err == EINTR
+#endif
+	) return 0;
+	char buf[96];
+	snprintf(buf, sizeof(buf), "send() failed (%d)", err);
+	this->lastError = buf;
+	return -1;
+}
+
+// ---------------------------------------------------------------------------
+// DNS
+// ---------------------------------------------------------------------------
+
+bool_t JavaSocket::resolveAddress(const std::string& host, std::string* outIp) {
+	JavaSocket::globalInit();
+
+	// Already numeric?
+	struct in_addr probe;
+	if(inet_pton(AF_INET, host.c_str(), &probe) == 1) {
+		if(outIp) *outIp = host;
+		return 1;
+	}
+
+	struct addrinfo hints;
+	memset(&hints, 0, sizeof(hints));
+	hints.ai_family = AF_INET;
+	hints.ai_socktype = SOCK_STREAM;
+
+	struct addrinfo* res = 0;
+	if(getaddrinfo(host.c_str(), 0, &hints, &res) != 0 || !res) return 0;
+
+	bool_t ok = 0;
+	for(struct addrinfo* it = res; it; it = it->ai_next) {
+		if(it->ai_family != AF_INET || !it->ai_addr) continue;
+		struct sockaddr_in* sin = (struct sockaddr_in*)it->ai_addr;
+		char txt[INET_ADDRSTRLEN];
+		if(inet_ntop(AF_INET, &sin->sin_addr, txt, sizeof(txt))) {
+			if(outIp) *outIp = txt;
+			ok = 1;
+			break;
+		}
+	}
+	freeaddrinfo(res);
+	return ok;
+}
+
+/* Encode "a.b.c" as DNS labels: 1a1b1c0 */
+static void javaDnsWriteName(std::vector<uint8_t>& out, const std::string& name) {
+	size_t i = 0;
+	while(i < name.size()) {
+		size_t dot = name.find('.', i);
+		if(dot == std::string::npos) dot = name.size();
+		size_t len = dot - i;
+		if(len > 63) len = 63;
+		out.push_back((uint8_t)len);
+		for(size_t k = 0; k < len; ++k) out.push_back((uint8_t)name[i + k]);
+		i = dot + 1;
+	}
+	out.push_back(0);
+}
+
+/* Walks a (possibly compressed) name, returning the offset just past it. */
+static size_t javaDnsSkipName(const uint8_t* buf, size_t len, size_t pos, std::string* out) {
+	if(out) out->clear();
+	int32_t guard = 0;
+	size_t cursor = pos;
+	size_t afterPointer = 0;
+	while(cursor < len && ++guard < 128) {
+		uint8_t l = buf[cursor];
+		if(l == 0) {
+			++cursor;
+			break;
+		}
+		if((l & 0xC0) == 0xC0) {
+			if(cursor + 1 >= len) return len;
+			if(!afterPointer) afterPointer = cursor + 2;
+			cursor = (size_t)(((l & 0x3F) << 8) | buf[cursor + 1]);
+			continue;
+		}
+		if(cursor + 1 + l > len) return len;
+		if(out) {
+			if(out->size()) out->push_back('.');
+			out->append((const char*)(buf + cursor + 1), l);
+		}
+		cursor += 1 + (size_t)l;
+	}
+	return afterPointer ? afterPointer : cursor;
+}
+
+/* Collects the nameservers we should ask. */
+static void javaDnsNameservers(std::vector<std::string>& out) {
+#ifndef _WIN32
+	FILE* f = fopen("/etc/resolv.conf", "r");
+	if(f) {
+		char line[256];
+		while(fgets(line, sizeof(line), f)) {
+			char* p = line;
+			while(*p == ' ' || *p == '\t') ++p;
+			if(strncmp(p, "nameserver", 10) != 0) continue;
+			p += 10;
+			while(*p == ' ' || *p == '\t') ++p;
+			char* e = p;
+			while(*e && *e != '\n' && *e != '\r' && *e != ' ' && *e != '\t' && *e != '#') ++e;
+			*e = 0;
+			if(*p && strchr(p, ':') == 0) out.push_back(p); // IPv4 resolvers only
+		}
+		fclose(f);
+	}
+#endif
+	// Public fallbacks, so an SRV lookup still works when resolv.conf is
+	// unavailable (Android, Windows, sandboxed builds).
+	out.push_back("1.1.1.1");
+	out.push_back("8.8.8.8");
+}
+
+bool_t JavaSocket::resolveSrv(const std::string& fqdn, std::string* outTarget, int32_t* outPort) {
+	JavaSocket::globalInit();
+
+	std::vector<std::string> servers;
+	javaDnsNameservers(servers);
+
+	std::vector<uint8_t> query;
+	query.push_back(0x4D); query.push_back(0x38); // transaction id "M8"
+	query.push_back(0x01); query.push_back(0x00); // standard query, recursion desired
+	query.push_back(0x00); query.push_back(0x01); // 1 question
+	query.push_back(0x00); query.push_back(0x00);
+	query.push_back(0x00); query.push_back(0x00);
+	query.push_back(0x00); query.push_back(0x00);
+	javaDnsWriteName(query, fqdn);
+	query.push_back(0x00); query.push_back(0x21); // QTYPE SRV (33)
+	query.push_back(0x00); query.push_back(0x01); // QCLASS IN
+
+	for(size_t si = 0; si < servers.size(); ++si) {
+		struct sockaddr_in ns;
+		memset(&ns, 0, sizeof(ns));
+		ns.sin_family = AF_INET;
+		ns.sin_port = htons(53);
+		if(inet_pton(AF_INET, servers[si].c_str(), &ns.sin_addr) != 1) continue;
+
+		int64_t s = (int64_t)socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
+		if(s == JSOCK_INVALID) continue;
+
+		bool_t got = 0;
+		if(sendto((int)s, (const char*)&query[0], (int)query.size(), 0,
+		          (struct sockaddr*)&ns, sizeof(ns)) == (int)query.size()) {
+			fd_set rset;
+			FD_ZERO(&rset);
+			FD_SET((int)s, &rset);
+			struct timeval tv;
+			tv.tv_sec = 1;
+			tv.tv_usec = 500000;
+			if(select((int)s + 1, &rset, 0, 0, &tv) > 0) {
+				uint8_t reply[1500];
+				int n = (int)recv((int)s, (char*)reply, sizeof(reply), 0);
+				if(n > 12) {
+					size_t len = (size_t)n;
+					int32_t qdCount = (reply[4] << 8) | reply[5];
+					int32_t anCount = (reply[6] << 8) | reply[7];
+					size_t pos = 12;
+					for(int32_t q = 0; q < qdCount && pos < len; ++q) {
+						pos = javaDnsSkipName(reply, len, pos, 0);
+						pos += 4; // QTYPE + QCLASS
+					}
+					int32_t bestPriority = 0x7FFFFFFF;
+					for(int32_t a = 0; a < anCount && pos + 10 <= len; ++a) {
+						pos = javaDnsSkipName(reply, len, pos, 0);
+						if(pos + 10 > len) break;
+						int32_t rtype = (reply[pos] << 8) | reply[pos + 1];
+						int32_t rdLen = (reply[pos + 8] << 8) | reply[pos + 9];
+						size_t rdata = pos + 10;
+						if(rdata + (size_t)rdLen > len) break;
+						if(rtype == 33 && rdLen >= 7) { // SRV
+							int32_t prio = (reply[rdata] << 8) | reply[rdata + 1];
+							int32_t port = (reply[rdata + 4] << 8) | reply[rdata + 5];
+							std::string target;
+							javaDnsSkipName(reply, len, rdata + 6, &target);
+							if(target.size() && prio < bestPriority) {
+								bestPriority = prio;
+								if(outTarget) *outTarget = target;
+								if(outPort) *outPort = port;
+								got = 1;
+							}
+						}
+						pos = rdata + (size_t)rdLen;
+					}
+				}
+			}
+		}
+		JSOCK_CLOSE(s);
+		if(got) return 1;
+	}
+	return 0;
+}
+
+bool_t JavaSocket::resolveMinecraftHost(const std::string& host, int32_t typedPort,
+                                        std::string* outIp, int32_t* outPort,
+                                        std::string* outConnectHost) {
+	std::string cleanHost = host;
+	// Allow "host:port" to be typed straight into the address box.
+	size_t colon = cleanHost.find(':');
+	int32_t port = typedPort;
+	if(colon != std::string::npos) {
+		std::string tail = cleanHost.substr(colon + 1);
+		long p = strtol(tail.c_str(), 0, 10);
+		if(p > 0 && p < 65536) port = (int32_t)p;
+		cleanHost = cleanHost.substr(0, colon);
+	}
+
+	if(outConnectHost) *outConnectHost = cleanHost;
+	if(outPort) *outPort = port;
+
+	// A numeric address means the operator told us exactly where to go.
+	struct in_addr probe;
+	if(inet_pton(AF_INET, cleanHost.c_str(), &probe) == 1) {
+		if(outIp) *outIp = cleanHost;
+		return 1;
+	}
+
+	// SRV first. Only trust it when we can also resolve its target.
+	std::string srvTarget;
+	int32_t srvPort = 0;
+	if(JavaSocket::resolveSrv("_minecraft._tcp." + cleanHost, &srvTarget, &srvPort)) {
+		std::string ip;
+		if(JavaSocket::resolveAddress(srvTarget, &ip)) {
+			if(outIp) *outIp = ip;
+			if(outPort) *outPort = srvPort;
+			// The handshake must still carry the name the player typed;
+			// virtual-host aware proxies (BungeeCord, aternos) key on it.
+			if(outConnectHost) *outConnectHost = cleanHost;
+			return 1;
+		}
+	}
+
+	std::string ip;
+	if(JavaSocket::resolveAddress(cleanHost, &ip)) {
+		if(outIp) *outIp = ip;
+		return 1;
+	}
+	return 0;
+}
diff --git a/modifiedeight-newadditions/impl/level/Level.cpp b/modifiedeight-newadditions/impl/level/Level.cpp
index ecf40ccb..fd2fab20 100644
--- a/modifiedeight-newadditions/impl/level/Level.cpp
+++ b/modifiedeight-newadditions/impl/level/Level.cpp
@@ -1,4 +1,5 @@
 #include <level/Level.hpp>
+#include <level/LevelHeight.hpp>
 #include <algorithm>
 #include <entity/EntityFactory.hpp>
 #include <entity/Player.hpp>
@@ -767,7 +768,7 @@ int32_t Level::getBrightness(const struct LightLayer& ll, int32_t x, int32_t y,
 	LevelChunk* chunk; // r0
 
 	v7 = x;
-	if((uint32_t)y > 0x7F) {
+	if(!LevelHeight::inRange(y)) {
 		return ll.baseLight;
 	}
 	v10 = x >> 4;
@@ -1097,7 +1098,7 @@ int32_t Level::getRawBrightness(int32_t x, int32_t y, int32_t z, bool_t recursiv
 		}
 	} else if(y < 0) {
 		return 0;
-	} else if(y <= 127) {
+	} else if(y <= LevelHeight::maxY()) {
 		chunk = this->getChunk(x >> 4, z >> 4);
 		if(!chunk) return 0;
 		return chunk->getRawBrightness(x & 0xF, y, z & 0xF, this->skyDarken);
@@ -1384,7 +1385,7 @@ int32_t Level::getTopSolidBlock(int32_t x, int32_t z) {
 	int32_t v12;		 // r6
 	const Material* mat; // r0
 
-	v6 = 127;
+	v6 = LevelHeight::maxY();
 	chunk = this->getChunkAt(x, z);
 	while(1) {
 		v8 = this->getMaterial(x, v6, z);
@@ -1411,7 +1412,7 @@ int32_t Level::getTopSolidBlock(int32_t x, int32_t z) {
 	return -1;
 }
 int32_t Level::getTopTileY(int32_t x, int32_t z) {
-	int32_t y = 127;
+	int32_t y = LevelHeight::maxY();
 	while(y > 0 && this->isEmptyTile(x, y, z)) {
 		--y;
 	}
@@ -1425,7 +1426,7 @@ bool_t Level::hasChunk(int32_t x, int32_t z) {
 	return this->chunkSource->hasChunk(x, z);
 }
 bool_t Level::hasChunkAt(int32_t x, int32_t y, int32_t z) {
-	return (uint32_t)y <= 127 && this->hasChunk(x >> 4, z >> 4);
+	return LevelHeight::inRange(y) && this->hasChunk(x >> 4, z >> 4);
 }
 bool_t Level::hasChunksAt(int32_t x, int32_t y, int32_t z, int32_t radius) {
 	return this->hasChunksAt(x - radius, y - radius, z - radius, x + radius, y + radius, z + radius);
@@ -1436,7 +1437,7 @@ bool_t Level::hasChunksAt(int32_t minX, int32_t minY, int32_t minZ, int32_t maxX
 	bool_t result; // r0
 	int32_t zz;	   // r4
 
-	if(maxY < 0 || minY > 127) {
+	if(maxY < 0 || minY > LevelHeight::maxY()) {
 		return 0;
 	}
 	xx = minX >> 4;
@@ -1469,9 +1470,9 @@ bool_t Level::hasNeighborSignal(int32_t x, int32_t y, int32_t z) {
 bool_t Level::inRange(int32_t x, int32_t y, int32_t z) {
 	// Infinite worlds have no horizontal bounds
 	if(this->levelData.getGeneratorVersion() != 0 && this->levelData.getGeneratorVersion() != 4) {
-		return (uint32_t)y <= 127;
+		return LevelHeight::inRange(y);
 	}
-	return (uint32_t)x <= 0xff && y <= 127 && z >= 0 && z <= 255;
+	return (uint32_t)x <= 0xff && y <= LevelHeight::maxY() && z >= 0 && z <= 255;
 }
 bool_t Level::isDay() {
 	return this->skyDarken <= 3;
@@ -1483,7 +1484,7 @@ bool_t Level::isSkyLit(int32_t x, int32_t y, int32_t z) {
 	int8_t xx = x;
 	int8_t zz = z;
 	if(y < 0) return 0;
-	if(y > 127) return 1;
+	if(y > LevelHeight::maxY()) return 1;
 	int32_t v9 = x >> 4;
 	int32_t v10 = z >> 4;
 	if(!this->hasChunk(x >> 4, z >> 4)) return 0;
@@ -1689,7 +1690,7 @@ void Level::setBrightness(const struct LightLayer& ll, int32_t x, int32_t y, int
 	int32_t v10;	   // r9
 	LevelChunk* chunk; // r0
 
-	if(y >= 0 && y <= 127) {
+	if(LevelHeight::inRange(y)) {
 		v10 = x >> 4;
 		if(this->hasChunk(x >> 4, z >> 4)) {
 			chunk = this->getChunk(v10, z >> 4);
@@ -1705,7 +1706,7 @@ bool_t Level::setData(int32_t x, int32_t y, int32_t z, int32_t data, int32_t fla
 	int v11;		   // r5
 	int v12;		   // r9
 
-	if(y < 0 || y > 127) {
+	if(!LevelHeight::inRange(y)) {
 		return 0;
 	}
 	chunk = this->getChunk(x >> 4, z >> 4);
@@ -1795,7 +1796,7 @@ bool_t Level::setTileAndData(int32_t x, int32_t y, int32_t z, int32_t id, int32_
 	int32_t curid;		// r11
 	bool_t res;			// r9
 
-	if(y < 0 || y > 127) {
+	if(!LevelHeight::inRange(y)) {
 		return 0;
 	}
 	chunk = this->getChunk(x >> 4, z >> 4);
@@ -1919,7 +1920,7 @@ void Level::tick(struct Entity* ent, bool_t a3) {
 
 	v6 = Mth::floor(ent->posX);
 	v7 = Mth::floor(ent->posZ);
-	if(!a3 || this->hasChunksAt(v6 - 32, 0, v7 - 32, v6 + 32, 128, v7 + 32)) {
+	if(!a3 || this->hasChunksAt(v6 - 32, 0, v7 - 32, v6 + 32, LevelHeight::height, v7 + 32)) {
 		ent->prevPosX = ent->posX;
 		ent->prevPosY = ent->posY;
 		ent->prevPosZ = ent->posZ;
@@ -2309,7 +2310,7 @@ Level::~Level() {
 	}
 }
 int32_t Level::getTile(int32_t x, int32_t y, int32_t z) {
-	if(y < 0 || y > 127) return 0;
+	if(!LevelHeight::inRange(y)) return 0;
 	LevelChunk* chunk = this->getChunk(x >> 4, z >> 4);
 	if(!chunk) return 0;
 	return chunk->getTile(x & 0xf, y, z & 0xf);
@@ -2321,7 +2322,7 @@ float Level::getBrightness(int32_t x, int32_t y, int32_t z) {
 	return this->dimensionPtr->lightRamp[this->getRawBrightness(x, y, z)];
 }
 int32_t Level::getData(int32_t x, int32_t y, int32_t z) {
-	if(y < 0 || y > 127) {
+	if(!LevelHeight::inRange(y)) {
 		return 0;
 	}
 	LevelChunk* chunk = this->getChunk(x >> 4, z >> 4);
@@ -2512,7 +2513,7 @@ void Level::tickTiles() {
 				uint32_t randXYZ = this->constRandom + 3 * this->prevRandomNumber;
 				int32_t x = (randXYZ >> 2) & 0xF;
 				int32_t z = (randXYZ >> 10) & 0xF;
-				int32_t y = (randXYZ >> 18) & 0x7F;
+				int32_t y = (randXYZ >> 18) & LevelHeight::maxY();
 				this->prevRandomNumber = randXYZ;
 				int32_t v21 = chunk->getTile(x, y, z);
 				if(Tile::shouldTick[v21]) {
diff --git a/modifiedeight-newadditions/impl/level/LevelHeight.cpp b/modifiedeight-newadditions/impl/level/LevelHeight.cpp
new file mode 100644
index 00000000..257a92c7
--- /dev/null
+++ b/modifiedeight-newadditions/impl/level/LevelHeight.cpp
@@ -0,0 +1,25 @@
+#include <level/LevelHeight.hpp>
+
+int32_t LevelHeight::height = MCPE_HEIGHT;
+int32_t LevelHeight::xShift = MCPE_X_SHIFT;
+int32_t LevelHeight::zShift = MCPE_Z_SHIFT;
+int32_t LevelHeight::tiles = MCPE_TILES;
+
+/*
+ * Call this immediately before building a Level and never while one is alive:
+ * every chunk of a level is allocated and indexed for the height that was set
+ * when the level was created.
+ */
+void LevelHeight::set(int32_t h) {
+	if(h > MCPE_HEIGHT) {
+		LevelHeight::height = JAVA_HEIGHT;
+		LevelHeight::xShift = JAVA_X_SHIFT;
+		LevelHeight::zShift = JAVA_Z_SHIFT;
+		LevelHeight::tiles = JAVA_TILES;
+	} else {
+		LevelHeight::height = MCPE_HEIGHT;
+		LevelHeight::xShift = MCPE_X_SHIFT;
+		LevelHeight::zShift = MCPE_Z_SHIFT;
+		LevelHeight::tiles = MCPE_TILES;
+	}
+}
diff --git a/modifiedeight-newadditions/impl/level/LightUpdate.cpp b/modifiedeight-newadditions/impl/level/LightUpdate.cpp
index 033e01ef..936130d1 100644
--- a/modifiedeight-newadditions/impl/level/LightUpdate.cpp
+++ b/modifiedeight-newadditions/impl/level/LightUpdate.cpp
@@ -1,4 +1,5 @@
 #include <level/LightUpdate.hpp>
+#include <level/LevelHeight.hpp>
 #include <level/Level.hpp>
 #include <level/LightLayer.hpp>
 #include <level/chunk/LevelChunk.hpp>
@@ -139,8 +140,8 @@ void LightUpdate::update(Level* a2) {
 						if(this->minY < 0) {
 							this->minY = 0;
 						}
-						if(this->maxY > 127) {
-							this->maxY = 127;
+						if(this->maxY > LevelHeight::maxY()) {
+							this->maxY = LevelHeight::maxY();
 						}
 						v6 = this->minY + 1;
 						z = a5 - 2;
diff --git a/modifiedeight-newadditions/impl/level/Region.cpp b/modifiedeight-newadditions/impl/level/Region.cpp
index faba50ca..3fb5e58f 100644
--- a/modifiedeight-newadditions/impl/level/Region.cpp
+++ b/modifiedeight-newadditions/impl/level/Region.cpp
@@ -1,4 +1,5 @@
 #include <level/Region.hpp>
+#include <level/LevelHeight.hpp>
 #include <level/Level.hpp>
 #include <level/chunk/LevelChunk.hpp>
 #include <level/dimension/Dimension.hpp>
@@ -69,7 +70,7 @@ int32_t Region::getRawBrightness(int32_t x, int32_t y, int32_t z, bool_t complex
 		}
 	} else if(y < 0) {
 		return 0;
-	} else if(y <= 127) {
+	} else if(y <= LevelHeight::maxY()) {
 		v14 = this->chunks[(x >> 4) - this->minCX][(z >> 4) - this->minCZ];
 		return v14->getRawBrightness(x & 0xF, y, z & 0xF, this->level->skyDarken);
 	} else {
@@ -88,7 +89,7 @@ Region::~Region() {
 
 int32_t Region::getTile(int32_t x, int32_t y, int32_t z) {
 	if(y < 0) return 0;
-	if(y > 127) return 0;
+	if(y > LevelHeight::maxY()) return 0;
 	int32_t v4 = (x >> 4) - this->minCX;
 	if(v4 < 0) return 0;
 	if(v4 >= this->sizeX) return 0;
@@ -105,7 +106,7 @@ float Region::getBrightness(int32_t x, int32_t y, int32_t z) {
 	return this->level->dimensionPtr->lightRamp[this->getRawBrightness(x, y, z)];
 }
 int32_t Region::getData(int32_t x, int32_t y, int32_t z) {
-	if(y < 0 || y > 127) return 0;
+	if(!LevelHeight::inRange(y)) return 0;
 	LevelChunk* r = this->chunks[(x >> 4) - this->minCX][(z >> 4) - this->minCZ];
 	return r->getData(x & 0xf, y, z & 0xf); //no epik nullptr check
 }
diff --git a/modifiedeight-newadditions/impl/level/chunk/LevelChunk.cpp b/modifiedeight-newadditions/impl/level/chunk/LevelChunk.cpp
index b0599e9e..98d81409 100644
--- a/modifiedeight-newadditions/impl/level/chunk/LevelChunk.cpp
+++ b/modifiedeight-newadditions/impl/level/chunk/LevelChunk.cpp
@@ -13,25 +13,33 @@
 
 bool_t LevelChunk::touchedSky = 0;
 
+/*
+ * Every size and every index in here comes from LevelHeight rather than a
+ * constant: 32768 tiles indexed y | (x << 11) | (z << 7) for the 128 tall world
+ * the game has always had, 65536 and one bit wider for a Java session.  The second
+ * constructor adopts a column buffer somebody else built - a level generator or
+ * the region file loader - and both of those only ever exist at MCPE height.
+ */
+
 LevelChunk::LevelChunk(struct Level* a2, int32_t a3, int32_t a4)
-	: tileMeta(32768)
-	, skyLight(32768)
-	, blockLight(32768) {
+	: tileMeta(LevelHeight::tiles)
+	, skyLight(LevelHeight::tiles)
+	, blockLight(LevelHeight::tiles) {
 	this->level = a2;
-	this->field_4 = 32768;
+	this->field_4 = LevelHeight::tiles;
 	this->field_258 = 1;
 	this->chunkX = a3;
 	this->chunkZ = a4;
 	this->chunkXworld = a3 * 16;
 	this->chunkZworld = a4 * 16;
-	this->tiles = new uint8_t[0x8000];
-	memset(this->tiles, 0, 0x8000);
+	this->tiles = new uint8_t[LevelHeight::tiles];
+	memset(this->tiles, 0, LevelHeight::tiles);
 	this->init();
 }
 LevelChunk::LevelChunk(struct Level* a2, uint8_t* a3, int32_t x, int32_t z)
-	: tileMeta(32768)
-	, skyLight(32768)
-	, blockLight(32768) {
+	: tileMeta(LevelHeight::tiles)
+	, skyLight(LevelHeight::tiles)
+	, blockLight(LevelHeight::tiles) {
 	this->level = a2;
 	this->chunkX = x;
 	this->chunkZ = z;
@@ -56,6 +64,10 @@ void LevelChunk::clearUpdateMap() {
 }
 void LevelChunk::deleteBlockData() {
 	if(this->tiles) delete[] this->tiles;
+	// Callers hand the chunk to the destructor right after this, and the
+	// destructor frees `tiles` again whenever the chunk allocated it itself
+	// (field_258).  Dropping the pointer here makes the pair safe either way.
+	this->tiles = 0;
 }
 struct TileEntity* LevelChunk::getTileEntity(int32_t x, int32_t y, int32_t z) {
 	TilePos xyz{x, y, z};
@@ -133,7 +145,7 @@ void LevelChunk::recalcHeight(int32_t x, int32_t y, int32_t z) {
 
 	xzIndex = x | (16 * z);
 	hm = this->heightMap[xzIndex];
-	v8 = (x << 11) | (z << 7);
+	v8 = (x << LevelHeight::xShift) | (z << LevelHeight::zShift);
 	if(hm < y) {
 		v9 = y;
 	} else {
@@ -150,7 +162,7 @@ void LevelChunk::recalcHeight(int32_t x, int32_t y, int32_t z) {
 		this->heightMap[xzIndex] = v9;
 		if(v9 >= this->topBlockY) {
 			v16 = 0;
-			v15 = 127;
+			v15 = LevelHeight::maxY();
 			do {
 				for(i = 0; i != 16; ++i) {
 					v12 = v16 | (16 * i);
@@ -222,13 +234,13 @@ void LevelChunk::setTileEntity(int32_t x, int32_t y, int32_t z, struct TileEntit
 	}
 }
 void LevelChunk::setTileRaw(int32_t x, int32_t y, int32_t z, int32_t id) {
-	int32_t in = y | (x << 11) | (z << 7);
+	int32_t in = LevelHeight::index(x, y, z);
 	this->tiles[in] = id;
 }
 
 
 LevelChunk::~LevelChunk() {
-	if(this->field_258) delete this->tiles;
+	if(this->field_258) delete[] this->tiles;
 }
 bool_t LevelChunk::isAt(int32_t x, int32_t z) {
 	return x == this->chunkX && z == this->chunkZ;
@@ -238,18 +250,18 @@ int32_t LevelChunk::getHeightmap(int32_t x, int32_t z) {
 }
 void LevelChunk::recalcHeightmap() {
 	int32_t v2 = 0;
-	int32_t v3 = 127;
+	int32_t v3 = LevelHeight::maxY();
 	do {
 		for(int32_t i = 0; i != 16; ++i) {
-			int32_t v4 = 127;
-			int32_t v5 = (v2 << 11) | (i << 7);
+			int32_t v4 = LevelHeight::maxY();
+			int32_t v5 = (v2 << LevelHeight::xShift) | (i << LevelHeight::zShift);
 			do {
 				if(Tile::lightBlock[this->tiles[v5 - 1 + v4]]) break;
 				--v4;
 			} while(v4);
 			this->heightMap[v2 | (16 * i)] = v4;
 			if(!this->level->dimensionPtr->hasNoSkyMaybe) {
-				int32_t v8 = 127;
+				int32_t v8 = LevelHeight::maxY();
 				int32_t v6 = 15;
 				do {
 					v6 -= Tile::lightBlock[this->tiles[v8 + v5]];
@@ -274,12 +286,12 @@ void LevelChunk::recalcHeightmap() {
 }
 void LevelChunk::recalcHeightmapOnly() {
 	int32_t v1 = 0;
-	int32_t v2 = 127;
+	int32_t v2 = LevelHeight::maxY();
 	do {
 		for(int32_t i = 0; i != 16; ++i) {
-			int32_t v4 = 127;
+			int32_t v4 = LevelHeight::maxY();
 			do {
-				if(Tile::lightBlock[this->tiles[((v1 << 11) | (i << 7)) - 1 + v4]]) --v4;
+				if(Tile::lightBlock[this->tiles[((v1 << LevelHeight::xShift) | (i << LevelHeight::zShift)) - 1 + v4]]) --v4;
 			} while(v4);
 			int32_t v6 = v1 | (16 * i);
 			if(v2 >= v4) v2 = v4;
@@ -319,7 +331,7 @@ void LevelChunk::addEntity(struct Entity* a2) {
 	float v2 = a2->posY * 0.0625;
 	int32_t v5 = Mth::floor(v2);
 	if(v5 < 0) v5 = 0;
-	else if(v5 >= 7) v5 = 7;
+	else if(v5 >= CHUNK_MINIS - 1) v5 = CHUNK_MINIS - 1;
 	a2->field_FD = 1;
 	a2->field_30 = v5;
 	a2->field_2C = this->chunkX;
@@ -331,7 +343,7 @@ void LevelChunk::removeEntity(struct Entity* a2) {
 }
 void LevelChunk::removeEntity(struct Entity* a2, int32_t a3) {
 	if(a3 < 0) a3 = 0;
-	if(a3 >= 7) a3 = 7;
+	if(a3 >= CHUNK_MINIS - 1) a3 = CHUNK_MINIS - 1;
 
 	auto e = std::find(this->miniChunkEntities[a3].begin(), this->miniChunkEntities[a3].end(), a2);
 	if(e != this->miniChunkEntities[a3].end()) {
@@ -341,9 +353,9 @@ void LevelChunk::removeEntity(struct Entity* a2, int32_t a3) {
 void LevelChunk::getEntitiesOfClass(int32_t a2, const struct AABB& a3, std::vector<struct Entity*>& a4) {
 	int32_t minChunkY = Mth::floor((a3.minY - 2) * 0.0625);
 	int32_t maxChunkY = Mth::floor((a3.maxY + 2) * 0.0625);
-	if(minChunkY > 0b111) minChunkY = 0b111; //usat(3, v);
+	if(minChunkY > CHUNK_MINIS - 1) minChunkY = CHUNK_MINIS - 1; //usat(3, v);
 	else if(minChunkY < 0) minChunkY = 0;
-	if(maxChunkY > 0b111) maxChunkY = 0b111; //usat(3, v);
+	if(maxChunkY > CHUNK_MINIS - 1) maxChunkY = CHUNK_MINIS - 1; //usat(3, v);
 	else if(minChunkY < 0) minChunkY = 0;
 
 	while(minChunkY <= maxChunkY) {
@@ -358,9 +370,9 @@ void LevelChunk::getEntitiesOfClass(int32_t a2, const struct AABB& a3, std::vect
 void LevelChunk::getEntitiesOfType(int32_t a2, const struct AABB& a3, std::vector<struct Entity*>& a4) {
 	int32_t minChunkY = Mth::floor((a3.minY - 2) * 0.0625);
 	int32_t maxChunkY = Mth::floor((a3.maxY + 2) * 0.0625);
-	if(minChunkY > 0b111) minChunkY = 0b111; //usat(3, v);
+	if(minChunkY > CHUNK_MINIS - 1) minChunkY = CHUNK_MINIS - 1; //usat(3, v);
 	else if(minChunkY < 0) minChunkY = 0;
-	if(maxChunkY > 0b111) maxChunkY = 0b111; //usat(3, v);
+	if(maxChunkY > CHUNK_MINIS - 1) maxChunkY = CHUNK_MINIS - 1; //usat(3, v);
 	else if(minChunkY < 0) minChunkY = 0;
 
 	while(minChunkY <= maxChunkY) {
@@ -400,14 +412,14 @@ int32_t LevelChunk::countEntities() {
 	do {
 		entCnt += this->miniChunkEntities[v1].size();
 		++v1;
-	} while(v1 != 8);
+	} while(v1 != CHUNK_MINIS);
 	return entCnt;
 }
 void LevelChunk::getEntities(struct Entity* a2, const struct AABB& bb, std::vector<struct Entity*>& a4) {
 	int32_t minChunkY = Mth::floor((bb.minY - 2) * 0.0625);
 	int32_t maxChunkY = Mth::floor((bb.maxY + 2) * 0.0625);
 	minChunkY = minChunkY & ~(minChunkY >> 31);
-	if(maxChunkY >= 7) maxChunkY = 7;
+	if(maxChunkY >= CHUNK_MINIS - 1) maxChunkY = CHUNK_MINIS - 1;
 
 	while(minChunkY <= maxChunkY) {
 		for(auto e: this->miniChunkEntities[minChunkY]) {
@@ -420,11 +432,11 @@ void LevelChunk::getEntities(struct Entity* a2, const struct AABB& bb, std::vect
 	}
 }
 int32_t LevelChunk::getTile(int32_t x, int32_t y, int32_t z) {
-	return this->tiles[y | (x << 11) | (z << 7)];
+	return this->tiles[LevelHeight::index(x, y, z)];
 }
 bool_t LevelChunk::setTile(int32_t x, int32_t y, int32_t z, int32_t id) {
 	int32_t v21 = x | (16 * z);
-	int32_t v10 = y | (x << 11) | (z << 7);
+	int32_t v10 = LevelHeight::index(x, y, z);
 	int32_t v22 = this->heightMap[v21];
 	int32_t oldID = this->tiles[v10];
 	if(oldID == id) return 0;
@@ -447,13 +459,13 @@ bool_t LevelChunk::setTile(int32_t x, int32_t y, int32_t z, int32_t id) {
 		if(!this->level->isClientMaybe) Tile::tiles[id]->onPlace(this->level, worldX, y, worldZ);
 	}
 	this->unsaved = 1;
-	this->updateMap[v21] |= 1 << (y >> 4);
+	if(y < MCPE_HEIGHT) this->updateMap[v21] |= 1 << (y >> 4);
 	return 1;
 }
 bool_t LevelChunk::setTileAndData(int32_t x, int32_t y, int32_t z, int32_t id, int32_t meta) {
 	int32_t v22 = x | (16 * z);
 	int32_t v23 = this->heightMap[v22];
-	int32_t v9 = y | (x << 11) | (z << 7);
+	int32_t v9 = LevelHeight::index(x, y, z);
 	int32_t oldid = this->tiles[v9];
 	if(oldid == id) {
 		int32_t m = this->tileMeta.get(x, y, z);
@@ -490,7 +502,7 @@ bool_t LevelChunk::setTileAndData(int32_t x, int32_t y, int32_t z, int32_t id, i
 		}
 	}
 	this->unsaved = 1;
-	this->updateMap[v22] |= 1 << (y >> 4);
+	if(y < MCPE_HEIGHT) this->updateMap[v22] |= 1 << (y >> 4);
 	return 1;
 }
 
@@ -505,7 +517,7 @@ bool_t LevelChunk::setData(int32_t x, int32_t y, int32_t z, int32_t d) {
 }
 void LevelChunk::setBlocks(uint8_t* data, int32_t y) {
 	for(int32_t i = 0; i != 8192; ++i) {
-		this->tiles[8192 * y + i] = data[i];
+		this->tiles[(LevelHeight::tiles / 4) * y + i] = data[i];
 	}
 	int32_t v5 = 4 * y;
 	int32_t v6 = 4 * y;
@@ -516,9 +528,9 @@ void LevelChunk::setBlocks(uint8_t* data, int32_t y) {
 		}
 		++v6;
 	}
-	this->level->updateLight(LightLayer::Sky, v5 + this->chunkXworld, 0, this->chunkZworld, v5 + this->chunkXworld + 4, 128, this->chunkZworld + 16);
-	this->level->updateLight(LightLayer::Block, v5 + this->chunkXworld, 0, this->chunkZworld, v5 + this->chunkXworld + 4, 128, this->chunkZworld + 16);
-	this->level->setTilesDirty(v5 + this->chunkXworld, 0, this->chunkZworld, v5 + this->chunkXworld + 4, 128, this->chunkZworld);
+	this->level->updateLight(LightLayer::Sky, v5 + this->chunkXworld, 0, this->chunkZworld, v5 + this->chunkXworld + 4, LevelHeight::height, this->chunkZworld + 16);
+	this->level->updateLight(LightLayer::Block, v5 + this->chunkXworld, 0, this->chunkZworld, v5 + this->chunkXworld + 4, LevelHeight::height, this->chunkZworld + 16);
+	this->level->setTilesDirty(v5 + this->chunkXworld, 0, this->chunkZworld, v5 + this->chunkXworld + 4, LevelHeight::height, this->chunkZworld);
 }
 int32_t LevelChunk::getBlocksAndData(uint8_t* a2, int32_t a3, int32_t a4, int32_t a5, int32_t a6, int32_t a7, int32_t a8, int32_t a9) {
 	int32_t v9; // r7
@@ -566,10 +578,10 @@ int32_t LevelChunk::getBlocksAndData(uint8_t* a2, int32_t a3, int32_t a4, int32_
 		if(v12 >= a6) {
 			break;
 		}
-		v18 = a4 | (v12 << 11);
+		v18 = a4 | (v12 << LevelHeight::xShift);
 		v17 = a5;
 		while(v17 < a8) {
-			v16 = v18 | (v17++ << 7);
+			v16 = v18 | (v17++ << LevelHeight::zShift);
 			v37 = v19;
 			v41 = v18;
 			memcpy(&a2[v19], &this->tiles[v16], v13);
@@ -586,10 +598,10 @@ int32_t LevelChunk::getBlocksAndData(uint8_t* a2, int32_t a3, int32_t a4, int32_
 		if(v20 >= a6) {
 			break;
 		}
-		v25 = a4 | (v20 << 11);
+		v25 = a4 | (v20 << LevelHeight::xShift);
 		v24 = a5;
 		while(v24 < a8) {
-			v23 = v25 | (v24++ << 7);
+			v23 = v25 | (v24++ << LevelHeight::zShift);
 			v38 = v26;
 			v42 = v25;
 			memcpy(&a2[v26], &this->tileMeta.data[v23 >> 1], v21);
@@ -603,10 +615,10 @@ int32_t LevelChunk::getBlocksAndData(uint8_t* a2, int32_t a3, int32_t a4, int32_
 		if(j >= a6) {
 			break;
 		}
-		v30 = a4 | (j << 11);
+		v30 = a4 | (j << LevelHeight::xShift);
 		v29 = a5;
 		while(v29 < a8) {
-			v28 = v30 | (v29++ << 7);
+			v28 = v30 | (v29++ << LevelHeight::zShift);
 			v39 = v31;
 			v43 = v30;
 			memcpy(&a2[v31], &this->blockLight.data[v28 >> 1], v21);
@@ -620,10 +632,10 @@ int32_t LevelChunk::getBlocksAndData(uint8_t* a2, int32_t a3, int32_t a4, int32_
 		if(v9 >= a6) {
 			break;
 		}
-		v34 = a4 | (v9 << 11);
+		v34 = a4 | (v9 << LevelHeight::xShift);
 		v33 = a5;
 		while(v33 < a8) {
-			v32 = v34 | (v33++ << 7);
+			v32 = v34 | (v33++ << LevelHeight::zShift);
 			v40 = v34;
 			memcpy(&a2[v35], &this->skyLight.data[v32 >> 1], v21);
 			v34 = v40;
@@ -680,10 +692,10 @@ int32_t LevelChunk::setBlocksAndData(uint8_t* a2, int32_t a3, int32_t a4, int32_
 		if(v14 >= a6) {
 			break;
 		}
-		v18 = a4 | (v14 << 11);
+		v18 = a4 | (v14 << LevelHeight::xShift);
 		v17 = a5;
 		while(v17 < a8) {
-			v16 = v18 | (v17 << 7);
+			v16 = v18 | (v17 << LevelHeight::zShift);
 			v37 = v18;
 			v41 = i;
 			++v17;
@@ -702,10 +714,10 @@ int32_t LevelChunk::setBlocksAndData(uint8_t* a2, int32_t a3, int32_t a4, int32_
 		if(j >= a6) {
 			break;
 		}
-		v25 = a4 | (j << 11);
+		v25 = a4 | (j << LevelHeight::xShift);
 		v24 = a5;
 		while(v24 < a8) {
-			v23 = v25 | (v24 << 7);
+			v23 = v25 | (v24 << LevelHeight::zShift);
 			v38 = v25;
 			++v24;
 			memcpy(&this->tileMeta.data[v23 >> 1], &a2[v26], v20);
@@ -719,10 +731,10 @@ int32_t LevelChunk::setBlocksAndData(uint8_t* a2, int32_t a3, int32_t a4, int32_
 		if(k >= a6) {
 			break;
 		}
-		v30 = a4 | (k << 11);
+		v30 = a4 | (k << LevelHeight::xShift);
 		v29 = a5;
 		while(v29 < a8) {
-			v28 = v30 | (v29 << 7);
+			v28 = v30 | (v29 << LevelHeight::zShift);
 			v39 = v30;
 			++v29;
 			memcpy(&this->blockLight.data[v28 >> 1], &a2[v31], v20);
@@ -736,10 +748,10 @@ int32_t LevelChunk::setBlocksAndData(uint8_t* a2, int32_t a3, int32_t a4, int32_
 		if(m >= a6) {
 			break;
 		}
-		v35 = a4 | (m << 11);
+		v35 = a4 | (m << LevelHeight::xShift);
 		v34 = a5;
 		while(v34 < a8) {
-			v33 = v35 | (v34 << 7);
+			v33 = v35 | (v34 << LevelHeight::zShift);
 			v40 = v35;
 			++v34;
 			memcpy(&this->skyLight.data[v33 >> 1], &a2[v36], v20);
diff --git a/modifiedeight-newadditions/impl/level/gen/NewRandomLevelSource.cpp b/modifiedeight-newadditions/impl/level/gen/NewRandomLevelSource.cpp
index c89c5a46..8f4d5158 100644
--- a/modifiedeight-newadditions/impl/level/gen/NewRandomLevelSource.cpp
+++ b/modifiedeight-newadditions/impl/level/gen/NewRandomLevelSource.cpp
@@ -1,5 +1,6 @@
 #include <level/gen/NewRandomLevelSource.hpp>
 #include <level/BiomeSource.hpp>
+#include <level/LevelHeight.hpp>
 #include <level/Level.hpp>
 #include <level/MobSpawner.hpp>
 #include <level/chunk/LevelChunk.hpp>
@@ -536,14 +537,22 @@ bool_t NewRandomLevelSource::hasChunk(int32_t x, int32_t z) {
 }
 struct LevelChunk* NewRandomLevelSource::getChunk(int32_t chunkX, int32_t chunkZ) {
 	this->random.setSeed(132899541 * chunkZ + 341872712 * chunkX);
-	uint8_t* chunkData = new uint8_t[0x8000u];
+	/*
+	 * LevelChunk indexes whatever buffer it is handed with LevelHeight::index, so
+	 * the size has to come from the same place - a fixed 0x8000 here would be a
+	 * 32K heap overflow the moment the two disagreed.  The terrain below is
+	 * written with the 128 tall layout on purpose: this generator has no taller
+	 * shape to produce, and a Java session replaces every column it is given
+	 * anyway.  Allocating for the real height just means it cannot be overrun.
+	 */
+	uint8_t* chunkData = new uint8_t[LevelHeight::tiles];
+	memset(chunkData, 0, LevelHeight::tiles);
 	LevelChunk* chunk = new LevelChunk(this->level, chunkData, chunkX, chunkZ);
 
 	if (this->level->getLevelData()->getGeneratorVersion() == 2) {
-		memset(chunkData, 0, 0x8000);
 		for (int32_t bx = 0; bx < 16; ++bx) {
 			for (int32_t bz = 0; bz < 16; ++bz) {
-				int32_t baseIdx = (bx << 11) | (bz << 7);
+				int32_t baseIdx = LevelHeight::index(bx, 0, bz);
 				chunkData[baseIdx + 0] = Tile::unbreakable->blockID;
 				chunkData[baseIdx + 1] = Tile::dirt->blockID;
 				chunkData[baseIdx + 2] = Tile::dirt->blockID;
diff --git a/modifiedeight-newadditions/impl/level/gen/PerformanceTestChunkSource.cpp b/modifiedeight-newadditions/impl/level/gen/PerformanceTestChunkSource.cpp
index 5b5bf701..8bfb8c6c 100644
--- a/modifiedeight-newadditions/impl/level/gen/PerformanceTestChunkSource.cpp
+++ b/modifiedeight-newadditions/impl/level/gen/PerformanceTestChunkSource.cpp
@@ -1,4 +1,5 @@
 #include <level/gen/PerformanceTestChunkSource.hpp>
+#include <level/LevelHeight.hpp>
 #include <level/chunk/LevelChunk.hpp>
 #include <string.h>
 
@@ -22,20 +23,22 @@ LevelChunk* PerformanceTestChunkSource::create(int32_t x, int32_t z) {
 	LevelChunk* v14; // r4
 
 	v6 = 0;
-	v7 = new uint8_t[0x8000u];
-	memset(v7, 0, 0x8000u);
+	// Sized from LevelHeight for the same reason as the real generators: the
+	// LevelChunk this is handed to indexes it with LevelHeight::index.
+	v7 = new uint8_t[LevelHeight::tiles];
+	memset(v7, 0, LevelHeight::tiles);
 	do {
 		if(v6 > 59) {
 			for(i = 0; i != 16; i += 2) {
 				for(j = 0; j != 16; j += 2) {
-					v11 = v6 | (i << 11) | (j << 7);
+					v11 = LevelHeight::index(i, v6, j);
 					v7[v11] = 3;
 				}
 			}
 		} else {
 			for(k = (v6 + 1) & 1; k <= 15; k += 2) {
 				for(m = v6 & 1; m <= 15; m += 2) {
-					v10 = v6 | (k << 11) | (m << 7);
+					v10 = LevelHeight::index(k, v6, m);
 					v7[v10] = 3;
 				}
 			}
diff --git a/modifiedeight-newadditions/impl/level/gen/RandomLevelSource.cpp b/modifiedeight-newadditions/impl/level/gen/RandomLevelSource.cpp
index b2066e39..e62a49ee 100644
--- a/modifiedeight-newadditions/impl/level/gen/RandomLevelSource.cpp
+++ b/modifiedeight-newadditions/impl/level/gen/RandomLevelSource.cpp
@@ -1,5 +1,6 @@
 #include <level/gen/RandomLevelSource.hpp>
 #include <level/BiomeSource.hpp>
+#include <level/LevelHeight.hpp>
 #include <level/Level.hpp>
 #include <level/MobSpawner.hpp>
 #include <level/chunk/LevelChunk.hpp>
@@ -530,14 +531,22 @@ bool_t RandomLevelSource::hasChunk(int32_t x, int32_t z) {
 }
 struct LevelChunk* RandomLevelSource::getChunk(int32_t chunkX, int32_t chunkZ) {
 	this->random.setSeed(132899541 * chunkZ + 341872712 * chunkX);
-	uint8_t* chunkData = new uint8_t[0x8000u];
+	/*
+	 * LevelChunk indexes whatever buffer it is handed with LevelHeight::index, so
+	 * the size has to come from the same place - a fixed 0x8000 here would be a
+	 * 32K heap overflow the moment the two disagreed.  The terrain below is
+	 * written with the 128 tall layout on purpose: this generator has no taller
+	 * shape to produce, and a Java session replaces every column it is given
+	 * anyway.  Allocating for the real height just means it cannot be overrun.
+	 */
+	uint8_t* chunkData = new uint8_t[LevelHeight::tiles];
+	memset(chunkData, 0, LevelHeight::tiles);
 	LevelChunk* chunk = new LevelChunk(this->level, chunkData, chunkX, chunkZ);
 
 	if (this->level->getLevelData()->getGeneratorVersion() == 2) {
-		memset(chunkData, 0, 0x8000);
 		for (int32_t bx = 0; bx < 16; ++bx) {
 			for (int32_t bz = 0; bz < 16; ++bz) {
-				int32_t baseIdx = (bx << 11) | (bz << 7);
+				int32_t baseIdx = LevelHeight::index(bx, 0, bz);
 				chunkData[baseIdx + 0] = Tile::unbreakable->blockID;
 				chunkData[baseIdx + 1] = Tile::dirt->blockID;
 				chunkData[baseIdx + 2] = Tile::dirt->blockID;
diff --git a/modifiedeight-newadditions/impl/level/storage/DataLayer.cpp b/modifiedeight-newadditions/impl/level/storage/DataLayer.cpp
index 90b799ff..55b92bb6 100644
--- a/modifiedeight-newadditions/impl/level/storage/DataLayer.cpp
+++ b/modifiedeight-newadditions/impl/level/storage/DataLayer.cpp
@@ -1,4 +1,5 @@
 #include <level/storage/DataLayer.hpp>
+#include <level/LevelHeight.hpp>
 #include <string.h>
 
 DataLayer::DataLayer(int32_t size){
@@ -13,14 +14,14 @@ DataLayer::~DataLayer(){
 }
 
 int32_t DataLayer::get(int32_t x, int32_t y, int32_t z){
-	int32_t index = y | (x << 11) | (z << 7);
+	int32_t index = LevelHeight::index(x, y, z);
 	uint8_t bt = this->data[index >> 1];
 	if((index & 1) != 0) return bt >> 4;
 	return bt & 0xf;
 }
 
 void DataLayer::set(int32_t x, int32_t y, int32_t z, int32_t d){
-	int32_t index = y | (x << 11) | (z << 7);
+	int32_t index = LevelHeight::index(x, y, z);
 	uint8_t bt = this->data[index >> 1];
 	uint8_t res;
 	if((index & 1) != 0) res = (bt & 0xf) | (16*d);
diff --git a/modifiedeight-newadditions/impl/level/storage/ExternalFileLevelStorage.cpp b/modifiedeight-newadditions/impl/level/storage/ExternalFileLevelStorage.cpp
index f3b1667d..1a285517 100644
--- a/modifiedeight-newadditions/impl/level/storage/ExternalFileLevelStorage.cpp
+++ b/modifiedeight-newadditions/impl/level/storage/ExternalFileLevelStorage.cpp
@@ -5,6 +5,7 @@
 #include <cpputils.hpp>
 #include <level/Level.hpp>
 #include <level/ChunkCache.hpp>
+#include <level/LevelHeight.hpp>
 #include <level/chunk/LevelChunk.hpp>
 #include <level/storage/RegionFile.hpp>
 #include <level/storage/chunk/UnsavedLevelChunk.hpp>
@@ -348,7 +349,19 @@ LevelChunk* ExternalFileLevelStorage::load(Level* a2, int32_t a3, int32_t a4) {
 		RakNet::BitStream* v22 = 0;
 		if(regionFile->readChunk(a3, a4, &v22)) {
 			v22->ResetReadPointer();
-			char* v12 = new char[0x8000];
+			/*
+			 * The region file format *is* the 128 tall column buffer, byte for
+			 * byte, so every Read length here is fixed and may never follow
+			 * LevelHeight - that is what keeps existing saves readable.  The
+			 * allocation is the one exception: LevelChunk indexes this buffer
+			 * with LevelHeight::index, so it has to be at least that big or the
+			 * chunk would run off the end of it.  The two are equal at 128,
+			 * which is the only height a world on disk ever has; the tail is
+			 * zeroed so a taller chunk reads air above the saved 128 rather
+			 * than uninitialised memory.
+			 */
+			char* v12 = new char[LevelHeight::tiles];
+			memset(v12, 0, LevelHeight::tiles);
 			v22->Read(v12, 0x8000);
 			LevelChunk* v10 = new LevelChunk(a2, (uint8_t*)v12, a3, a4);
 			v22->Read((char*)v10->tileMeta.data, 0x4000);
diff --git a/modifiedeight-newadditions/impl/network/ClientSideNetworkHandler.cpp b/modifiedeight-newadditions/impl/network/ClientSideNetworkHandler.cpp
index cccd0ca3..e2bf3bdc 100644
--- a/modifiedeight-newadditions/impl/network/ClientSideNetworkHandler.cpp
+++ b/modifiedeight-newadditions/impl/network/ClientSideNetworkHandler.cpp
@@ -1,4 +1,5 @@
 #include <network/ClientSideNetworkHandler.hpp>
+#include <level/LevelHeight.hpp>
 #include <Minecraft.hpp>
 #include <entity/Arrow.hpp>
 #include <entity/EntityFactory.hpp>
@@ -241,6 +242,8 @@ void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& a2, struct Start
 		levelSource->loadFromCache(&v14, LevelStorageSource::TempLevelId);
 	}
 
+	// An MCPE server speaks 128 tall chunks, so the level has to be one.
+	LevelHeight::set(MCPE_HEIGHT);
 	v8 = new MultiPlayerLevel(levelSource->selectLevel(LevelStorageSource::TempLevelId, 1), "temp", LevelSettings{pk->seed, pk->gamemode != 0}, 1, pk->genver, 0);
 	player = new LocalPlayer(this->minecraft, v8, this->minecraft->user, v8->dimensionPtr->id, pk->gamemode == 1);
 
@@ -487,7 +490,7 @@ void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID&, struct ChunkDat
 								}
 
 								for(int i = 0; i < 8; ++i) { //XXX inlined into 2int assign?
-									chunk->tileMeta.data[((ymc + (((index & 0xF) << 11) | (index >> 4 << 7))) >> 1) + i] = metas[i];
+									chunk->tileMeta.data[(LevelHeight::index(index & 0xF, ymc, index >> 4) >> 1) + i] = metas[i];
 								}
 							}
 							int v18 = minY;
diff --git a/modifiedeight-newadditions/impl/network/RakNetInstance.cpp b/modifiedeight-newadditions/impl/network/RakNetInstance.cpp
index cc030d80..6028cce5 100644
--- a/modifiedeight-newadditions/impl/network/RakNetInstance.cpp
+++ b/modifiedeight-newadditions/impl/network/RakNetInstance.cpp
@@ -3,6 +3,7 @@
 #include <network/MinecraftPackets.hpp>
 #include <network/NetEventCallback.hpp>
 #include <network/Packet.hpp>
+#include <java/JavaBridge.hpp>
 
 static RakNet::SystemAddress _D6E0A1B0;
 
@@ -124,6 +125,7 @@ void RakNetInstance::clearServerList() {
 	this->serverList.clear();
 }
 void RakNetInstance::disconnect() {
+	JavaBridge::shutdown();
 	if(this->rakPeerInstance->IsActive()) {
 		this->rakPeerInstance->Shutdown(500);
 	}
@@ -155,6 +157,9 @@ bool_t RakNetInstance::isMyLocalGuid(const RakNet::RakNetGUID& a2) {
 	return 0;
 }
 void RakNetInstance::runEvents(NetEventCallback* a2) {
+	// A Java session has no RakNet peer to receive from; this is simply the one
+	// place in the frame that is guaranteed to run, so it is where it ticks.
+	JavaBridge::pump();
 	while(1) {
 		RakNet::Packet* v8 = this->rakPeerInstance->Receive();
 		if(!v8) break;
@@ -221,6 +226,9 @@ void RakNetInstance::runEvents(NetEventCallback* a2) {
 	}
 }
 void RakNetInstance::send(Packet& a2) {
+	if(JavaBridge::interceptSend(&a2)) {
+		return;
+	}
 	RakNet::BitStream v14;
 	a2.write(&v14);
 	if(this->_isServer) {
@@ -232,6 +240,9 @@ void RakNetInstance::send(Packet& a2) {
 	}
 }
 void RakNetInstance::send(const RakNet::RakNetGUID& a2, Packet& a3) {
+	if(JavaBridge::interceptSend(&a3)) {
+		return;
+	}
 	RakNet::BitStream v11;
 	a3.write(&v11);
 	this->rakPeerInstance->Send(&v11, a3.packetPriorityMaybe, a3.packetReliabilityMaybe, 0, RakNet::AddressOrGUID(a2), 0, 0);
diff --git a/modifiedeight-newadditions/impl/network/packet/ChunkDataPacket.cpp b/modifiedeight-newadditions/impl/network/packet/ChunkDataPacket.cpp
index f1350b56..957b1762 100644
--- a/modifiedeight-newadditions/impl/network/packet/ChunkDataPacket.cpp
+++ b/modifiedeight-newadditions/impl/network/packet/ChunkDataPacket.cpp
@@ -1,4 +1,5 @@
 #include <network/packet/ChunkDataPacket.hpp>
+#include <level/LevelHeight.hpp>
 #include <level/chunk/LevelChunk.hpp>
 #include <network/PacketIds.h>
 #include <network/NetEventCallback.hpp>
@@ -22,7 +23,7 @@ void ChunkDataPacket::write(RakNet::BitStream* stream) {
 		if(um) {
 			for(int32_t i = 0; i != 8; ++i) {
 				if((((int32_t)um >> i) & 1) != 0) {
-					int32_t index = (((v4 & 0xF) << 11) | (v4 >> 4 << 7)) + 16 * i;
+					int32_t index = LevelHeight::index(v4 & 0xF, 16 * i, v4 >> 4);
 					this->stream.Write((char*)&this->chunk->tiles[index], 0x10u);
 					this->stream.Write((char*)&this->chunk->tileMeta.data[index >> 1], 0x8u);
 				}
diff --git a/modifiedeight-newadditions/impl/rendering/ItemInHandRenderer.cpp b/modifiedeight-newadditions/impl/rendering/ItemInHandRenderer.cpp
index cf6c7328..6e658ad7 100644
--- a/modifiedeight-newadditions/impl/rendering/ItemInHandRenderer.cpp
+++ b/modifiedeight-newadditions/impl/rendering/ItemInHandRenderer.cpp
@@ -29,8 +29,13 @@ ItemInHandRenderer::ItemInHandRenderer(struct Minecraft* a2)
 int32_t ItemInHandRenderer::_getFrameID(struct Mob* a2, ItemInstance* a3) {
 	int32_t v7 = (a3->getId() | (((uint16_t)a3->getAuxValue()) << 12));
 	if(a2) {
-		v7 |= a2->getEntityTypeId() << 16;					 //byte2
-		v7 |= a3->itemClass->getAnimationFrameFor(a2) << 24; //hibyte
+		v7 |= a2->getEntityTypeId() << 16; //byte2
+		// A stack the id table could not represent has neither an item nor a
+		// tile behind it and still reports itself valid, which is how id 0 is
+		// spelled.  Frame 0 for it, rather than a null dereference.
+		if(a3->itemClass) {
+			v7 |= a3->itemClass->getAnimationFrameFor(a2) << 24; //hibyte
+		}
 	}
 	return v7;
 }
@@ -62,24 +67,24 @@ RenderCall* ItemInHandRenderer::rebuildItem(struct Mob* a2, ItemInstance& a3) {
 			if(v24 != 1) {
 				if(!a3.tileClass->goodGraphics) {
 					v7->field_31 = 0;
-					v7->field_32 = a3.itemClass->isEmissive(a3.getAuxValue());
+					v7->field_32 = a3.itemClass ? a3.itemClass->isEmissive(a3.getAuxValue()) : 0;
 					return v7;
 				}
 				if(v24 != 3) {
 					v7->field_31 = 0;
-					v7->field_32 = a3.itemClass->isEmissive(a3.getAuxValue());
+					v7->field_32 = a3.itemClass ? a3.itemClass->isEmissive(a3.getAuxValue()) : 0;
 					return v7;
 				}
 			}
 			v7->field_31 = 1;
-			v7->field_32 = a3.itemClass->isEmissive(a3.getAuxValue());
+			v7->field_32 = a3.itemClass ? a3.itemClass->isEmissive(a3.getAuxValue()) : 0;
 			return v7;
 		}
 	}
 	int v25 = a3.getId();
 	v7->field_30 = 1;
 	v7->field_0 = v25;
-	if(a3.tileClass) {
+	if(a3.tileClass || !a3.itemClass) {
 		v7->field_2C = "terrain-atlas.tga";
 	} else {
 		v7->field_2C = a3.itemClass->itemTexture;
@@ -282,7 +287,7 @@ void ItemInHandRenderer::render(float a2) {
 	glRotatef(50.0, 0.0, 1.0, 0.0);
 	glRotatef(335.0, 0.0, 0.0, 1.0);
 LABEL_22:
-	if(this->field_4.itemClass->isMirroredArt()) {
+	if(this->field_4.itemClass && this->field_4.itemClass->isMirroredArt()) {
 		glRotatef(180.0, 0.0, 1.0, 0.0);
 	}
 	if(this->minecraft->options.viewBobbing) {
diff --git a/modifiedeight-newadditions/impl/rendering/LevelRenderer.cpp b/modifiedeight-newadditions/impl/rendering/LevelRenderer.cpp
index b99958da..39c0dd30 100644
--- a/modifiedeight-newadditions/impl/rendering/LevelRenderer.cpp
+++ b/modifiedeight-newadditions/impl/rendering/LevelRenderer.cpp
@@ -1,4 +1,5 @@
 #include <rendering/LevelRenderer.hpp>
+#include <level/LevelHeight.hpp>
 #include <unigl.h>
 #include <Minecraft.hpp>
 #include <algorithm>
@@ -1385,14 +1386,15 @@ void LevelRenderer::allChanged() {
 			v7 = (int)(float)((float)v7 * 0.8);
 		}
 	}
-	this->renderYsize = 8;
+	// One render chunk per 16 blocks of world height.
+	this->renderYsize = LevelHeight::height >> 4;
 	x = 0;
 	v9 = 0;
 	v10 = 0;
 	v11 = v7 / 16 + 1;
 	this->renderXsize = v11;
 	this->renderZSize = v11;
-	v12 = v11 * 8 * v11;
+	v12 = v11 * this->renderYsize * v11;
 	this->chunksToRenderSize = v12;
 	v13 = new RenderChunk*[v12];
 	renderXsize = this->renderXsize;
diff --git a/modifiedeight-newadditions/impl/rendering/entity/HumanoidMobRenderer.cpp b/modifiedeight-newadditions/impl/rendering/entity/HumanoidMobRenderer.cpp
index d5a364f5..25695fdb 100644
--- a/modifiedeight-newadditions/impl/rendering/entity/HumanoidMobRenderer.cpp
+++ b/modifiedeight-newadditions/impl/rendering/entity/HumanoidMobRenderer.cpp
@@ -62,7 +62,10 @@ void HumanoidMobRenderer::additionalRendering(Mob* a2, float a3) {
 			glScalef(0.625, 0.625, 0.625);
 			v10 = -100.0;
 		} else {
-			if(!v6->itemClass->isHandEquipped()) {
+			// itemClass is null for a stack whose id nothing local could
+			// represent - id 0 still calls itself valid - and a remote player
+			// may well be holding one of those on a Java server.
+			if(!v6->itemClass || !v6->itemClass->isHandEquipped()) {
 				glTranslatef(0.25, 0.1875, -0.1875);
 				glScalef(0.375, 0.375, 0.375);
 				glRotatef(60.0, 0.0, 0.0, 1.0);
diff --git a/modifiedeight-newadditions/impl/rendering/entity/ItemRenderer.cpp b/modifiedeight-newadditions/impl/rendering/entity/ItemRenderer.cpp
index ec215dbf..901fd0c3 100644
--- a/modifiedeight-newadditions/impl/rendering/entity/ItemRenderer.cpp
+++ b/modifiedeight-newadditions/impl/rendering/entity/ItemRenderer.cpp
@@ -516,8 +516,17 @@ void ItemRenderer::render(Entity* e_, float x, float y, float z, float a6, float
 		}
 		if(tileClass) {
 			this->bindTexture("terrain-atlas.tga");
-		} else {
+		} else if(e->itemInstance.itemClass) {
 			this->bindTexture(e->itemInstance.itemClass->itemTexture);
+		} else {
+			/*
+			 * ItemInstance calls id 0 valid - that is how an empty slot is
+			 * spelled - so a stack whose id no server-side translation could
+			 * represent arrives here with a count, no tile and no item, and
+			 * itemClass->itemTexture is a null dereference on the first frame it
+			 * is on screen.  Draw it against the atlas rather than going down.
+			 */
+			this->bindTexture("terrain-atlas.tga");
 		}
 		glEnable(0xBC0u);
 		glScalef(0.5, 0.5, 0.5);
diff --git a/modifiedeight-newadditions/impl/rendering/entity/PaintingRenderer.cpp b/modifiedeight-newadditions/impl/rendering/entity/PaintingRenderer.cpp
index 4cf38672..3654e474 100644
--- a/modifiedeight-newadditions/impl/rendering/entity/PaintingRenderer.cpp
+++ b/modifiedeight-newadditions/impl/rendering/entity/PaintingRenderer.cpp
@@ -84,6 +84,7 @@ MeshBuffer PaintingRenderer::_buildPainting(int32_t a2, int32_t a3, int32_t a4,
 	return Tesselator::instance.end();
 }
 MeshBuffer* PaintingRenderer::_getMesh(const Motive* a2) {
+	if(!a2) a2 = Motive::DefaultImage;
 	auto&& p = this->motives.find(a2);
 	if(p != this->motives.end()) {
 		return &p->second;
@@ -99,6 +100,7 @@ void PaintingRenderer::render(Entity* e_, float x, float y, float z, float angle
 	MeshBuffer* mesh; // r6
 
 	mesh = this->_getMesh(e->motive);
+	if(!mesh) return;
 	e->setupLighting(this->isFancy(), a7);
 	glPushMatrix();
 	glTranslatef(x, y, z);
diff --git a/modifiedeight-newadditions/impl/rendering/entity/PlayerRenderer.cpp b/modifiedeight-newadditions/impl/rendering/entity/PlayerRenderer.cpp
index e9502041..7a764c59 100644
--- a/modifiedeight-newadditions/impl/rendering/entity/PlayerRenderer.cpp
+++ b/modifiedeight-newadditions/impl/rendering/entity/PlayerRenderer.cpp
@@ -1,3 +1,4 @@
+#include <level/LevelHeight.hpp>
 #include <entity/Player.hpp>
 #include <item/ArmorItem.hpp>
 #include <level/Level.hpp>
@@ -32,7 +33,7 @@ static bool isPlayerSwimming(Player *p) {
     int pz = (int)floorf(p->posZ);
     for (float yo = -0.5f; yo <= 1.4f; yo += 0.35f) {
       int py = (int)floorf(p->posY + yo);
-      if (py >= 0 && py < 128) {
+      if (LevelHeight::inRange(py)) {
         int tile = p->level->getTile(px, py, pz);
         Material *mat = p->level->getMaterial(px, py, pz);
         if (tile == Tile::water->blockID || tile == Tile::calmWater->blockID ||
diff --git a/modifiedeight-newadditions/impl/rendering/model/HumanoidModel.cpp b/modifiedeight-newadditions/impl/rendering/model/HumanoidModel.cpp
index b4ad251a..1d879bd2 100644
--- a/modifiedeight-newadditions/impl/rendering/model/HumanoidModel.cpp
+++ b/modifiedeight-newadditions/impl/rendering/model/HumanoidModel.cpp
@@ -1,3 +1,4 @@
+#include <level/LevelHeight.hpp>
 #include <rendering/model/HumanoidModel.hpp>
 #include <entity/Entity.hpp>
 #include <entity/Mob.hpp>
@@ -68,7 +69,7 @@ void HumanoidModel::render(Entity* a2, float a3, float a4, float a5, float a6, f
 				int pz = (int)floorf(m->posZ);
 				for (float yo = -0.5f; yo <= 1.4f; yo += 0.35f) {
 					int py = (int)floorf(m->posY + yo);
-					if (py >= 0 && py < 128) {
+					if (LevelHeight::inRange(py)) {
 						Material* mat = m->level->getMaterial(px, py, pz);
 						int tile = m->level->getTile(px, py, pz);
 						if ((mat && mat == Material::water) || tile == Tile::water->blockID || tile == Tile::calmWater->blockID || (Tile::seagrass && tile == Tile::seagrass->blockID)) {
diff --git a/modifiedeight-newadditions/impl/tile/ChestTile.cpp b/modifiedeight-newadditions/impl/tile/ChestTile.cpp
index 52bb85bd..c26448ef 100644
--- a/modifiedeight-newadditions/impl/tile/ChestTile.cpp
+++ b/modifiedeight-newadditions/impl/tile/ChestTile.cpp
@@ -98,7 +98,9 @@ void ChestTile::onRemove(Level* level, int32_t x, int32_t y, int32_t z) {
 }
 bool_t ChestTile::use(Level* level, int32_t x, int32_t y, int32_t z, Player* player) {
 	TileEntity* te = level->getTileEntity(x, y, z);
-	if(te->isType(2)) {
+	// Null when the block is no longer a chest - the server can replace it
+	// between the click and this call - and every other use() here checks.
+	if(te && te->isType(2)) {
 		if(!level->isClientMaybe) {
 			if(((ChestTileEntity*)te)->canOpen()) {
 				((ChestTileEntity*)te)->openBy(player);
diff --git a/modifiedeight-newadditions/impl/tile/ReedTile.cpp b/modifiedeight-newadditions/impl/tile/ReedTile.cpp
index 19f1d52e..a3656494 100644
--- a/modifiedeight-newadditions/impl/tile/ReedTile.cpp
+++ b/modifiedeight-newadditions/impl/tile/ReedTile.cpp
@@ -1,3 +1,4 @@
+#include <level/LevelHeight.hpp>
 #include <tile/ReedTile.hpp>
 #include <item/Item.hpp>
 #include <level/Level.hpp>
@@ -24,7 +25,7 @@ bool_t ReedTile::onFertilized(Level* level, int32_t x, int32_t y, int32_t z) {
 	while(v5 > 0 && level->getTile(x, v5, z) == this->blockID) {
 		--v5;
 	}
-	while(v6 <= 127 && level->getTile(x, v6, z) == this->blockID) {
+	while(v6 <= LevelHeight::maxY() && level->getTile(x, v6, z) == this->blockID) {
 		++v6;
 	}
 	v11 = v5 - (v6 - 1) + 3;
diff --git a/modifiedeight-newadditions/impl/tile/SeagrassTile.cpp b/modifiedeight-newadditions/impl/tile/SeagrassTile.cpp
index dbb60042..cc95634b 100644
--- a/modifiedeight-newadditions/impl/tile/SeagrassTile.cpp
+++ b/modifiedeight-newadditions/impl/tile/SeagrassTile.cpp
@@ -1,4 +1,5 @@
 #include <tile/SeagrassTile.hpp>
+#include <level/LevelHeight.hpp>
 #include <level/Level.hpp>
 #include <level/LevelSource.hpp>
 #include <tile/material/Material.hpp>
@@ -41,7 +42,7 @@ TextureUVCoordinateSet* SeagrassTile::getCarriedTexture(int32_t a2, int32_t a3)
 }
 
 bool_t SeagrassTile::canSurvive(Level* level, int32_t x, int32_t y, int32_t z) {
-	if (!level || y <= 0 || y >= 127) return 0;
+	if (!level || y <= 0 || y >= LevelHeight::maxY()) return 0;
 	int32_t belowTile = level->getTile(x, y - 1, z);
 	if (belowTile == this->blockID) {
 		return 1;
@@ -57,7 +58,7 @@ bool_t SeagrassTile::canSurvive(Level* level, int32_t x, int32_t y, int32_t z) {
 }
 
 bool_t SeagrassTile::mayPlace(Level* level, int32_t x, int32_t y, int32_t z) {
-	if (!level || y <= 0 || y >= 127) return 0;
+	if (!level || y <= 0 || y >= LevelHeight::maxY()) return 0;
 	int32_t currentTile = level->getTile(x, y, z);
 	Material* curMat = level->getMaterial(x, y, z);
 	if (currentTile != Tile::water->blockID && currentTile != Tile::calmWater->blockID && (!curMat || curMat != Material::water)) {
diff --git a/modifiedeight-newadditions/impl/tile/SpongeTile.cpp b/modifiedeight-newadditions/impl/tile/SpongeTile.cpp
index 35466b1b..fd73ad67 100644
--- a/modifiedeight-newadditions/impl/tile/SpongeTile.cpp
+++ b/modifiedeight-newadditions/impl/tile/SpongeTile.cpp
@@ -1,3 +1,4 @@
+#include <level/LevelHeight.hpp>
 #include <tile/SpongeTile.hpp>
 #include <tile/material/Material.hpp>
 #include <level/Level.hpp>
@@ -23,7 +24,7 @@ void SpongeTile::_absorbWater(Level* level, int32_t x, int32_t y, int32_t z) {
 					int32_t tx = x + dx;
 					int32_t ty = y + dy;
 					int32_t tz = z + dz;
-					if (ty >= 0 && ty < 128) {
+					if (LevelHeight::inRange(ty)) {
 						if (level->getMaterial(tx, ty, tz) == Material::water) {
 							level->setTileAndData(tx, ty, tz, 0, 0, 3);
 						}
diff --git a/modifiedeight-newadditions/impl/tile/Tile.cpp b/modifiedeight-newadditions/impl/tile/Tile.cpp
index a7c93b81..3427ee59 100644
--- a/modifiedeight-newadditions/impl/tile/Tile.cpp
+++ b/modifiedeight-newadditions/impl/tile/Tile.cpp
@@ -1,5 +1,16 @@
-#include <I18n.hpp>
+#include <tile/Tile.hpp>
 #include <cstdio>
+#include <I18n.hpp>
+#include <level/LevelHeight.hpp>
+#include <tile/BlockColorRegistry.hpp>
+#include <tile/LeverTile.hpp>
+#include <tile/RedstoneLampTile.hpp>
+#include <tile/MixedSlabTile.hpp>
+#include <tile/DoublePlantTile.hpp>
+#include <tile/WaterLilyTile.hpp>
+#include <tile/SeagrassTile.hpp>
+#include <tile/SpongeTile.hpp>
+#include <item/DoublePlantTileItem.hpp>
 #include <entity/ItemEntity.hpp>
 #include <entity/Player.hpp>
 #include <item/ClothTileItem.hpp>
@@ -1871,98 +1882,98 @@ int32_t Tile::transformToValidBlockId(int32_t oldid, int32_t x, int32_t y,
 }
 Tile::~Tile() {}
 
-int32_t Tile::getTileType() { return 0; }
-bool_t Tile::onFertilized(Level *, int32_t, int32_t, int32_t) { return 0; }
-bool_t Tile::isCubeShaped() { return 1; }
-int32_t Tile::getRenderShape() { return 0; }
-Tile *Tile::setShape(float a2, float a3, float a4, float a5, float a6,
-                     float a7) {
-  this->minZ = a4;
-  this->minX = a2;
-  this->minY = a3;
-  this->maxX = a5;
-  this->maxY = a6;
-  this->maxZ = a7;
-  return this;
+int32_t Tile::getTileType() {
+	return 0;
 }
-void Tile::updateShape(LevelSource *, int32_t, int32_t, int32_t) {}
-void Tile::updateDefaultShape(void) {}
-void Tile::addLights(Level *, int32_t, int32_t, int32_t) {}
-float Tile::getBrightness(LevelSource *level, int32_t x, int32_t y, int32_t z) {
-  return level->getBrightness(x, y, z);
+bool_t Tile::onFertilized(Level*, int32_t, int32_t, int32_t) {
+	return 0;
 }
-bool_t Tile::shouldRenderFace(LevelSource *level, int32_t x, int32_t y,
-                              int32_t z, int32_t face) {
-  if (y < 0 || y > 127)
-    return 1;
-  if (face == 0) {
-    if (this->minY > 0)
-      return 1;
-  } else if (face == 1) {
-    if (this->maxY < 1)
-      return 1;
-  } else if (face == 2) {
-    if (this->minZ > 0)
-      return 1;
-  } else if (face == 3) {
-    if (this->maxZ < 1)
-      return 1;
-  } else if (face == 4) {
-    if (this->minX > 0)
-      return 1;
-  } else if (face == 5) {
-    if (this->maxX < 1)
-      return 1;
-  }
-  Tile *tile = Tile::tiles[level->getTile(x, y, z)];
-  if (tile) {
-    if (face != 1 || tile->blockID != Tile::topSnow->blockID) {
-      return !tile->isSolidRender();
-    }
-    return 0;
-  }
-  return 1;
+bool_t Tile::isCubeShaped() {
+	return 1;
 }
-TextureUVCoordinateSet *Tile::getTexture(int32_t) { return &this->textureUV; }
-TextureUVCoordinateSet *Tile::getTexture(int32_t a2, int32_t a3) {
-  return this->getTexture(a2);
+int32_t Tile::getRenderShape() {
+	return 0;
 }
-TextureUVCoordinateSet *Tile::getTexture(LevelSource *level, int32_t x,
-                                         int32_t y, int32_t z, int32_t a6) {
-  int32_t meta = level->getData(x, y, z);
-  return this->getTexture(a6, meta);
+Tile* Tile::setShape(float a2, float a3, float a4, float a5, float a6, float a7) {
+	this->minZ = a4;
+	this->minX = a2;
+	this->minY = a3;
+	this->maxX = a5;
+	this->maxY = a6;
+	this->maxZ = a7;
+	return this;
 }
-TextureUVCoordinateSet *Tile::getCarriedTexture(int32_t a2, int32_t a3) {
-  return this->getTexture(a2, a3);
+void Tile::updateShape(LevelSource*, int32_t, int32_t, int32_t) {
 }
-AABB *Tile::getAABB(Level *level, int32_t x, int32_t y, int32_t z) {
-  this->aabb.minX = x + this->minX;
-  this->aabb.minY = y + this->minY;
-  this->aabb.minZ = z + this->minZ;
-  this->aabb.maxX = x + this->maxX;
-  this->aabb.maxY = y + this->maxY;
-  this->aabb.maxZ = z + this->maxZ;
-  return &this->aabb;
+void Tile::updateDefaultShape(void) {
 }
-void Tile::addAABBs(Level *level, int32_t x, int32_t y, int32_t z,
-                    const AABB *entBB, std::vector<AABB> &vec) {
-  AABB *bb = this->getAABB(level, x, y, z);
-  if (bb) {
-    if (bb->maxX > entBB->minX && bb->minX < entBB->maxX &&
-        bb->maxY > entBB->minY && bb->minY < entBB->maxY &&
-        bb->maxZ > entBB->minZ && bb->minZ < entBB->maxZ) {
-      vec.emplace_back(*bb);
-    }
-  }
+void Tile::addLights(Level*, int32_t, int32_t, int32_t) {
+}
+float Tile::getBrightness(LevelSource* level, int32_t x, int32_t y, int32_t z) {
+	return level->getBrightness(x, y, z);
+}
+bool_t Tile::shouldRenderFace(LevelSource* level, int32_t x, int32_t y, int32_t z, int32_t face) {
+	if(!LevelHeight::inRange(y)) return 0;
+	if(face == 0) {
+		if(this->minY > 0) return 1;
+	} else if(face == 1) {
+		if(this->maxY < 1) return 1;
+	} else if(face == 2) {
+		if(this->minZ > 0) return 1;
+	} else if(face == 3) {
+		if(this->maxZ < 1) return 1;
+	} else if(face == 4) {
+		if(this->minX > 0) return 1;
+	} else if(face == 5) {
+		if(this->maxX < 1) return 1;
+	}
+	Tile* tile = Tile::tiles[level->getTile(x, y, z)];
+	if(tile) {
+		if(face != 1 || tile->blockID != Tile::topSnow->blockID) {
+			return !tile->isSolidRender();
+		}
+		return 0;
+	}
+	return 1;
+}
+TextureUVCoordinateSet* Tile::getTexture(int32_t) {
+	return &this->textureUV;
+}
+TextureUVCoordinateSet* Tile::getTexture(int32_t a2, int32_t a3) {
+	return this->getTexture(a2);
+}
+TextureUVCoordinateSet* Tile::getTexture(LevelSource* level, int32_t x, int32_t y, int32_t z, int32_t a6) {
+	int32_t meta = level->getData(x, y, z);
+	return this->getTexture(a6, meta);
+}
+TextureUVCoordinateSet* Tile::getCarriedTexture(int32_t a2, int32_t a3) {
+	return this->getTexture(a2, a3);
+}
+AABB* Tile::getAABB(Level* level, int32_t x, int32_t y, int32_t z) {
+	this->aabb.minX = x + this->minX;
+	this->aabb.minY = y + this->minY;
+	this->aabb.minZ = z + this->minZ;
+	this->aabb.maxX = x + this->maxX;
+	this->aabb.maxY = y + this->maxY;
+	this->aabb.maxZ = z + this->maxZ;
+	return &this->aabb;
+}
+void Tile::addAABBs(Level* level, int32_t x, int32_t y, int32_t z, const AABB* entBB, std::vector<AABB>& vec) {
+	AABB* bb = this->getAABB(level, x, y, z);
+	if(bb) {
+		if(bb->maxX > entBB->minX && bb->minX < entBB->maxX && bb->maxY > entBB->minY && bb->minY < entBB->maxY && bb->maxZ > entBB->minZ && bb->minZ < entBB->maxZ) {
+			vec.emplace_back(*bb);
+		}
+	}
 }
-AABB Tile::getTileAABB(Level *level, int32_t x, int32_t y, int32_t z) {
-  AABB ret;
-  ret.minX = x + this->minX;
-  ret.minY = y + this->minY;
-  ret.minZ = z + this->minZ;
-  ret.maxX = x + this->maxX;
-  ret.maxY = y + this->maxY;
-  ret.maxZ = z + this->maxZ;
+AABB Tile::getTileAABB(Level* level, int32_t x, int32_t y, int32_t z) {
+	AABB ret;
+	ret.minX = x + this->minX;
+	ret.minY = y + this->minY;
+	ret.minZ = z + this->minZ;
+	ret.maxX = x + this->maxX;
+	ret.maxY = y + this->maxY;
+	ret.maxZ = z + this->maxZ;
 
   return ret;
 }
diff --git a/modifiedeight-newadditions/impl/tile/WaterLilyTile.cpp b/modifiedeight-newadditions/impl/tile/WaterLilyTile.cpp
index 2f72b0ca..85394984 100644
--- a/modifiedeight-newadditions/impl/tile/WaterLilyTile.cpp
+++ b/modifiedeight-newadditions/impl/tile/WaterLilyTile.cpp
@@ -1,4 +1,5 @@
 #include <tile/WaterLilyTile.hpp>
+#include <level/LevelHeight.hpp>
 #include <tile/material/Material.hpp>
 #include <level/Level.hpp>
 #include <level/LevelSource.hpp>
@@ -40,14 +41,14 @@ bool_t WaterLilyTile::isCubeShaped() {
 }
 
 bool_t WaterLilyTile::canSurvive(Level* level, int32_t x, int32_t y, int32_t z) {
-	if (y <= 0 || y >= 128) return 0;
+	if (y <= 0 || y >= LevelHeight::height) return 0;
 	int32_t belowTile = level->getTile(x, y - 1, z);
 	Material* belowMat = level->getMaterial(x, y - 1, z);
 	return (belowTile == Tile::water->blockID || belowTile == Tile::calmWater->blockID || (belowMat && belowMat == Material::water));
 }
 
 bool_t WaterLilyTile::mayPlace(Level* level, int32_t x, int32_t y, int32_t z) {
-	if (y <= 0 || y >= 128) return 0;
+	if (y <= 0 || y >= LevelHeight::height) return 0;
 	int32_t cur = level->getTile(x, y, z);
 	if (cur != 0) return 0;
 	return this->canSurvive(level, x, y, z);