initial commit

1 files changed, 1930 insertions, 0 deletions

diff --git a/src/Protocol.c b/src/Protocol.c
new file mode 100644
index 0000000..fb81993
--- /dev/null
+++ b/src/Protocol.c
@@ -0,0 +1,1930 @@
+#include "Protocol.h"
+#include "Game.h"
+#ifdef CC_BUILD_NETWORKING
+#include "String.h"
+#include "Deflate.h"
+#include "Server.h"
+#include "Stream.h"
+#include "Entity.h"
+#include "Platform.h"
+#include "Screens.h"
+#include "World.h"
+#include "Event.h"
+#include "ExtMath.h"
+#include "SelectionBox.h"
+#include "Chat.h"
+#include "Inventory.h"
+#include "Block.h"
+#include "Model.h"
+#include "Funcs.h"
+#include "Lighting.h"
+#include "Http.h"
+#include "Drawer2D.h"
+#include "Logger.h"
+#include "TexturePack.h"
+#include "Gui.h"
+#include "Errors.h"
+#include "Camera.h"
+#include "Window.h"
+#include "Particle.h"
+#include "Picking.h"
+#include "Input.h"
+#include "Utils.h"
+
+struct _ProtocolData Protocol;
+
+/* Classic state */
+static cc_bool classic_receivedFirstPos;
+
+/* Map state */
+static cc_bool map_begunLoading;
+static cc_uint64 map_receiveBeg;
+static struct Stream map_part;
+static int map_volume;
+
+/*########################################################################################################################*
+*-----------------------------------------------------CPE extensions------------------------------------------------------*
+*#########################################################################################################################*/
+struct CpeExt {
+	const char* name;
+	cc_uint8 clientVersion, serverVersion;
+};
+cc_bool cpe_needD3Fix;
+static int cpe_serverExtensionsCount, cpe_pingTicks;
+
+static struct CpeExt 
+	clickDist_Ext       = { "ClickDistance", 1 },
+	customBlocks_Ext    = { "CustomBlocks", 1 },
+	heldBlock_Ext       = { "HeldBlock", 1 },  
+	emoteFix_Ext        = { "EmoteFix", 1 },
+	textHotKey_Ext      = { "TextHotKey", 1 },  
+	extPlayerList_Ext   = { "ExtPlayerList", 2 },
+	envColors_Ext       = { "EnvColors", 1 },
+	selectionCuboid_Ext = { "SelectionCuboid", 1 },
+	blockPerms_Ext      = { "BlockPermissions", 1 },
+	changeModel_Ext     = { "ChangeModel", 2 },
+	mapAppearance_Ext   = { "EnvMapAppearance", 2 },
+	weatherType_Ext     = { "EnvWeatherType", 1 },
+	messageTypes_Ext    = { "MessageTypes", 1 },
+	hackControl_Ext     = { "HackControl", 1 },
+	playerClick_Ext     = { "PlayerClick", 1 },
+	fullCP437_Ext       = { "FullCP437", 1 },
+	longerMessages_Ext  = { "LongerMessages", 1 },
+	blockDefs_Ext       = { "BlockDefinitions", 1 },
+	blockDefsExt_Ext    = { "BlockDefinitionsExt", 2 },
+	bulkBlockUpdate_Ext = { "BulkBlockUpdate", 1 },
+	textColors_Ext      = { "TextColors", 1 },
+	envMapAspect_Ext    = { "EnvMapAspect", 2 },
+	entityProperty_Ext  = { "EntityProperty", 1 },
+	extEntityPos_Ext    = { "ExtEntityPositions", 1 },
+	twoWayPing_Ext      = { "TwoWayPing", 1 },
+	invOrder_Ext        = { "InventoryOrder", 1 },
+	instantMOTD_Ext     = { "InstantMOTD", 1 },
+	fastMap_Ext         = { "FastMap", 1 },
+	setHotbar_Ext       = { "SetHotbar", 1 },
+	setSpawnpoint_Ext   = { "SetSpawnpoint", 1 },
+	velControl_Ext      = { "VelocityControl", 1 },
+	customParticles_Ext = { "CustomParticles", 1 },
+	customModels_Ext    = { "CustomModels", 2 },
+	pluginMessages_Ext  = { "PluginMessages", 1 },
+	extTeleport_Ext     = { "ExtEntityTeleport", 1 },
+	lightingMode_Ext    = { "LightingMode", 1 },
+	extTextures_Ext     = { "ExtendedTextures", 1 },
+	extBlocks_Ext       = { "ExtendedBlocks", 1 };
+
+static struct CpeExt* cpe_clientExtensions[] = {
+	&clickDist_Ext, &customBlocks_Ext, &heldBlock_Ext, &emoteFix_Ext, &textHotKey_Ext, &extPlayerList_Ext,
+	&envColors_Ext, &selectionCuboid_Ext, &blockPerms_Ext, &changeModel_Ext, &mapAppearance_Ext, &weatherType_Ext,
+	&messageTypes_Ext, &hackControl_Ext, &playerClick_Ext, &fullCP437_Ext, &longerMessages_Ext, &blockDefs_Ext,
+	&blockDefsExt_Ext, &bulkBlockUpdate_Ext, &textColors_Ext, &envMapAspect_Ext, &entityProperty_Ext, &extEntityPos_Ext,
+	&twoWayPing_Ext, &invOrder_Ext, &instantMOTD_Ext, &fastMap_Ext, &setHotbar_Ext, &setSpawnpoint_Ext, &velControl_Ext,
+	&customParticles_Ext, &pluginMessages_Ext, &extTeleport_Ext, &lightingMode_Ext,
+#ifdef CUSTOM_MODELS
+	&customModels_Ext,
+#endif
+#ifdef EXTENDED_TEXTURES
+	&extTextures_Ext,
+#endif
+#ifdef EXTENDED_BLOCKS
+	&extBlocks_Ext,
+#endif
+}; 
+#define IsSupported(ext) (ext.serverVersion > 0)
+
+
+/*########################################################################################################################*
+*-----------------------------------------------------Common handlers-----------------------------------------------------*
+*#########################################################################################################################*/
+
+#ifndef EXTENDED_BLOCKS
+#define ReadBlock(data, value) value = *data++;
+#else
+#define ReadBlock(data, value)\
+if (IsSupported(extBlocks_Ext)) {\
+	value = Stream_GetU16_BE(data) % BLOCK_COUNT; data += 2;\
+} else { value = *data++; }
+#endif
+
+#ifndef EXTENDED_BLOCKS
+#define WriteBlock(data, value) *data++ = value;
+#else
+#define WriteBlock(data, value)\
+if (IsSupported(extBlocks_Ext)) {\
+	Stream_SetU16_BE(data, value); data += 2;\
+} else { *data++ = (BlockRaw)value; }
+#endif
+
+static cc_string UNSAFE_GetString(cc_uint8* data) {
+	int i, length = 0;
+	for (i = STRING_SIZE - 1; i >= 0; i--) {
+		char code = data[i];
+		if (code == '\0' || code == ' ') continue;
+		length = i + 1; break;
+	}
+	return String_Init((char*)data, length, STRING_SIZE);
+}
+
+static float GetFloat(cc_uint8* data) {
+	union IntAndFloat raw;
+	raw.u = Stream_GetU32_BE(data);
+	return raw.f;
+}
+
+static void ReadString(cc_uint8** ptr, cc_string* str) {
+	int i, length = 0;
+	cc_uint8* data = *ptr;
+	for (i = STRING_SIZE - 1; i >= 0; i--) {
+		char code = data[i];
+		if (code == '\0' || code == ' ') continue;
+		length = i + 1; break;
+	}
+
+	String_AppendAll(str, data, length);
+	*ptr = data + STRING_SIZE;
+}
+
+static void WriteString(cc_uint8* data, const cc_string* value) {
+	int i, count = min(value->length, STRING_SIZE);
+	for (i = 0; i < count; i++) {
+		char c = value->buffer[i];
+		if (c == '&') c = '%'; /* escape color codes */
+		data[i] = c;
+	}
+
+	for (; i < STRING_SIZE; i++) { data[i] = ' '; }
+}
+
+static void RemoveEndPlus(cc_string* value) {
+	/* Workaround for MCDzienny (and others) use a '+' at the end to distinguish classicube.net accounts */
+	/* from minecraft.net accounts. Unfortunately they also send this ending + to the client. */
+	if (!value->length || value->buffer[value->length - 1] != '+') return;
+	value->length--;
+}
+
+static void CheckName(EntityID id, cc_string* name, cc_string* skin) {
+	cc_string colorlessName; char colorlessBuffer[STRING_SIZE];
+
+	RemoveEndPlus(name);
+	/* Server is only allowed to change our own name colours. */
+	if (id == ENTITIES_SELF_ID) {
+		String_InitArray(colorlessName, colorlessBuffer);
+		String_AppendColorless(&colorlessName, name);
+		if (!String_Equals(&colorlessName, &Game_Username)) String_Copy(name, &Game_Username);
+	}
+
+	if (!skin->length) String_Copy(skin, name);
+	RemoveEndPlus(skin);
+}
+
+static void Classic_ReadAbsoluteLocation(cc_uint8* data, EntityID id, cc_uint8 flags);
+static void AddEntity(cc_uint8* data, EntityID id, const cc_string* name, const cc_string* skin, cc_bool readPosition) {
+	struct LocalPlayer* p = Entities.CurPlayer;
+	struct Entity* e;
+
+	if (id != ENTITIES_SELF_ID) {
+		Entities_Remove(id);
+		e = &NetPlayers_List[id].Base;
+
+		NetPlayer_Init((struct NetPlayer*)e);
+		Entities.List[id] = e;
+		Event_RaiseInt(&EntityEvents.Added, id);
+	} else {
+		e = &Entities.CurPlayer->Base;
+	}
+	Entity_SetSkin(e, skin);
+	Entity_SetName(e, name);
+
+	if (!readPosition) return;
+	Classic_ReadAbsoluteLocation(data, id,
+		LU_HAS_POS | LU_HAS_YAW | LU_HAS_PITCH | LU_POS_ABSOLUTE_INSTANT);
+	if (id != ENTITIES_SELF_ID) return;
+
+	p->Spawn      = p->Base.Position;
+	p->SpawnYaw   = p->Base.Yaw;
+	p->SpawnPitch = p->Base.Pitch;
+}
+
+static void UpdateLocation(EntityID id, struct LocationUpdate* update) {
+	struct Entity* e = Entities.List[id];
+	if (e) { e->VTABLE->SetLocation(e, update); }
+}
+
+static void UpdateUserType(struct HacksComp* hacks, cc_uint8 value) {
+	cc_bool isOp = value >= 100 && value <= 127;
+	hacks->IsOp  = isOp;
+	if (IsSupported(blockPerms_Ext)) return;
+
+	Blocks.CanPlace[BLOCK_BEDROCK]     = isOp;
+	Blocks.CanDelete[BLOCK_BEDROCK]    = isOp;
+	Blocks.CanPlace[BLOCK_WATER]       = isOp;
+	Blocks.CanPlace[BLOCK_STILL_WATER] = isOp;
+	Blocks.CanPlace[BLOCK_LAVA]        = isOp;
+	Blocks.CanPlace[BLOCK_STILL_LAVA]  = isOp;
+}
+
+
+/*########################################################################################################################*
+*------------------------------------------------------WoM protocol-------------------------------------------------------*
+*#########################################################################################################################*/
+/* Partially based on information from http://files.worldofminecraft.com/texturing/ */
+/* NOTE: http://files.worldofminecraft.com/ has been down for quite a while, so support was removed on Oct 10, 2015 */
+static int wom_identifier;
+static cc_bool wom_sendId, wom_sentId;
+
+static void WoM_CheckMotd(void) {
+	cc_string url; char urlBuffer[STRING_SIZE];
+	cc_string motd, host;
+	int index;	
+
+	motd = Server.MOTD;
+	if (!motd.length) return;
+	index = String_IndexOfConst(&motd, "cfg=");
+	if (Game_PureClassic || index == -1) return;
+	
+	host = String_UNSAFE_SubstringAt(&motd, index + 4);
+	String_InitArray(url, urlBuffer);
+	String_Format1(&url, "http://%s", &host);
+	/* TODO: Replace $U with username */
+	/*url = url.Replace("$U", game.Username); */
+
+	/* Ensure that if the user quickly changes to a different world, env settings from old world aren't
+	applied in the new world if the async 'get env request' didn't complete before the old world was unloaded */
+	wom_identifier = Http_AsyncGetData(&url, HTTP_FLAG_PRIORITY);
+	wom_sendId = true;
+}
+
+static void WoM_CheckSendWomID(void) {
+	static const cc_string msg = String_FromConst("/womid WoMClient-2.0.7");
+
+	if (wom_sendId && !wom_sentId) {
+		Chat_Send(&msg, false);
+		wom_sentId = true;
+	}
+}
+
+static PackedCol WoM_ParseCol(const cc_string* value, PackedCol defaultColor) {
+	int argb;
+	if (!Convert_ParseInt(value, &argb)) return defaultColor;
+	return PackedCol_Make(argb >> 16, argb >> 8, argb, 255);
+}
+
+static void WoM_ParseConfig(struct HttpRequest* item) {
+	cc_string line; char lineBuffer[STRING_SIZE * 2];
+	struct Stream mem;
+	cc_string key, value;
+	int waterLevel;
+	PackedCol col;
+
+	String_InitArray(line, lineBuffer);
+	Stream_ReadonlyMemory(&mem, item->data, item->size);
+
+	while (!Stream_ReadLine(&mem, &line)) {
+		Platform_Log(line.buffer, line.length);
+		if (!String_UNSAFE_Separate(&line, '=', &key, &value)) continue;
+
+		if (String_CaselessEqualsConst(&key, "environment.cloud")) {
+			col = WoM_ParseCol(&value, ENV_DEFAULT_CLOUDS_COLOR);
+			Env_SetCloudsCol(col);
+		} else if (String_CaselessEqualsConst(&key, "environment.sky")) {
+			col = WoM_ParseCol(&value, ENV_DEFAULT_SKY_COLOR);
+			Env_SetSkyCol(col);
+		} else if (String_CaselessEqualsConst(&key, "environment.fog")) {
+			col = WoM_ParseCol(&value, ENV_DEFAULT_FOG_COLOR);
+			Env_SetFogCol(col);
+		} else if (String_CaselessEqualsConst(&key, "environment.level")) {
+			if (Convert_ParseInt(&value, &waterLevel)) {
+				Env_SetEdgeHeight(waterLevel);
+			}
+		} else if (String_CaselessEqualsConst(&key, "user.detail") && !IsSupported(messageTypes_Ext)) {
+			Chat_AddOf(&value, MSG_TYPE_STATUS_2);
+		}
+	}
+}
+
+static void WoM_Reset(void) {
+	wom_identifier = 0;
+	wom_sendId = false; wom_sentId = false;
+}
+
+static void WoM_Tick(void) {
+	struct HttpRequest item;
+	if (!Http_GetResult(wom_identifier, &item)) return;
+
+	if (item.success) WoM_ParseConfig(&item);
+	HttpRequest_Free(&item);
+}
+
+
+/*########################################################################################################################*
+*----------------------------------------------------Map decompressor-----------------------------------------------------*
+*#########################################################################################################################*/
+#define MAP_SIZE_LEN 4
+
+struct MapState {
+	struct InflateState inflateState;
+	struct Stream stream;
+	BlockRaw* blocks;
+	struct GZipHeader gzHeader;
+	cc_uint8 size[MAP_SIZE_LEN];
+	int index, sizeIndex;
+	cc_bool allocFailed;
+};
+static struct MapState map1;
+#ifdef EXTENDED_BLOCKS
+static struct MapState map2;
+#endif
+
+static void DisconnectInvalidMap(cc_result res) {
+	static const cc_string title  = String_FromConst("Disconnected");
+	cc_string tmp; char tmpBuffer[STRING_SIZE];
+	String_InitArray(tmp, tmpBuffer);
+
+	String_Format1(&tmp, "Server sent corrupted map data (error %e)", &res);
+	Game_Disconnect(&title, &tmp); return;
+}
+
+static void MapState_Init(struct MapState* m) {
+	Inflate_MakeStream2(&m->stream, &m->inflateState, &map_part);
+	GZipHeader_Init(&m->gzHeader);
+
+	m->index       = 0;
+	m->blocks      = NULL;
+	m->sizeIndex   = 0;
+	m->allocFailed = false;
+}
+
+static CC_INLINE void MapState_SkipHeader(struct MapState* m) {
+	m->gzHeader.done = true;
+	m->sizeIndex     = MAP_SIZE_LEN;
+}
+
+static void FreeMapStates(void) {
+	Mem_Free(map1.blocks);
+	map1.blocks = NULL;
+#ifdef EXTENDED_BLOCKS
+	Mem_Free(map2.blocks);
+	map2.blocks = NULL;
+#endif
+}
+
+static cc_result MapState_Read(struct MapState* m) {
+	cc_uint32 left, read;
+	cc_result res;
+	if (m->allocFailed) return 0;
+
+	if (m->sizeIndex < MAP_SIZE_LEN) {
+		left = MAP_SIZE_LEN - m->sizeIndex;
+		res  = m->stream.Read(&m->stream, &m->size[m->sizeIndex], left, &read); 
+
+		m->sizeIndex += read;
+		if (res) return res;
+
+		/* 0.01% chance to happen, but still possible */
+		if (m->sizeIndex < MAP_SIZE_LEN) return 0;
+	}
+
+	if (!map_volume) map_volume = Stream_GetU32_BE(m->size);
+
+	if (!m->blocks) {
+		m->blocks = (BlockRaw*)Mem_TryAlloc(map_volume, 1);
+		/* unlikely but possible */
+		if (!m->blocks) {
+			Window_ShowDialog("Out of memory", "Not enough free memory to join that map.\nTry joining a different map.");
+			m->allocFailed = true;
+			return 0;
+		}
+	}
+
+	left = map_volume - m->index;
+	res  = m->stream.Read(&m->stream, &m->blocks[m->index], left, &read);
+
+	m->index += read;
+	return res;
+}
+
+
+/*########################################################################################################################*
+*----------------------------------------------------Classic protocol-----------------------------------------------------*
+*#########################################################################################################################*/
+void Classic_SendLogin(void) {
+	cc_uint8 data[131];
+	data[0] = OPCODE_HANDSHAKE;
+	{
+		data[1]   = Game_Version.Protocol;
+		WriteString(&data[2],  &Game_Username);
+		WriteString(&data[66], &Game_Mppass);
+
+		/* The 'user type' field's behaviour depends on protocol version: */
+		/*   version 7 - 0x42 specifies CPE client, any other value is ignored? */
+		/*   version 6 - any value ignored? */
+		/*   version 5 - field doesn't exist */
+		/* Theroetically, this means packet size is 131 bytes for 6/7, 130 bytes for 5 and below. */
+		/* In practice, some version 7 server software always expects to read 131 bytes for handshake packet, */
+		/*  and will get stuck waiting for data if client connects using version 5 and only sends 130 bytes */
+		/* To workaround this, include a 'ping packet' after 'version 5 handshake packet' - version 5 server software */
+		/*  will do nothing with the ping packet, and the aforementioned server software will be happy with 131 bytes */
+		data[130] = Game_Version.HasCPE ? 0x42 : (Game_Version.Protocol <= PROTOCOL_0019 ? OPCODE_PING : 0x00);
+	}
+	Server.SendData(data, 131);
+}
+
+void Classic_SendChat(const cc_string* text, cc_bool partial) {
+	cc_uint8 data[66];
+	data[0] = OPCODE_MESSAGE;
+	{
+		data[1] = Server.SupportsPartialMessages ? partial : ENTITIES_SELF_ID;
+		WriteString(&data[2], text);
+	}
+	Server.SendData(data, 66);
+}
+
+static cc_uint8* Classic_WritePosition(cc_uint8* data, Vec3 pos, float yaw, float pitch) {
+	BlockID payload;
+	int x, y, z;
+
+	*data++ = OPCODE_ENTITY_TELEPORT;
+	{
+		payload = IsSupported(heldBlock_Ext) ? Inventory_SelectedBlock : ENTITIES_SELF_ID;
+		WriteBlock(data, payload);
+		x = (int)(pos.x * 32);
+		y = (int)(pos.y * 32) + 51;
+		z = (int)(pos.z * 32);
+
+		if (IsSupported(extEntityPos_Ext)) {
+			Stream_SetU32_BE(data, x); data += 4;
+			Stream_SetU32_BE(data, y); data += 4;
+			Stream_SetU32_BE(data, z); data += 4;
+		} else {
+			Stream_SetU16_BE(data, x); data += 2;
+			Stream_SetU16_BE(data, y); data += 2;
+			Stream_SetU16_BE(data, z); data += 2;
+		}
+
+		*data++ = Math_Deg2Packed(yaw);
+		*data++ = Math_Deg2Packed(pitch);
+	}
+	return data;
+}
+
+void Classic_SendSetBlock(int x, int y, int z, cc_bool place, BlockID block) {
+	cc_uint8 tmp[32];
+	cc_uint8* data = tmp;
+
+	*data++ = OPCODE_SET_BLOCK_CLIENT;
+	{
+		Stream_SetU16_BE(data, x); data += 2;
+		Stream_SetU16_BE(data, y); data += 2;
+		Stream_SetU16_BE(data, z); data += 2;
+		*data++ = place;
+		WriteBlock(data, block);
+	}
+	Server.SendData(tmp, (cc_uint32)(data - tmp));
+}
+
+static void Classic_Handshake(cc_uint8* data) {
+	struct HacksComp* hacks;
+
+	Server.Name.length = 0;
+	Server.MOTD.length = 0;
+	data++; /* protocol version */
+
+	ReadString(&data, &Server.Name);
+	ReadString(&data, &Server.MOTD);
+	Chat_SetLogName(&Server.Name);
+
+	hacks = &Entities.CurPlayer->Hacks;
+	UpdateUserType(hacks, *data);
+	
+	String_Copy(&hacks->HacksFlags,         &Server.Name);
+	String_AppendString(&hacks->HacksFlags, &Server.MOTD);
+	HacksComp_RecheckFlags(hacks);
+}
+
+static void Classic_Ping(cc_uint8* data) { }
+
+static void Classic_StartLoading(void) {
+	World_NewMap();
+	LoadingScreen_Show(&Server.Name, &Server.MOTD);
+	WoM_CheckMotd();
+	classic_receivedFirstPos = false;
+
+	map_begunLoading = true;
+	map_receiveBeg   = Stopwatch_Measure();
+	map_volume       = 0;
+
+	MapState_Init(&map1);
+#ifdef EXTENDED_BLOCKS
+	MapState_Init(&map2);
+#endif
+}
+
+static void Classic_LevelInit(cc_uint8* data) {
+	/* in case server is buggy and sends LevelInit multiple times */
+	if (map_begunLoading) return;
+
+	Classic_StartLoading();
+	if (!IsSupported(fastMap_Ext)) return;
+
+	/* Fast map puts volume in header, and uses raw DEFLATE without GZIP header/footer */
+	map_volume = Stream_GetU32_BE(data);
+	MapState_SkipHeader(&map1);
+#ifdef EXTENDED_BLOCKS
+	MapState_SkipHeader(&map2);
+#endif
+}
+
+static void Classic_LevelDataChunk(cc_uint8* data) {
+	struct MapState* m;
+	int usedLength;
+	float progress;
+	cc_result res;
+
+	/* Workaround for some servers that send LevelDataChunk before LevelInit due to their async sending behaviour */
+	if (!map_begunLoading) Classic_StartLoading();
+	usedLength = Stream_GetU16_BE(data);
+
+	map_part.meta.mem.cur    = data + 2;
+	map_part.meta.mem.base   = data + 2;
+	map_part.meta.mem.left   = usedLength;
+	map_part.meta.mem.length = usedLength;
+
+#ifndef EXTENDED_BLOCKS
+	m = &map1;
+#else
+	/* progress byte in original classic, but we ignore it */
+	if (IsSupported(extBlocks_Ext) && data[1026]) {
+		m = &map2;
+	} else {
+		m = &map1;
+	}
+#endif
+
+	if (!m->gzHeader.done) {
+		res = GZipHeader_Read(&map_part, &m->gzHeader);
+		if (res && res != ERR_END_OF_STREAM) { DisconnectInvalidMap(res); return; }
+	}
+
+	if (m->gzHeader.done) {
+		res = MapState_Read(m);
+		if (res) { DisconnectInvalidMap(res); return; }
+	}
+
+	progress = !map_volume ? 0.0f : (float)map1.index / map_volume;
+	Event_RaiseFloat(&WorldEvents.Loading, progress);
+}
+
+static void Classic_LevelFinalise(cc_uint8* data) {
+	int width, height, length, volume;
+	cc_uint64 end;
+	int delta;
+
+	end   = Stopwatch_Measure();
+	delta = Stopwatch_ElapsedMS(map_receiveBeg, end);
+	Platform_Log1("map loading took: %i", &delta);
+	map_begunLoading = false;
+	WoM_CheckSendWomID();
+
+#ifdef EXTENDED_BLOCKS
+	if (map2.allocFailed) FreeMapStates();
+#endif
+
+	width  = Stream_GetU16_BE(data + 0);
+	height = Stream_GetU16_BE(data + 2);
+	length = Stream_GetU16_BE(data + 4);
+	volume = width * height * length;
+
+	if (map1.allocFailed) {
+		Chat_AddRaw("&cFailed to load map, try joining a different map");
+		Chat_AddRaw("   &cNot enough free memory to load the map");
+	} else if (!map1.blocks) {
+		Chat_AddRaw("&cFailed to load map, try joining a different map");
+		Chat_AddRaw("   &cAttempted to load map without a Blocks array");
+	} else if (map_volume != volume) {
+		Chat_AddRaw("&cFailed to load map, try joining a different map");
+		Chat_Add2(  "   &cBlocks array size (%i) does not match volume of map (%i)", &map_volume, &volume);
+		FreeMapStates();
+	}
+	
+#ifdef EXTENDED_BLOCKS
+	/* defer allocation of second map array if possible */
+	if (IsSupported(extBlocks_Ext) && map2.blocks) {
+		World_SetMapUpper(map2.blocks);
+	}
+	map2.blocks = NULL;
+#endif
+	World_SetNewMap(map1.blocks, width, height, length);
+	map1.blocks  = NULL;
+}
+
+static void Classic_SetBlock(cc_uint8* data) {
+	int x, y, z;
+	BlockID block;
+
+	x = Stream_GetU16_BE(data + 0);
+	y = Stream_GetU16_BE(data + 2);
+	z = Stream_GetU16_BE(data + 4);
+	data += 6;
+
+	ReadBlock(data, block);
+	if (World_Contains(x, y, z)) {
+		Game_UpdateBlock(x, y, z, block);
+	}
+}
+
+static void Classic_AddEntity(cc_uint8* data) {
+	static const cc_string group = String_FromConst("Players");
+	cc_string name; char nameBuffer[STRING_SIZE];
+	cc_string skin; char skinBuffer[STRING_SIZE];
+	EntityID id;
+	String_InitArray(name, nameBuffer);
+	String_InitArray(skin, skinBuffer);
+
+	id = *data++;
+	ReadString(&data, &name);
+	CheckName(id, &name, &skin);
+	AddEntity(data, id, &name, &skin, true);
+
+	/* Workaround for some servers that declare support for ExtPlayerList but don't send ExtAddPlayerName */
+	TabList_Set(id, &name, &name, &group, 0);
+	TabList_EntityLinked_Set(id);
+}
+
+static void Classic_EntityTeleport(cc_uint8* data) {
+	EntityID id = *data++;
+	Classic_ReadAbsoluteLocation(data, id, 
+		LU_HAS_POS | LU_HAS_YAW | LU_HAS_PITCH | LU_POS_ABSOLUTE_SMOOTH | LU_ORI_INTERPOLATE);
+}
+
+static void Classic_RelPosAndOrientationUpdate(cc_uint8* data) {
+	struct LocationUpdate update;
+	EntityID id = data[0];
+
+	update.flags = LU_HAS_POS | LU_HAS_YAW | LU_HAS_PITCH | LU_POS_RELATIVE_SMOOTH | LU_ORI_INTERPOLATE;
+	update.pos.x = (cc_int8)data[1] / 32.0f;
+	update.pos.y = (cc_int8)data[2] / 32.0f;
+	update.pos.z = (cc_int8)data[3] / 32.0f;
+	update.yaw   = Math_Packed2Deg(data[4]);
+	update.pitch = Math_Packed2Deg(data[5]);
+	UpdateLocation(id, &update);
+}
+
+static void Classic_RelPositionUpdate(cc_uint8* data) {
+	struct LocationUpdate update;
+	EntityID id = data[0];
+
+	update.flags = LU_HAS_POS | LU_POS_RELATIVE_SMOOTH | LU_ORI_INTERPOLATE;
+	update.pos.x = (cc_int8)data[1] / 32.0f;
+	update.pos.y = (cc_int8)data[2] / 32.0f;
+	update.pos.z = (cc_int8)data[3] / 32.0f;
+	UpdateLocation(id, &update);
+}
+
+static void Classic_OrientationUpdate(cc_uint8* data) {
+	struct LocationUpdate update;
+	EntityID id = data[0];
+
+	update.flags = LU_HAS_YAW | LU_HAS_PITCH | LU_ORI_INTERPOLATE;
+	update.yaw   = Math_Packed2Deg(data[1]);
+	update.pitch = Math_Packed2Deg(data[2]);
+	UpdateLocation(id, &update);
+}
+
+static void Classic_RemoveEntity(cc_uint8* data) {
+	EntityID id = data[0];
+	if (id != ENTITIES_SELF_ID) Entities_Remove(id);
+}
+
+static void Classic_Message(cc_uint8* data) {
+	static const cc_string detailMsg  = String_FromConst("^detail.user=");
+	static const cc_string detailUser = String_FromConst("^detail.user");
+	cc_string text; char textBuffer[STRING_SIZE + 2];
+
+	cc_uint8 type = *data++;
+	String_InitArray(text, textBuffer);
+
+	/* Original vanilla server uses player ids for type, 255 for server messages (&e prefix) */
+	if (!IsSupported(messageTypes_Ext)) {
+		if (type == 0xFF) String_AppendConst(&text, "&e");
+		type = MSG_TYPE_NORMAL;
+	}
+	ReadString(&data, &text);
+
+	/* WoM detail messages (used e.g. for fCraft server compass) */
+	if (String_CaselessStarts(&text, &detailMsg)) {
+		text = String_UNSAFE_SubstringAt(&text, detailMsg.length);
+		type = MSG_TYPE_STATUS_3;
+	}
+	/* Ignore ^detail.user.joined etc */
+	if (!String_CaselessStarts(&text, &detailUser)) Chat_AddOf(&text, type);
+}
+
+static void Classic_Kick(cc_uint8* data) {
+	static const cc_string title = String_FromConst("&eLost connection to the server");
+	cc_string reason = UNSAFE_GetString(data);
+	Game_Disconnect(&title, &reason);
+}
+
+static void Classic_SetPermission(cc_uint8* data) {
+	struct HacksComp* hacks = &Entities.CurPlayer->Hacks;
+	UpdateUserType(hacks, data[0]);
+	HacksComp_RecheckFlags(hacks);
+}
+
+static void Classic_ReadAbsoluteLocation(cc_uint8* data, EntityID id, cc_uint8 flags) {
+	struct LocationUpdate update;
+	int x, y, z;
+	cc_uint8 mode;
+
+	if (IsSupported(extEntityPos_Ext)) {
+		x = (int)Stream_GetU32_BE(&data[0]);
+		y = (int)Stream_GetU32_BE(&data[4]);
+		z = (int)Stream_GetU32_BE(&data[8]);
+		data += 12;
+	} else {
+		x = (cc_int16)Stream_GetU16_BE(&data[0]);
+		y = (cc_int16)Stream_GetU16_BE(&data[2]);
+		z = (cc_int16)Stream_GetU16_BE(&data[4]);
+		data += 6;
+	}
+
+	mode = flags & LU_POS_MODEMASK;
+	if (mode == LU_POS_ABSOLUTE_SMOOTH || mode == LU_POS_ABSOLUTE_INSTANT) { /* Only perform height shifts on absolute updates */
+		y -= 51; /* Convert to feet position */
+		/* The original classic client behaves strangely in that */
+		/*   Y+0  is sent back to the server for next client->server position update */
+		/*   Y+22 is sent back to the server for all subsequent position updates */
+		/* so to simplify things, just always add 22 to Y*/
+		if (id == ENTITIES_SELF_ID) y += 22;
+	}
+
+	update.flags = flags;
+	update.pos.x = x/32.0f; 
+	update.pos.y = y/32.0f; 
+	update.pos.z = z/32.0f;
+	update.yaw   = Math_Packed2Deg(*data++);
+	update.pitch = Math_Packed2Deg(*data++);
+
+	if (id == ENTITIES_SELF_ID) classic_receivedFirstPos = true;
+	UpdateLocation(id, &update);
+}
+
+#define Classic_HandshakeSize() (Game_Version.Protocol > PROTOCOL_0019 ? 131 : 130)
+static void Classic_Reset(void) {
+	Stream_ReadonlyMemory(&map_part, NULL, 0);
+	map_begunLoading = false;
+	classic_receivedFirstPos = false;
+
+	Net_Set(OPCODE_HANDSHAKE, Classic_Handshake, Classic_HandshakeSize());
+	Net_Set(OPCODE_PING, Classic_Ping, 1);
+	Net_Set(OPCODE_LEVEL_BEGIN, Classic_LevelInit, 1);
+	Net_Set(OPCODE_LEVEL_DATA, Classic_LevelDataChunk, 1028);
+	Net_Set(OPCODE_LEVEL_END, Classic_LevelFinalise, 7);
+	Net_Set(OPCODE_SET_BLOCK, Classic_SetBlock, 8);
+
+	Net_Set(OPCODE_ADD_ENTITY, Classic_AddEntity, 74);
+	Net_Set(OPCODE_ENTITY_TELEPORT, Classic_EntityTeleport, 10);
+	Net_Set(OPCODE_RELPOS_AND_ORI_UPDATE, Classic_RelPosAndOrientationUpdate, 7);
+	Net_Set(OPCODE_RELPOS_UPDATE, Classic_RelPositionUpdate, 5);
+	Net_Set(OPCODE_ORI_UPDATE, Classic_OrientationUpdate, 4);
+	Net_Set(OPCODE_REMOVE_ENTITY, Classic_RemoveEntity, 2);
+
+	Net_Set(OPCODE_MESSAGE, Classic_Message, 66);
+	Net_Set(OPCODE_KICK, Classic_Kick, 65);
+	Net_Set(OPCODE_SET_PERMISSION, Classic_SetPermission, 2);
+}
+
+static cc_uint8* Classic_Tick(cc_uint8* data) {
+	struct Entity* e = &Entities.CurPlayer->Base;
+	if (!classic_receivedFirstPos) return data;
+
+	/* Report end position of each physics tick, rather than current position */
+	/*  (otherwise can miss landing on a block then jumping off of it again) */
+	return Classic_WritePosition(data, e->next.pos, e->Yaw, e->Pitch);
+}
+
+
+/*########################################################################################################################*
+*------------------------------------------------------CPE protocol-------------------------------------------------------*
+*#########################################################################################################################*/
+static void CPEExtensions_Reset(void) {
+	struct CpeExt* ext;
+	int i;
+
+	for (i = 0; i < Array_Elems(cpe_clientExtensions); i++)
+	{
+		ext = cpe_clientExtensions[i];
+		ext->serverVersion = 0;
+	}
+}
+
+static struct CpeExt* CPEExtensions_Find(const cc_string* name) {
+	struct CpeExt* ext;
+	int i;
+
+	for (i = 0; i < Array_Elems(cpe_clientExtensions); i++)
+	{
+		ext = cpe_clientExtensions[i];
+		if (String_CaselessEqualsConst(name, ext->name)) return ext;
+	}
+	return NULL;
+}
+
+#define Ext_Deg2Packed(x) ((int)((x) * 65536.0f / 360.0f))
+void CPE_SendPlayerClick(int button, cc_bool pressed, cc_uint8 targetId, struct RayTracer* t) {
+	struct Entity* p = &Entities.CurPlayer->Base;
+	cc_uint8 data[15];
+
+	data[0] = OPCODE_PLAYER_CLICK;
+	{
+		data[1] = button;
+		data[2] = !pressed;
+		Stream_SetU16_BE(&data[3], Ext_Deg2Packed(p->Yaw));
+		Stream_SetU16_BE(&data[5], Ext_Deg2Packed(p->Pitch));
+
+		data[7] = targetId;
+		Stream_SetU16_BE(&data[8],  t->pos.x);
+		Stream_SetU16_BE(&data[10], t->pos.y);
+		Stream_SetU16_BE(&data[12], t->pos.z);
+
+		data[14] = 255;
+		/* FACE enum values differ from CPE block face values */
+		switch (t->closest) {
+		case FACE_XMAX: data[14] = 0; break;
+		case FACE_XMIN: data[14] = 1; break;
+		case FACE_YMAX: data[14] = 2; break;
+		case FACE_YMIN: data[14] = 3; break;
+		case FACE_ZMAX: data[14] = 4; break;
+		case FACE_ZMIN: data[14] = 5; break;
+		}
+	}
+	Server.SendData(data, 15);
+}
+
+void CPE_SendPluginMessage(cc_uint8 channel, cc_uint8* data) {
+	cc_uint8 buffer[66];
+	if (!IsSupported(pluginMessages_Ext)) return;
+
+	buffer[0] = OPCODE_PLUGIN_MESSAGE;
+	{
+		buffer[1] = channel;
+		Mem_Copy(buffer + 2, data, 64);
+	}
+	Server.SendData(buffer, 66);
+}
+
+static void CPE_SendExtInfo(int extsCount) {
+	cc_uint8 data[67];
+	data[0] = OPCODE_EXT_INFO;
+	{
+		WriteString(data + 1,       &Server.AppName);
+		Stream_SetU16_BE(data + 65, extsCount);
+	}
+	Server.SendData(data, 67);
+}
+
+static void CPE_SendExtEntry(const cc_string* extName, int extVersion) {
+	cc_uint8 data[69];
+	data[0] = OPCODE_EXT_ENTRY;
+	{
+		WriteString(data + 1,       extName);
+		Stream_SetU32_BE(data + 65, extVersion);
+	}
+	Server.SendData(data, 69);
+}
+
+static cc_uint8* CPE_WriteTwoWayPing(cc_uint8* data, cc_bool serverToClient, int id) {
+	*data++ = OPCODE_TWO_WAY_PING;
+	{
+		*data++ = serverToClient;
+		Stream_SetU16_BE(data, id); data += 2;
+	}
+	return data;
+}
+
+static void CPE_SendCpeExtInfoReply(void) {
+	struct CpeExt* ext;
+	int count = Array_Elems(cpe_clientExtensions);
+	cc_string name;
+	int i, ver;
+
+	if (cpe_serverExtensionsCount) return;
+
+#ifdef EXTENDED_BLOCKS
+	if (!Game_AllowCustomBlocks) count -= 3;
+#else
+	if (!Game_AllowCustomBlocks) count -= 2;
+#endif
+	CPE_SendExtInfo(count);
+
+	for (i = 0; i < Array_Elems(cpe_clientExtensions); i++) 
+	{
+		ext  = cpe_clientExtensions[i];
+		name = String_FromReadonly(ext->name);
+		ver  = ext->serverVersion ? ext->serverVersion : ext->clientVersion;
+		/* Don't reply with version higher than what server supports to workaround some buggy server software */
+
+		if (!Game_AllowCustomBlocks) {
+			if (String_CaselessEqualsConst(&name, "BlockDefinitionsExt")) continue;
+			if (String_CaselessEqualsConst(&name, "BlockDefinitions"))    continue;
+#ifdef EXTENDED_BLOCKS
+			if (String_CaselessEqualsConst(&name, "ExtendedBlocks"))      continue;
+#endif
+		}
+		CPE_SendExtEntry(&name, ver);
+	}
+}
+
+static void CPE_ExtInfo(cc_uint8* data) {
+	static const cc_string d3Server = String_FromConst("D3 server");
+	cc_string appName = UNSAFE_GetString(data);
+	cpe_needD3Fix     = String_CaselessStarts(&appName, &d3Server);
+	Chat_Add1("Server software: %s", &appName);
+
+	/* Workaround for old MCGalaxy that send ExtEntry sync but ExtInfo async. */
+	/* Means ExtEntry may sometimes arrive before ExtInfo, so use += instead of = */
+	cpe_serverExtensionsCount += Stream_GetU16_BE(&data[64]);
+	CPE_SendCpeExtInfoReply();
+}
+
+static void CPE_ExtEntry(cc_uint8* data) {
+	struct CpeExt* ext;
+	cc_string name = UNSAFE_GetString(data);
+	int version    = data[67];
+	Platform_Log2("cpe ext: %s, %i", &name, &version);
+
+	cpe_serverExtensionsCount--;
+	CPE_SendCpeExtInfoReply();
+
+	ext = CPEExtensions_Find(&name);
+	if (!ext) return;
+	ext->serverVersion = min(ext->clientVersion, version);
+
+	/* update support state */
+	if (ext == &extPlayerList_Ext) {
+		Server.SupportsExtPlayerList = true;
+	} else if (ext == &playerClick_Ext) {
+		Server.SupportsPlayerClick = true;
+	} else if (ext == &mapAppearance_Ext) {
+		if (ext->serverVersion == 1) return;
+		Protocol.Sizes[OPCODE_ENV_SET_MAP_APPEARANCE] += 4;
+	} else if (ext == &longerMessages_Ext) {
+		Server.SupportsPartialMessages = true;
+	} else if (ext == &fullCP437_Ext) {
+		Server.SupportsFullCP437 = true;
+	} else if (ext == &blockDefsExt_Ext) {
+		if (ext->serverVersion == 1) return;
+		Protocol.Sizes[OPCODE_DEFINE_BLOCK_EXT] += 3;
+	} else if (ext == &extEntityPos_Ext) {
+		Protocol.Sizes[OPCODE_ENTITY_TELEPORT]     += 6;
+		Protocol.Sizes[OPCODE_ADD_ENTITY]          += 6;
+		Protocol.Sizes[OPCODE_EXT_ADD_ENTITY2]     += 6;
+		Protocol.Sizes[OPCODE_SET_SPAWNPOINT]      += 6;
+		Protocol.Sizes[OPCODE_ENTITY_TELEPORT_EXT] += 6;
+	} else if (ext == &fastMap_Ext) {
+		Protocol.Sizes[OPCODE_LEVEL_BEGIN] += 4;
+	} else if (ext == &envMapAspect_Ext) {
+		if (ext->serverVersion == 1) return;
+		Protocol.Sizes[OPCODE_ENV_SET_MAP_URL] += 64;
+	}  else if (ext == &customModels_Ext) {
+		if (ext->serverVersion == 2) {
+			Protocol.Sizes[OPCODE_DEFINE_MODEL_PART] = 167;
+		}
+	}
+#ifdef EXTENDED_TEXTURES
+	else if (ext == &extTextures_Ext) {
+		Protocol.Sizes[OPCODE_DEFINE_BLOCK]     += 3;
+		Protocol.Sizes[OPCODE_DEFINE_BLOCK_EXT] += 6;
+	}
+#endif
+#ifdef EXTENDED_BLOCKS
+	else if (ext == &extBlocks_Ext) {
+		if (!Game_AllowCustomBlocks) return;
+
+		Protocol.Sizes[OPCODE_SET_BLOCK] += 1;
+		Protocol.Sizes[OPCODE_HOLD_THIS] += 1;
+		Protocol.Sizes[OPCODE_SET_BLOCK_PERMISSION] += 1;
+		Protocol.Sizes[OPCODE_DEFINE_BLOCK]     += 1;
+		Protocol.Sizes[OPCODE_UNDEFINE_BLOCK]   += 1;
+		Protocol.Sizes[OPCODE_DEFINE_BLOCK_EXT] += 1;
+		Protocol.Sizes[OPCODE_SET_INVENTORY_ORDER] += 2;
+		Protocol.Sizes[OPCODE_BULK_BLOCK_UPDATE]   += 256 / 4;
+		Protocol.Sizes[OPCODE_SET_HOTBAR]       += 1;
+	}
+#endif
+}
+
+static void CPE_ApplyTexturePack(const cc_string* url) {
+	if (!url->length || Utils_IsUrlPrefix(url)) {
+		Server_RetrieveTexturePack(url);
+	}
+	Platform_Log1("Tex url: %s", url);
+}
+
+
+static void CPE_SetClickDistance(cc_uint8* data) {
+	Entities.CurPlayer->ReachDistance = Stream_GetU16_BE(data) / 32.0f;
+}
+
+static void CPE_CustomBlockLevel(cc_uint8* data) {
+	/* reply with version 1 level support */
+	cc_uint8 reply[2] = { OPCODE_CUSTOM_BLOCK_LEVEL, 1 };
+	Server.SendData(reply, 2);
+
+	Game_UseCPEBlocks = true;
+	Event_RaiseVoid(&BlockEvents.PermissionsChanged);
+}
+
+static void CPE_HoldThis(cc_uint8* data) {
+	BlockID block;
+	cc_bool canChange;
+
+	ReadBlock(data, block);
+	canChange = *data == 0;
+
+	Inventory.CanChangeSelected = true;
+	Inventory_SetSelectedBlock(block);
+	Inventory.CanChangeSelected = canChange;
+}
+
+static void CPE_SetTextHotkey(cc_uint8* data) {
+	/* First 64 bytes are label string */
+	cc_string action  = UNSAFE_GetString(&data[64]);
+	cc_uint32 keyCode = Stream_GetU32_BE(&data[128]);
+	cc_uint8 keyMods  = data[132];
+	int key;
+	
+	if (keyCode > 255) return;
+	key = Hotkeys_LWJGL[keyCode];
+	if (!key) return;
+	Platform_Log3("CPE hotkey added: %c, %b: %s", Input_DisplayNames[key], &keyMods, &action);
+
+	if (!action.length) {
+		Hotkeys_Remove(key, keyMods);
+		StoredHotkeys_Load(key, keyMods);
+	} else if (action.buffer[action.length - 1] == '\n') {
+		action.length--;
+		Hotkeys_Add(key, keyMods, &action, 
+					HOTKEY_FLAG_AUTO_DEFINED);
+	} else { /* more input needed by user */
+		Hotkeys_Add(key, keyMods, &action, 
+					HOTKEY_FLAG_AUTO_DEFINED | HOTKEY_FLAG_STAYS_OPEN);
+	}
+}
+
+static void CPE_ExtAddPlayerName(cc_uint8* data) {
+	EntityID id = data[1]; /* 16 bit id */
+	cc_string playerName = UNSAFE_GetString(&data[2]);
+	cc_string listName   = UNSAFE_GetString(&data[66]);
+	cc_string groupName  = UNSAFE_GetString(&data[130]);
+	cc_uint8 groupRank   = data[194];
+
+	RemoveEndPlus(&playerName);
+	RemoveEndPlus(&listName);
+
+	/* Workarond for server software that declares support for ExtPlayerList, but sends AddEntity then AddPlayerName */
+	TabList_EntityLinked_Reset(id);
+	TabList_Set(id, &playerName, &listName, &groupName, groupRank);
+}
+
+static void CPE_ExtAddEntity(cc_uint8* data) {
+	cc_string name, skin;
+	EntityID id;
+
+	id   = data[0];
+	name = UNSAFE_GetString(data + 1);
+	skin = UNSAFE_GetString(data + 65);
+
+	CheckName(id, &name, &skin);
+	AddEntity(data + 129, id, &name, &skin, false);
+}
+
+static void CPE_ExtRemovePlayerName(cc_uint8* data) {
+	EntityID id = data[1];
+	TabList_Remove(id);
+}
+
+static void CPE_MakeSelection(cc_uint8* data) {
+	IVec3 p1, p2;
+	PackedCol c;
+	/* data[0] is id, data[1..64] is label */
+
+	p1.x = (cc_int16)Stream_GetU16_BE(data + 65);
+	p1.y = (cc_int16)Stream_GetU16_BE(data + 67);
+	p1.z = (cc_int16)Stream_GetU16_BE(data + 69);
+	p2.x = (cc_int16)Stream_GetU16_BE(data + 71);
+	p2.y = (cc_int16)Stream_GetU16_BE(data + 73);
+	p2.z = (cc_int16)Stream_GetU16_BE(data + 75);
+
+	/* R,G,B,A are actually 16 bit unsigned integers */
+	c = PackedCol_Make(data[78], data[80], data[82], data[84]);
+	Selections_Add(data[0], &p1, &p2, c);
+}
+
+static void CPE_RemoveSelection(cc_uint8* data) {
+	Selections_Remove(data[0]);
+}
+
+static void CPE_SetEnvCol(cc_uint8* data) {
+	PackedCol c;
+	cc_uint8 variable;
+	cc_bool invalid;
+	
+	variable = data[0];
+	invalid  = data[1] || data[3] || data[5];
+	/* R,G,B are actually 16 bit unsigned integers */
+	/* Above > 255 is 'invalid' (this is used by servers) */
+	c = PackedCol_Make(data[2], data[4], data[6], 255);
+
+	if (variable == 0) {
+		Env_SetSkyCol(invalid        ? ENV_DEFAULT_SKY_COLOR      : c);
+	} else if (variable == 1) {	     
+		Env_SetCloudsCol(invalid     ? ENV_DEFAULT_CLOUDS_COLOR   : c);
+	} else if (variable == 2) {	     
+		Env_SetFogCol(invalid        ? ENV_DEFAULT_FOG_COLOR      : c);
+	} else if (variable == 3) {	     
+		Env_SetShadowCol(invalid     ? ENV_DEFAULT_SHADOW_COLOR   : c);
+	} else if (variable == 4) {	     
+		Env_SetSunCol(invalid        ? ENV_DEFAULT_SUN_COLOR      : c);
+	} else if (variable == 5) {	     
+		Env_SetSkyboxCol(invalid     ? ENV_DEFAULT_SKYBOX_COLOR   : c);
+	} else if (variable == 6) {
+		Env_SetLavaLightCol(invalid ? ENV_DEFAULT_LAVALIGHT_COLOR : c);
+	} else if (variable == 7) {
+		Env_SetLampLightCol(invalid ? ENV_DEFAULT_LAMPLIGHT_COLOR : c);
+	}
+}
+
+static void CPE_SetBlockPermission(cc_uint8* data) {
+	BlockID block; 
+	ReadBlock(data, block);
+
+	Blocks.CanPlace[block]  = *data++ != 0;
+	Blocks.CanDelete[block] = *data++ != 0;
+	Event_RaiseVoid(&BlockEvents.PermissionsChanged);
+}
+
+static void CPE_ChangeModel(cc_uint8* data) {
+	struct Entity* e;
+	EntityID id     = data[0];
+	cc_string model = UNSAFE_GetString(data + 1);
+
+	e = Entities.List[id];
+	if (e) Entity_SetModel(e, &model);
+}
+
+static void CPE_EnvSetMapAppearance(cc_uint8* data) {
+	cc_string url = UNSAFE_GetString(data);
+	int maxViewDist;
+	CPE_ApplyTexturePack(&url);
+
+	Env_SetSidesBlock(data[64]);
+	Env_SetEdgeBlock(data[65]);
+	Env_SetEdgeHeight((cc_int16)Stream_GetU16_BE(data + 66));
+	if (mapAppearance_Ext.serverVersion == 1) return;
+
+	/* Version 2 */
+	Env_SetCloudsHeight((cc_int16)Stream_GetU16_BE(data + 68));
+	maxViewDist       = (cc_int16)Stream_GetU16_BE(data + 70);
+	Game_MaxViewDistance = maxViewDist <= 0 ? DEFAULT_MAX_VIEWDIST : maxViewDist;
+	Game_SetViewDistance(Game_UserViewDistance);
+}
+
+static void CPE_EnvWeatherType(cc_uint8* data) {
+	Env_SetWeather(data[0]);
+}
+
+static void CPE_HackControl(cc_uint8* data) {
+	struct LocalPlayer* p = Entities.CurPlayer;
+	int jumpHeight;
+
+	p->Hacks.CanFly            = true;
+	p->Hacks.CanNoclip         = true;
+	p->Hacks.CanSpeed          = true;
+	p->Hacks.CanRespawn        = true;
+	p->Hacks.CanUseThirdPerson = true;
+	HacksComp_Update(&p->Hacks);
+	jumpHeight = Stream_GetU16_BE(data + 5);
+
+	if (jumpHeight == UInt16_MaxValue) { /* special value of -1 to reset default */
+		LocalPlayer_ResetJumpVelocity(p);
+	} else {
+		p->Physics.JumpVel       = PhysicsComp_CalcJumpVelocity(jumpHeight / 32.0f);
+		p->Physics.ServerJumpVel = p->Physics.JumpVel;
+	}
+}
+
+static void CPE_ExtAddEntity2(cc_uint8* data) {
+	cc_string name, skin;
+	EntityID id;
+
+	id   = data[0];
+	name = UNSAFE_GetString(data + 1);
+	skin = UNSAFE_GetString(data + 65);
+
+	CheckName(id, &name, &skin);
+	AddEntity(data + 129, id, &name, &skin, true);
+}
+
+#define BULK_MAX_BLOCKS 256
+static void CPE_BulkBlockUpdate(cc_uint8* data) {
+	cc_int32 indices[BULK_MAX_BLOCKS];
+	BlockID blocks[BULK_MAX_BLOCKS];
+	int index, i;
+	int x, y, z;
+	int count = 1 + *data++;
+
+	for (i = 0; i < count; i++) {
+		indices[i] = Stream_GetU32_BE(data); data += 4;
+	}
+	data += (BULK_MAX_BLOCKS - count) * 4;
+	
+	for (i = 0; i < count; i++) {
+		blocks[i] = data[i];
+	}
+	data += BULK_MAX_BLOCKS;
+
+	if (IsSupported(extBlocks_Ext)) {
+		for (i = 0; i < count; i += 4) {
+			cc_uint8 flags = data[i >> 2];
+			blocks[i + 0] |= (BlockID)((flags & 0x03) << 8);
+			blocks[i + 1] |= (BlockID)((flags & 0x0C) << 6);
+			blocks[i + 2] |= (BlockID)((flags & 0x30) << 4);
+			blocks[i + 3] |= (BlockID)((flags & 0xC0) << 2);
+		}
+		data += BULK_MAX_BLOCKS / 4;
+	}
+
+	for (i = 0; i < count; i++) {
+		index = indices[i];
+		if (index < 0 || index >= World.Volume) continue;
+		World_Unpack(index, x, y, z);
+
+#ifdef EXTENDED_BLOCKS
+		Game_UpdateBlock(x, y, z, blocks[i] % BLOCK_COUNT);
+#else
+		Game_UpdateBlock(x, y, z, blocks[i]);
+#endif
+	}
+}
+
+static void CPE_SetTextColor(cc_uint8* data) {
+	BitmapCol c   = BitmapCol_Make(data[0], data[1], data[2], data[3]);
+	cc_uint8 code = data[4];
+
+	/* disallow space, null, and color code specifiers */
+	if (code == '\0' || code == ' ' || code == 0xFF) return;
+	if (code == '%'  || code == '&') return;
+
+	Drawer2D.Colors[code] = c;
+	Event_RaiseInt(&ChatEvents.ColCodeChanged, code);
+}
+
+static void CPE_SetMapEnvUrl(cc_uint8* data) {
+	char urlBuffer[URL_MAX_SIZE];
+	cc_string url;
+
+	cc_string part1 = UNSAFE_GetString(data);
+	String_InitArray(url, urlBuffer);
+	String_Copy(&url, &part1);
+
+	/* Version 1 only supports URLs up to 64 characters long */
+	/* Version 2 supports URLs up to 128 characters long */
+	if (envMapAspect_Ext.serverVersion > 1) {
+		cc_string part2 = UNSAFE_GetString(data + 64);
+		String_AppendString(&url, &part2);
+	}
+	CPE_ApplyTexturePack(&url);
+}
+
+static void CPE_SetMapEnvProperty(cc_uint8* data) {
+	int value = (int)Stream_GetU32_BE(data + 1);
+	Math_Clamp(value, -0xFFFFFF, 0xFFFFFF);
+
+	switch (data[0]) {
+	case 0:
+		Math_Clamp(value, 0, BLOCK_MAX_DEFINED);
+		Env_SetSidesBlock((BlockID)value); break;
+	case 1:
+		Math_Clamp(value, 0, BLOCK_MAX_DEFINED);
+		Env_SetEdgeBlock((BlockID)value); break;
+	case 2:
+		Env_SetEdgeHeight(value); break;
+	case 3:
+		Env_SetCloudsHeight(value); break;
+	case 4:
+		Math_Clamp(value, -0x7FFF, 0x7FFF);
+		Game_MaxViewDistance = value <= 0 ? DEFAULT_MAX_VIEWDIST : value;
+		Game_SetViewDistance(Game_UserViewDistance); break;
+	case 5:
+		Env_SetCloudsSpeed(value  / 256.0f); break;
+	case 6:
+		Env_SetWeatherSpeed(value / 256.0f); break;
+	case 7:
+		Env_SetWeatherFade(value  / 128.0f); break;
+	case 8:
+		Env_SetExpFog(value != 0); break;
+	case 9:
+		Env_SetSidesOffset(value); break;
+	case 10:
+		Env_SetSkyboxHorSpeed(value / 1024.0f); break;
+	case 11:
+		Env_SetSkyboxVerSpeed(value / 1024.0f); break;
+	}
+}
+
+static void CPE_SetEntityProperty(cc_uint8* data) {
+	struct LocationUpdate update;
+	struct Entity* e;
+	float scale;
+
+	EntityID id   = data[0];
+	cc_uint8 type = data[1];
+	int value     = (int)Stream_GetU32_BE(data + 2);
+
+	e = Entities.List[id];
+	if (!e) return;
+
+	switch (type) {
+	case 0:
+		update.flags = LU_HAS_ROTX | LU_ORI_INTERPOLATE;
+		update.rotX  = (float)value; break;
+	case 1:
+		update.flags = LU_HAS_YAW  | LU_ORI_INTERPOLATE;
+		update.yaw   = (float)value; break;
+	case 2:
+		update.flags = LU_HAS_ROTZ | LU_ORI_INTERPOLATE;
+		update.rotZ  = (float)value; break;
+
+	case 3:
+	case 4:
+	case 5:
+		scale = value / 1000.0f;
+		if (e->Flags & ENTITY_FLAG_MODEL_RESTRICTED_SCALE) {
+			Math_Clamp(scale, 0.01f, e->Model->maxScale);
+		}
+
+		if (type == 3) e->ModelScale.x = scale;
+		if (type == 4) e->ModelScale.y = scale;
+		if (type == 5) e->ModelScale.z = scale;
+
+		Entity_UpdateModelBounds(e);
+		return;
+	default:
+		return;
+	}
+	e->VTABLE->SetLocation(e, &update);
+}
+
+static void CPE_TwoWayPing(cc_uint8* data) {
+	cc_uint8 serverToClient = data[0];
+	int id = Stream_GetU16_BE(data + 1);
+	cc_uint8 tmp[32];
+
+	/* handle client>server ping response from server */
+	if (!serverToClient) { Ping_Update(id); return; }
+
+	/* send server>client ping response to server */
+	data = CPE_WriteTwoWayPing(tmp, true, id);
+	Server.SendData(tmp, (cc_uint32)(data - tmp));
+}
+
+static void CPE_SetInventoryOrder(cc_uint8* data) {
+	BlockID block, order;
+	ReadBlock(data, block);
+	ReadBlock(data, order);
+
+	Inventory_Remove(block);
+	if (order) { Inventory.Map[order - 1] = block; }
+}
+
+static void CPE_SetHotbar(cc_uint8* data) {
+	BlockID block;
+	cc_uint8 index;
+	ReadBlock(data, block);
+	index = *data;
+
+	if (index >= INVENTORY_BLOCKS_PER_HOTBAR) return;
+	Inventory_Set(index, block);
+}
+
+static void CPE_SetSpawnPoint(cc_uint8* data) {
+	struct LocalPlayer* p = Entities.CurPlayer;
+	int x, y, z;
+
+	if (IsSupported(extEntityPos_Ext)) {
+		x = (int)Stream_GetU32_BE(&data[0]);
+		y = (int)Stream_GetU32_BE(&data[4]);
+		z = (int)Stream_GetU32_BE(&data[8]);
+		data += 12;
+	} else {
+		x = (cc_int16)Stream_GetU16_BE(&data[0]);
+		y = (cc_int16)Stream_GetU16_BE(&data[2]);
+		z = (cc_int16)Stream_GetU16_BE(&data[4]);
+		data += 6;
+	}
+	p->SpawnYaw   = Math_Packed2Deg(*data++);
+	p->SpawnPitch = Math_Packed2Deg(*data++);
+
+	y -= 51; /* Convert to feet position */
+	Vec3_Set(p->Spawn, (float)(x / 32.0f), (float)(y / 32.0f), (float)(z / 32.0f));
+}
+
+static void CalcVelocity(float* vel, cc_uint8* src, cc_uint8 mode) {
+	int raw     = (int)Stream_GetU32_BE(src);
+	float value = Math_AbsF(raw / 10000.0f);
+	value       = Math_Sign(raw) * PhysicsComp_CalcJumpVelocity(value);
+
+	if (mode == 0) *vel += value;
+	if (mode == 1) *vel = value;
+
+	if (*vel < -1024) *vel = -1024;
+	if (*vel > +1024) *vel = +1024;
+}
+
+static void CPE_VelocityControl(cc_uint8* data) {
+	struct LocalPlayer* p = Entities.CurPlayer;
+	CalcVelocity(&p->Base.Velocity.x, data + 0, data[12]);
+	CalcVelocity(&p->Base.Velocity.y, data + 4, data[13]);
+	CalcVelocity(&p->Base.Velocity.z, data + 8, data[14]);
+}
+
+static void CPE_DefineEffect(cc_uint8* data) {
+	struct CustomParticleEffect* e = &Particles_CustomEffects[data[0]];
+
+	/* e.g. bounds of 0,0, 15,15 gives an 8x8 icon in the default 128x128 particles.png */
+	e->rec.u1 = data[1]       / 256.0f;
+	e->rec.v1 = data[2]       / 256.0f;
+	e->rec.u2 = (data[3] + 1) / 256.0f;
+	e->rec.v2 = (data[4] + 1) / 256.0f;
+
+	e->tintCol       = PackedCol_Make(data[5], data[6], data[7], 255);
+	e->frameCount    = data[8];
+	e->particleCount = data[9];
+	e->size          = data[10] / 32.0f; /* 32 units per block */
+
+	e->sizeVariation      = (int)Stream_GetU32_BE(data + 11) / 10000.0f;
+	e->spread             =      Stream_GetU16_BE(data + 15) / 32.0f;
+	e->speed              = (int)Stream_GetU32_BE(data + 17) / 10000.0f;
+	e->gravity            = (int)Stream_GetU32_BE(data + 21) / 10000.0f;
+	e->baseLifetime       = (int)Stream_GetU32_BE(data + 25) / 10000.0f;
+	e->lifetimeVariation  = (int)Stream_GetU32_BE(data + 29) / 10000.0f;
+
+	e->collideFlags = data[33];
+	e->fullBright   = data[34];
+}
+
+static void CPE_SpawnEffect(cc_uint8* data) {
+	float x, y, z, originX, originY, originZ;
+
+	x       = (int)Stream_GetU32_BE(data +  1) / 32.0f;
+	y       = (int)Stream_GetU32_BE(data +  5) / 32.0f;
+	z       = (int)Stream_GetU32_BE(data +  9) / 32.0f;
+	originX = (int)Stream_GetU32_BE(data + 13) / 32.0f;
+	originY = (int)Stream_GetU32_BE(data + 17) / 32.0f;
+	originZ = (int)Stream_GetU32_BE(data + 21) / 32.0f;
+
+	Particles_CustomEffect(data[0], x, y, z, originX, originY, originZ);
+}
+
+static void CPE_PluginMessage(cc_uint8* data) {
+	cc_uint8 channel = data[0];
+	Event_RaisePluginMessage(&NetEvents.PluginMessageReceived, channel, data + 1);
+}
+
+static void CPE_ExtEntityTeleport(cc_uint8* data) {
+	EntityID id = *data++;
+	cc_uint8 packetFlags = *data++;
+	cc_uint8 flags = 0;
+
+	/* bit  0    includes position */
+	/* bits 1-2  position mode(absolute_instant / absolute_smooth / relative_smooth / relative_seamless) */
+	/* bit  3    unused */
+	/* bit  4    includes orientation */
+	/* bit  5    interpolate ori */
+	/* bit  6-7  unused */
+
+	if (packetFlags & 1) flags |= LU_HAS_POS;
+	flags |= (packetFlags & 6) << 4; /* bit-and with 00000110 to isolate only pos mode, then left shift by 4 to match client mode offset */
+	if (packetFlags & 16) flags |= LU_HAS_PITCH | LU_HAS_YAW;
+	if (packetFlags & 32) flags |= LU_ORI_INTERPOLATE;
+
+	Classic_ReadAbsoluteLocation(data, id, flags);
+}
+
+static void CPE_LightingMode(cc_uint8* data) {
+	cc_uint8  mode = *data++;
+	cc_bool locked = *data++ != 0;
+
+	if (mode == 0) {
+		if (!Lighting_ModeSetByServer) return;
+		/* locked is ignored with mode 0 and always set to false */
+		Lighting_ModeLockedByServer = false;
+		Lighting_ModeSetByServer    = false;
+
+		Lighting_SetMode(Lighting_ModeUserCached, true);
+		return;
+	}
+	/* Convert from Network mode (0 = no change, 1 = classic, 2 = fancy) to client mode (0 = classic, 1 = fancy) */
+	mode--;
+	if (mode >= LIGHTING_MODE_COUNT) return;
+
+	if (!Lighting_ModeSetByServer) Lighting_ModeUserCached = Lighting_Mode;
+	Lighting_ModeLockedByServer = locked;
+	Lighting_ModeSetByServer    = true;
+
+	Lighting_SetMode(mode, true);
+}
+
+static void CPE_Reset(void) {
+	cpe_serverExtensionsCount = 0; cpe_pingTicks = 0;
+	CPEExtensions_Reset();
+	cpe_needD3Fix = false;
+	Game_UseCPEBlocks = false;
+	if (!Game_Version.HasCPE) return;
+
+	Net_Set(OPCODE_EXT_INFO, CPE_ExtInfo, 67);
+	Net_Set(OPCODE_EXT_ENTRY, CPE_ExtEntry, 69);
+	Net_Set(OPCODE_SET_REACH, CPE_SetClickDistance, 3);
+	Net_Set(OPCODE_CUSTOM_BLOCK_LEVEL, CPE_CustomBlockLevel, 2);
+	Net_Set(OPCODE_HOLD_THIS, CPE_HoldThis, 3);
+	Net_Set(OPCODE_SET_TEXT_HOTKEY, CPE_SetTextHotkey, 134);
+
+	Net_Set(OPCODE_EXT_ADD_PLAYER_NAME, CPE_ExtAddPlayerName, 196);
+	Net_Set(OPCODE_EXT_ADD_ENTITY, CPE_ExtAddEntity, 130);
+	Net_Set(OPCODE_EXT_REMOVE_PLAYER_NAME, CPE_ExtRemovePlayerName, 3);
+
+	Net_Set(OPCODE_ENV_SET_COLOR, CPE_SetEnvCol, 8);
+	Net_Set(OPCODE_MAKE_SELECTION, CPE_MakeSelection, 86);
+	Net_Set(OPCODE_REMOVE_SELECTION, CPE_RemoveSelection, 2);
+	Net_Set(OPCODE_SET_BLOCK_PERMISSION, CPE_SetBlockPermission, 4);
+	Net_Set(OPCODE_SET_MODEL, CPE_ChangeModel, 66);
+	Net_Set(OPCODE_ENV_SET_MAP_APPEARANCE, CPE_EnvSetMapAppearance, 69);
+	Net_Set(OPCODE_ENV_SET_WEATHER, CPE_EnvWeatherType, 2);
+	Net_Set(OPCODE_HACK_CONTROL, CPE_HackControl, 8);
+	Net_Set(OPCODE_EXT_ADD_ENTITY2, CPE_ExtAddEntity2, 138);
+
+	Net_Set(OPCODE_BULK_BLOCK_UPDATE, CPE_BulkBlockUpdate, 1282);
+	Net_Set(OPCODE_SET_TEXT_COLOR, CPE_SetTextColor, 6);
+	Net_Set(OPCODE_ENV_SET_MAP_URL, CPE_SetMapEnvUrl, 65);
+	Net_Set(OPCODE_ENV_SET_MAP_PROPERTY, CPE_SetMapEnvProperty, 6);
+	Net_Set(OPCODE_SET_ENTITY_PROPERTY, CPE_SetEntityProperty, 7);
+	Net_Set(OPCODE_TWO_WAY_PING, CPE_TwoWayPing, 4);
+	Net_Set(OPCODE_SET_INVENTORY_ORDER, CPE_SetInventoryOrder, 3);
+	Net_Set(OPCODE_SET_HOTBAR, CPE_SetHotbar, 3);
+	Net_Set(OPCODE_SET_SPAWNPOINT, CPE_SetSpawnPoint, 9);
+	Net_Set(OPCODE_VELOCITY_CONTROL, CPE_VelocityControl, 16);
+	Net_Set(OPCODE_DEFINE_EFFECT, CPE_DefineEffect, 36);
+	Net_Set(OPCODE_SPAWN_EFFECT, CPE_SpawnEffect, 26);
+	Net_Set(OPCODE_PLUGIN_MESSAGE, CPE_PluginMessage, 66);
+	Net_Set(OPCODE_ENTITY_TELEPORT_EXT, CPE_ExtEntityTeleport, 11);
+	Net_Set(OPCODE_LIGHTING_MODE, CPE_LightingMode, 3);
+}
+
+static cc_uint8* CPE_Tick(cc_uint8* data) {
+	cpe_pingTicks++;
+	if (cpe_pingTicks >= 20 && IsSupported(twoWayPing_Ext)) {
+		data = CPE_WriteTwoWayPing(data, false, Ping_NextPingId());
+		cpe_pingTicks = 0;
+	}
+	return data;
+}
+
+#ifdef CUSTOM_MODELS
+/*########################################################################################################################*
+*------------------------------------------------------Custom models------------------------------------------------------*
+*#########################################################################################################################*/
+static void CPE_DefineModel(cc_uint8* data) {
+	struct CustomModel* cm = CustomModel_Get(data[0]);
+	cc_string name;
+	cc_uint8 flags;
+	cc_uint8 numParts;
+
+	if (!cm) return;
+	CustomModel_Undefine(cm);
+	Model_Init(&cm->model);
+
+	name = UNSAFE_GetString(data + 1);
+	String_CopyToRawArray(cm->name, &name);
+
+	flags = data[65];
+	cm->model.bobbing        = flags & 0x01;
+	cm->model.pushes         = flags & 0x02;
+	cm->model.usesHumanSkin  = flags & 0x04;
+	cm->model.calcHumanAnims = flags & 0x08;
+
+	cm->nameY = GetFloat(data + 66);
+	cm->eyeY  = GetFloat(data + 70);
+
+	cm->collisionBounds.x = GetFloat(data + 74);
+	cm->collisionBounds.y = GetFloat(data + 78);
+	cm->collisionBounds.z = GetFloat(data + 82);
+
+	cm->pickingBoundsAABB.Min.x = GetFloat(data + 86);
+	cm->pickingBoundsAABB.Min.y = GetFloat(data + 90);
+	cm->pickingBoundsAABB.Min.z = GetFloat(data + 94);
+
+	cm->pickingBoundsAABB.Max.x = GetFloat(data + 98);
+	cm->pickingBoundsAABB.Max.y = GetFloat(data + 102);
+	cm->pickingBoundsAABB.Max.z = GetFloat(data + 106);
+
+	cm->uScale = Stream_GetU16_BE(data + 110);
+	cm->vScale = Stream_GetU16_BE(data + 112);
+	numParts   = data[114];
+
+	if (numParts > MAX_CUSTOM_MODEL_PARTS) {
+		int maxParts = MAX_CUSTOM_MODEL_PARTS;
+		Chat_Add2("&cCustom Model '%s' exceeds parts limit of %i", &name, &maxParts);
+		return;
+	}
+
+	cm->numParts = numParts;
+	cm->model.vertices = (struct ModelVertex*)Mem_AllocCleared(numParts * MODEL_BOX_VERTICES,
+												sizeof(struct ModelVertex), "CustomModel vertices");
+	cm->defined = true;
+}
+
+static void CPE_DefineModelPart(cc_uint8* data) {
+	struct CustomModel* m;
+	struct CustomModelPart* part;
+	struct CustomModelPartDef p;
+	int i;
+
+	m = CustomModel_Get(data[0]);
+	if (!m || !m->defined || m->curPartIndex >= m->numParts) return;
+	part = &m->parts[m->curPartIndex];
+
+	p.min.x = GetFloat(data +  1);
+	p.min.y = GetFloat(data +  5);
+	p.min.z = GetFloat(data +  9);
+	p.max.x = GetFloat(data + 13);
+	p.max.y = GetFloat(data + 17);
+	p.max.z = GetFloat(data + 21);
+
+	/* read u, v coords for our 6 faces */
+	for (i = 0; i < 6; i++) 
+	{
+		p.u1[i] = Stream_GetU16_BE(data + 25 + (i*8 + 0));
+		p.v1[i] = Stream_GetU16_BE(data + 25 + (i*8 + 2));
+		p.u2[i] = Stream_GetU16_BE(data + 25 + (i*8 + 4));
+		p.v2[i] = Stream_GetU16_BE(data + 25 + (i*8 + 6));
+	}
+
+	p.rotationOrigin.x = GetFloat(data + 73);
+	p.rotationOrigin.y = GetFloat(data + 77);
+	p.rotationOrigin.z = GetFloat(data + 81);
+
+	part->rotation.x = GetFloat(data + 85);
+	part->rotation.y = GetFloat(data + 89);
+	part->rotation.z = GetFloat(data + 93);
+
+	if (customModels_Ext.serverVersion == 1) {
+		/* ignore animations */
+		p.flags = data[102];
+	} else {
+		p.flags = data[165];
+
+		data += 97;
+		for (i = 0; i < MAX_CUSTOM_MODEL_ANIMS; i++) 
+		{
+			cc_uint8 tmp = *data++;
+			part->anims[i].type = tmp & 0x3F;
+			part->anims[i].axis = tmp >> 6;
+
+			part->anims[i].a = GetFloat(data);
+			data += 4;
+			part->anims[i].b = GetFloat(data);
+			data += 4;
+			part->anims[i].c = GetFloat(data);
+			data += 4;
+			part->anims[i].d = GetFloat(data);
+			data += 4;
+		}
+	}
+
+	CustomModel_BuildPart(m, &p);
+	m->curPartIndex++;
+	if (m->curPartIndex == m->numParts) CustomModel_Register(m);
+}
+
+static void CPE_UndefineModel(cc_uint8* data) {
+	struct CustomModel* cm = CustomModel_Get(data[0]);
+	if (cm) CustomModel_Undefine(cm);
+}
+
+static void CustomModels_Reset(void) {
+	if (!Game_Version.HasCPE) return;
+
+	Net_Set(OPCODE_DEFINE_MODEL,      CPE_DefineModel, 116);
+	Net_Set(OPCODE_DEFINE_MODEL_PART, CPE_DefineModelPart, 104);
+	Net_Set(OPCODE_UNDEFINE_MODEL,    CPE_UndefineModel, 2);
+}
+#else
+static void CustomModels_Reset(void) { }
+#endif
+
+
+/*########################################################################################################################*
+*------------------------------------------------------Custom blocks------------------------------------------------------*
+*#########################################################################################################################*/
+static void BlockDefs_OnBlocksLightPropertyUpdated(BlockID block, cc_bool oldProp) {
+	if (!World.Loaded) return;
+	/* Need to refresh lighting when a block's light blocking state changes */
+	if (Blocks.BlocksLight[block] != oldProp) Lighting.Refresh();
+}
+
+static void BlockDefs_OnBrightnessPropertyUpdated(BlockID block, cc_uint8 oldProp) {
+	if (!World.Loaded) return;
+	if (Lighting_Mode == LIGHTING_MODE_CLASSIC) return;
+	/* Need to refresh fancy lighting when a block's brightness changes */
+	if (Blocks.Brightness[block] != oldProp) Lighting.Refresh();
+}
+
+static TextureLoc BlockDefs_Tex(cc_uint8** ptr) {
+	TextureLoc loc; 
+	cc_uint8* data = *ptr;
+
+	if (!IsSupported(extTextures_Ext)) {
+		loc = *data++;
+	} else {
+		loc = Stream_GetU16_BE(data) % ATLAS1D_MAX_ATLASES; data += 2;
+	}
+
+	*ptr = data; return loc;
+}
+
+static BlockID BlockDefs_DefineBlockCommonStart(cc_uint8** ptr, cc_bool uniqueSideTexs) {
+	cc_string name;
+	BlockID block;
+	cc_bool oldBlocksLight;
+	cc_uint8 oldBrightness;
+	float speedLog2;
+	cc_uint8 sound;
+	cc_uint8* data = *ptr;
+
+	ReadBlock(data, block);
+	oldBlocksLight = Blocks.BlocksLight[block];
+	oldBrightness = Blocks.Brightness[block];
+	Block_ResetProps(block);
+	
+	name = UNSAFE_GetString(data); data += STRING_SIZE;
+	Block_SetName(block, &name);
+	Blocks.Collide[block] = *data++;
+
+	speedLog2 = (*data++ - 128) / 64.0f;
+	Blocks.SpeedMultiplier[block] = (float)Math_Exp2(speedLog2);
+
+	Block_Tex(block, FACE_YMAX) = BlockDefs_Tex(&data);
+	if (uniqueSideTexs) {
+		Block_Tex(block, FACE_XMIN) = BlockDefs_Tex(&data);
+		Block_Tex(block, FACE_XMAX) = BlockDefs_Tex(&data);
+		Block_Tex(block, FACE_ZMIN) = BlockDefs_Tex(&data);
+		Block_Tex(block, FACE_ZMAX) = BlockDefs_Tex(&data);
+	} else {
+		Block_SetSide(BlockDefs_Tex(&data), block);
+	}
+	Block_Tex(block, FACE_YMIN) = BlockDefs_Tex(&data);
+
+	Blocks.BlocksLight[block] = *data++ == 0;
+	BlockDefs_OnBlocksLightPropertyUpdated(block, oldBlocksLight);
+
+	sound = *data++;
+	Blocks.StepSounds[block] = sound;
+	Blocks.DigSounds[block]  = sound;
+	if (sound == SOUND_GLASS) Blocks.StepSounds[block] = SOUND_STONE;
+
+	Blocks.Brightness[block] = Block_ReadBrightness(*data++);
+	BlockDefs_OnBrightnessPropertyUpdated(block, oldBrightness);
+	*ptr = data;
+	return block;
+}
+
+static void BlockDefs_DefineBlockCommonEnd(cc_uint8* data, cc_uint8 shape, BlockID block) {
+	cc_uint8 draw = data[0];
+	if (shape == 0) {
+		Blocks.SpriteOffset[block] = draw;
+		draw = DRAW_SPRITE;
+	}
+	Blocks.Draw[block] = draw;
+
+	Blocks.FogDensity[block] = data[1] == 0 ? 0.0f : (data[1] + 1) / 128.0f;
+	Blocks.FogCol[block]     = PackedCol_Make(data[2], data[3], data[4], 255);
+}
+
+static void BlockDefs_DefineBlock(cc_uint8* data) {
+	BlockID block = BlockDefs_DefineBlockCommonStart(&data, false);
+
+	cc_uint8 shape = *data++;
+	if (shape > 0 && shape <= 16) {
+		Blocks.MaxBB[block].y = shape / 16.0f;
+	}
+
+	BlockDefs_DefineBlockCommonEnd(data, shape, block);
+	Block_DefineCustom(block, true);
+}
+
+static void BlockDefs_UndefineBlock(cc_uint8* data) {
+	BlockID block;
+	cc_bool didBlockLight;
+
+	ReadBlock(data, block);
+	didBlockLight = Blocks.BlocksLight[block];
+
+	Block_UndefineCustom(block);
+	BlockDefs_OnBlocksLightPropertyUpdated(block, didBlockLight);
+}
+
+static void BlockDefs_DefineBlockExt(cc_uint8* data) {
+	Vec3 minBB, maxBB;
+	BlockID block = BlockDefs_DefineBlockCommonStart(&data, 
+						blockDefsExt_Ext.serverVersion >= 2);
+
+	minBB.x = (cc_int8)(*data++) / 16.0f;
+	minBB.y = (cc_int8)(*data++) / 16.0f;
+	minBB.z = (cc_int8)(*data++) / 16.0f;
+
+	maxBB.x = (cc_int8)(*data++) / 16.0f;
+	maxBB.y = (cc_int8)(*data++) / 16.0f;
+	maxBB.z = (cc_int8)(*data++) / 16.0f;
+
+	Blocks.MinBB[block] = minBB;
+	Blocks.MaxBB[block] = maxBB;
+	BlockDefs_DefineBlockCommonEnd(data, 1, block);
+	Block_DefineCustom(block, false);
+}
+
+static void BlockDefs_Reset(void) {
+	if (!Game_Version.HasCPE || !Game_AllowCustomBlocks) return;
+	Net_Set(OPCODE_DEFINE_BLOCK,     BlockDefs_DefineBlock,    80);
+	Net_Set(OPCODE_UNDEFINE_BLOCK,   BlockDefs_UndefineBlock,  2);
+	Net_Set(OPCODE_DEFINE_BLOCK_EXT, BlockDefs_DefineBlockExt, 85);
+}
+
+
+/*########################################################################################################################*
+*-----------------------------------------------------Public handlers-----------------------------------------------------*
+*#########################################################################################################################*/
+static void Protocol_Reset(void) {
+	Classic_Reset();
+	CPE_Reset();
+	BlockDefs_Reset();
+	CustomModels_Reset();
+	WoM_Reset();
+}
+
+void Protocol_Tick(void) {
+	cc_uint8 tmp[256];
+	cc_uint8* data = tmp;
+
+	data = Classic_Tick(data);
+	data = CPE_Tick(data);
+	WoM_Tick();
+
+	/* Have any packets been written? */
+	if (data == tmp) return;
+	Server.SendData(tmp, (cc_uint32)(data - tmp));
+}
+
+static void OnInit(void) {
+	if (Server.IsSinglePlayer) return;
+	Protocol_Reset();
+}
+
+static void OnReset(void) {
+	if (Server.IsSinglePlayer) return;
+	Mem_Set(&Protocol, 0, sizeof(Protocol));
+	Protocol_Reset();
+	FreeMapStates();
+}
+#else
+void CPE_SendPlayerClick(int button, cc_bool pressed, cc_uint8 targetId, struct RayTracer* t) { }
+
+static void OnInit(void) { }
+
+static void OnReset(void) { }
+#endif
+
+struct IGameComponent Protocol_Component = {
+	OnInit,  /* Init  */
+	NULL,    /* Free  */
+	OnReset, /* Reset */
+};