added missing audio random.burp when finishing a food item

CMakeLists.txt

@@ -111,6 +111,7 @@ CPMAddPackage(
         "ALSOFT_STATIC_LIBGCC ON"
 )
 
+# TODO: Clear this paths with *
 file(GLOB SERVER_SOURCES
     "project/lib_projects/raknet/jni/RaknetSources/*.cpp"
     "src/NinecraftApp.cpp"
@@ -149,6 +150,7 @@ file(GLOB SERVER_SOURCES
 
     "src/platform/CThread.cpp"
     "src/platform/HttpClient.cpp"
+    "src/platform/PngLoader.cpp"
     "src/platform/time.cpp"
 
     "src/platform/input/Controller.cpp"
@@ -210,7 +212,6 @@ file(GLOB SERVER_SOURCES
     "src/world/level/tile/entity/*.cpp"
 
     "src/world/phys/HitResult.cpp"
-    "src/commands/*.cpp"
 ) 
 
 file(GLOB CLIENT_SOURCES 
@@ -292,8 +293,6 @@ file(GLOB CLIENT_SOURCES
 
     "src/AppPlatform_glfw.cpp"
     "src/main.cpp"
-
-    "src/commands/*.cpp"
 )
 
 if (${PLATFORM} STREQUAL "Desktop")
@@ -301,16 +300,18 @@ if (${PLATFORM} STREQUAL "Desktop")
 endif()
 
 # Server
-add_executable("${PROJECT_NAME}-server" ${SERVER_SOURCES})
+if(UNIX)
+    add_executable("${PROJECT_NAME}-server" ${SERVER_SOURCES})
 
-target_compile_definitions("${PROJECT_NAME}-server" PUBLIC "STANDALONE_SERVER" "SERVER_PROFILER")
+    target_compile_definitions("${PROJECT_NAME}-server" PUBLIC "STANDALONE_SERVER" "SERVER_PROFILER")
 
-target_include_directories("${PROJECT_NAME}-server" PUBLIC 
+    target_include_directories("${PROJECT_NAME}-server" PUBLIC 
-    "${CMAKE_SOURCE_DIR}/src/"
+        "${CMAKE_SOURCE_DIR}/src/"
-    "project/lib_projects/raknet/jni/RaknetSources"
+        "project/lib_projects/raknet/jni/RaknetSources"
-)
+    )
 
-target_link_libraries("${PROJECT_NAME}-server" ${CMAKE_THREAD_LIBS_INIT})
+    target_link_libraries("${PROJECT_NAME}-server" ${CMAKE_THREAD_LIBS_INIT})
+endif()
 
 add_executable(${PROJECT_NAME} ${CLIENT_SOURCES})
 

project/android/jni/Android.mk

@@ -109,7 +109,6 @@ LOCAL_SRC_FILES := ../../../src/main.cpp \
 ../../../src/client/renderer/Textures.cpp \
 ../../../src/client/renderer/TileRenderer.cpp \
 ../../../src/client/renderer/gles.cpp \
-../../../src/world/level/LevelConstants.cpp \
 ../../../src/client/renderer/culling/Frustum.cpp \
 ../../../src/client/renderer/entity/ArrowRenderer.cpp \
 ../../../src/client/renderer/entity/ChickenRenderer.cpp \
@@ -140,12 +139,6 @@ LOCAL_SRC_FILES := ../../../src/main.cpp \
 ../../../src/network/Packet.cpp \
 ../../../src/network/RakNetInstance.cpp \
 ../../../src/network/ServerSideNetworkHandler.cpp \
-../../../src/commands/Command.cpp \
-../../../src/commands/CommandHelp.cpp \
-../../../src/commands/CommandKick.cpp \
-../../../src/commands/CommandBan.cpp \
-../../../src/commands/CommandManager.cpp \
-../../../src/commands/CommandOp.cpp \
 ../../../src/server/ServerLevel.cpp \
 ../../../src/server/ServerPlayer.cpp \
 ../../../src/util/DataIO.cpp \

project/android_java/jni/Android.mk

@@ -228,7 +228,6 @@ LOCAL_SRC_FILES := ../../../src/main.cpp \
 ../../../src/world/level/tile/entity/TileEntity.cpp \
 ../../../src/world/level/tile/entity/FurnaceTileEntity.cpp \
 ../../../src/world/phys/HitResult.cpp
-../../../src/world/level/LevelConstants.cpp
 
 LOCAL_CFLAGS := -Wno-psabi $(LOCAL_CFLAGS)
 

project/android_java/src/com/mojang/minecraftpe/sound/SoundPlayer.java

@@ -129,6 +129,7 @@ public class SoundPlayer
 			new SoundId(R.raw.eat1, "random.eat"),
 			new SoundId(R.raw.eat2, "random.eat"),
 			new SoundId(R.raw.eat3, "random.eat"),
+			new SoundId(R.raw.burp1, "random.burp"),
 			new SoundId(R.raw.fuse, "random.fuse"),
 
 			new SoundId(R.raw.zpig1, "mob.zombiepig.zpig"),

src/NinecraftApp.cpp

@@ -136,7 +136,7 @@ void NinecraftApp::teardown()
 	Recipes ::teardownRecipes();
 	TileEntity::teardownTileEntities();
 #endif
-#if defined(WIN32) && !defined(STANDALONE_SERVER)
+#ifdef WIN32
 	ItemRenderer::teardown_static();
 	if (EntityTileRenderer::instance != NULL) {
 		delete EntityTileRenderer::instance;

src/client/Minecraft.cpp

@@ -2,7 +2,6 @@
 #include "Options.h"
 #include "client/Options.h"
 #include "client/player/input/IBuildInput.h"
-#include "commands/CommandManager.hpp"
 #include "platform/input/Keyboard.h"
 #include "world/item/Item.h"
 #include "world/item/ItemInstance.h"
@@ -176,8 +175,7 @@ Minecraft::Minecraft() :
 	_powerVr(false),
 	commandPort(4711),
 	reserved_d1(0),reserved_d2(0),
-	reserved_f1(0),reserved_f2(0), options(this),
+	reserved_f1(0),reserved_f2(0), options(this)
-	m_commandManager()
 {
 //#ifdef ANDROID
 
@@ -258,10 +256,9 @@ void Minecraft::selectLevel( const std::string& levelId, const std::string& leve
 
 void Minecraft::setLevel(Level* level, const std::string& message /* ="" */, LocalPlayer* forceInsertPlayer /* = NULL */) {
 	cameraTargetPlayer = NULL;
+	LOGI("Seed is %ld\n", level->getSeed());
 
 	if (level != NULL) {
-		LOGI("Seed is %ld\n", level->getSeed());
-
 		level->raknetInstance = raknetInstance;
         gameMode->initLevel(level);
 
@@ -278,11 +275,6 @@ void Minecraft::setLevel(Level* level, const std::string& message /* ="" */, Loc
 			}
 		}
 		this->level = level;
-		// So uhhh
-		std::string op = options.getStringValue(OPTIONS_USERNAME);
-    	std::transform(op.begin(), op.end(), op.begin(), ::tolower);
-
-		level->ops.emplace(op);
 		_hasSignaledGeneratingLevelFinished = false;
 #ifdef STANDALONE_SERVER
 		const bool threadedLevelCreation = false;
@@ -366,10 +358,10 @@ void Minecraft::prepareLevel(const std::string& title) {
 	if (!level->isNew())
 		level->setUpdateLights(false);
 
-	int Max = LevelConstants::CHUNK_CACHE_WIDTH * LevelConstants::CHUNK_CACHE_WIDTH;
+	int Max = CHUNK_CACHE_WIDTH * CHUNK_CACHE_WIDTH;
 	int pp = 0;
-	for (int x = 8; x < (LevelConstants::CHUNK_CACHE_WIDTH * LevelConstants::CHUNK_WIDTH); x += LevelConstants::CHUNK_WIDTH) {
+	for (int x = 8; x < (CHUNK_CACHE_WIDTH * CHUNK_WIDTH); x += CHUNK_WIDTH) {
-        for (int z = 8; z < (LevelConstants::CHUNK_CACHE_WIDTH * LevelConstants::CHUNK_WIDTH); z += LevelConstants::CHUNK_WIDTH) {
+        for (int z = 8; z < (CHUNK_CACHE_WIDTH * CHUNK_WIDTH); z += CHUNK_WIDTH) {
             progressStagePercentage = 100 * pp++ / Max;
             //printf("level generation progress %d\n", progressStagePercentage);
 			B.start();
@@ -386,9 +378,9 @@ void Minecraft::prepareLevel(const std::string& title) {
 	level->setUpdateLights(true);
 
 	C.start();
-	for (int x = 0; x < LevelConstants::CHUNK_CACHE_WIDTH; x++)
+	for (int x = 0; x < CHUNK_CACHE_WIDTH; x++)
 	{
-		for (int z = 0; z < LevelConstants::CHUNK_CACHE_WIDTH; z++)
+		for (int z = 0; z < CHUNK_CACHE_WIDTH; z++)
 		{
 			LevelChunk* chunk = level->getChunk(x, z);
 			if (chunk && !chunk->createdFromSave)
@@ -735,21 +727,6 @@ void Minecraft::tickInput() {
 				options.toggle(OPTIONS_RENDER_DEBUG);
 			}
 
-			// TODO: replace it with client /give command :face_vomiting:
-			// if (key == Keyboard::KEY_F4) {
-			// 	player->inventory->add(new ItemInstance(Tile::redBrick));
-			// 	player->inventory->add(new ItemInstance(Item::ironIngot, 64));
-			// 	player->inventory->add(new ItemInstance(Item::ironIngot, 34));
-			// 	player->inventory->add(new ItemInstance(Tile::stonecutterBench));
-			// 	player->inventory->add(new ItemInstance(Tile::workBench));
-			// 	player->inventory->add(new ItemInstance(Tile::furnace));
-			// 	player->inventory->add(new ItemInstance(Tile::wood, 54));
-			// 	player->inventory->add(new ItemInstance(Item::stick, 14));
-			// 	player->inventory->add(new ItemInstance(Item::coal, 31));
-			// 	player->inventory->add(new ItemInstance(Tile::sand, 6));
-
-			// }
-
 			if (key == Keyboard::KEY_F5) {
 				options.toggle(OPTIONS_THIRD_PERSON_VIEW);
 				/*
@@ -1138,7 +1115,6 @@ bool Minecraft::supportNonTouchScreen() {
 }
 void Minecraft::init()
 {
-	LevelChunk::ChunkBlockCount = LevelConstants::CHUNK_BLOCK_COUNT;
 #ifndef STANDALONE_SERVER
 	checkGlError("Init enter");
 
@@ -1328,8 +1304,11 @@ bool Minecraft::joinMultiplayerFromString( const std::string& server )
 		ip = server;
 	}
 
+	printf("%s \n", port.c_str());
+	
 	if (isLookingForMultiplayer && netCallback) {
 		isLookingForMultiplayer = false;
+		printf("test");
 		int portNum = atoi(port.c_str());
 		return raknetInstance->connect(ip.c_str(), portNum);
 	}
@@ -1603,11 +1582,3 @@ void Minecraft::optionUpdated(OptionId option, int value ) {
         setSize(width, height);
     }
 }
-
-void Minecraft::addMessage(const std::string& msg) {
-#ifndef STANDALONE_SERVER
-	gui.addMessage(msg);
-#else 
-	LOGI("%s \n", msg.c_str());
-#endif
-}

src/client/Minecraft.h

@@ -2,7 +2,6 @@
 #define NET_MINECRAFT_CLIENT__Minecraft_H__
 
 #include "Options.h"
-#include "commands/CommandManager.hpp"
 #ifndef STANDALONE_SERVER
 #include "MouseHandler.h"
 #include "gui/Gui.h"
@@ -121,17 +120,11 @@ public:
 	void optionUpdated(OptionId option, bool value);
 	void optionUpdated(OptionId option, float value);
 	void optionUpdated(OptionId option, int value);
-
-	int getTicks() { return ticks; }
-
-	void addMessage(const std::string& msg);
 #ifdef __APPLE__
     bool _isSuperFast;
     bool isSuperFast() { return _isSuperFast; }
 #endif
 
-	CommandManager& commandManager() { return m_commandManager; }
-
 protected:
 	void _levelGenerated();
 
@@ -204,8 +197,7 @@ public:
 	std::string externalCacheStoragePath;
 protected:
 	Timer timer;
-
+    // @note @attn @warn: this is dangerous as fuck!
-	// @note @attn @warn: this is dangerous as fuck!
 	volatile bool isGeneratingLevel;
 	bool _hasSignaledGeneratingLevelFinished;
 
@@ -232,8 +224,6 @@ private:
 
 	PerfRenderer* _perfRenderer;
 	CommandServer* _commandServer;
-
-	CommandManager m_commandManager;
 };
 
 #endif /*NET_MINECRAFT_CLIENT__Minecraft_H__*/

src/client/gamemode/SurvivalMode.cpp

@@ -68,7 +68,6 @@ bool SurvivalMode::destroyBlock( int x, int y, int z, int face ) {
 			minecraft->player->inventory->clearSlot(minecraft->player->inventory->selected);
 		}
 	}
-	
 	if (changed && couldDestroy) {
 		ItemInstance instance(t, 1, data);
 		Tile::tiles[t]->playerDestroy(minecraft->level, minecraft->player, x, y, z, data);

src/client/gui/Gui.cpp

@@ -730,6 +730,7 @@ void Gui::renderDebugInfo() {
 
 	// Position
 	float px = p->x, py = p->y - p->heightOffset, pz = p->z;
+	posTranslator.to(px, py, pz);
 	int bx = (int)floorf(px), by = (int)floorf(py), bz = (int)floorf(pz);
 	int cx = bx >> 4, cz = bz >> 4;
 

src/client/gui/screens/ConsoleScreen.cpp

@@ -8,7 +8,6 @@
 #include "../../../network/ServerSideNetworkHandler.h"
 #include "../../../network/packet/ChatPacket.h"
 #include "../../../platform/log.h"
-#include "util/StringUtils.h"
 
 #include <sstream>
 #include <cstdlib>
@@ -55,37 +54,141 @@ void ConsoleScreen::charPressed(char inputChar)
         _input += inputChar;
 }
 
+// ---------------------------------------------------------------------------
+// execute: run _input as a command, print result, close screen
+// ---------------------------------------------------------------------------
 void ConsoleScreen::execute()
 {
-    if (!minecraft->level) return;
-
     if (_input.empty()) {
-        return minecraft->setScreen(NULL);
+        minecraft->setScreen(NULL);
+        return;
     }
 
     if (_input[0] == '/') {
         // Command
-        _input = Util::stringTrim(_input.substr(1));
+        std::string result = processCommand(_input);
-        
+        if (!result.empty())
-        std::istringstream iss(minecraft->commandManager().execute(*minecraft, *minecraft->player, _input));
+            minecraft->gui.addMessage(result);
-        for (std::string line; std::getline(iss, line); ) {
-            minecraft->gui.addMessage(line);
-        }
     } else {
-        // @ai @rewrite
+        // Chat message: <name> message
+        std::string msg = std::string("<") + minecraft->player->name + "> " + _input;
         if (minecraft->netCallback && minecraft->raknetInstance->isServer()) {
-            static_cast<ServerSideNetworkHandler*>(minecraft->netCallback)->displayGameMessage(_input);
+            // Hosting a LAN game: displayGameMessage shows locally + broadcasts MessagePacket to clients
+            static_cast<ServerSideNetworkHandler*>(minecraft->netCallback)->displayGameMessage(msg);
         } else if (minecraft->netCallback) {
-            ChatPacket chatPkt(_input);
+            // Connected client: send ChatPacket to server; server echoes it back as MessagePacket
+            ChatPacket chatPkt(msg);
             minecraft->raknetInstance->send(chatPkt);
         } else {
-            minecraft->gui.addMessage("<" + minecraft->player->name + "> " + _input);
+            // Singleplayer: show locally only
+            minecraft->gui.addMessage(msg);
         }
     }
 
     minecraft->setScreen(NULL);
 }
 
+// ---------------------------------------------------------------------------
+// processCommand
+// ---------------------------------------------------------------------------
+static std::string trim(const std::string& s) {
+    size_t a = s.find_first_not_of(" \t");
+    if (a == std::string::npos) return "";
+    size_t b = s.find_last_not_of(" \t");
+    return s.substr(a, b - a + 1);
+}
+
+std::string ConsoleScreen::processCommand(const std::string& raw)
+{
+    // strip leading '/'
+    std::string line = raw;
+    if (!line.empty() && line[0] == '/') line = line.substr(1);
+    line = trim(line);
+
+    // tokenise
+    std::vector<std::string> args;
+    {
+        std::istringstream ss(line);
+        std::string tok;
+        while (ss >> tok) args.push_back(tok);
+    }
+
+    if (args.empty()) return "";
+
+    Level* level = minecraft->level;
+    if (!level) return "No level loaded.";
+
+    // -----------------------------------------------------------------------
+    // /time ...
+    // -----------------------------------------------------------------------
+    if (args[0] == "time") {
+        if (args.size() < 2)
+            return "Usage: /time <add|set|query> ...";
+
+        const std::string& sub = args[1];
+
+        // -- time add <value> -----------------------------------------------
+        if (sub == "add") {
+            if (args.size() < 3) return "Usage: /time add <value>";
+            long delta = std::atol(args[2].c_str());
+            long newTime = level->getTime() + delta;
+            level->setTime(newTime);
+            std::ostringstream out;
+            out << "Set the time to " << (newTime % Level::TICKS_PER_DAY);
+            return out.str();
+        }
+
+        // -- time set <value|day|night|noon|midnight> -----------------------
+        if (sub == "set") {
+            if (args.size() < 3) return "Usage: /time set <value|day|night|noon|midnight>";
+            const std::string& val = args[2];
+
+            long t = -1;
+            if      (val == "day")      t = 1000;
+            else if (val == "noon")     t = 6000;
+            else if (val == "night")    t = 13000;
+            else if (val == "midnight") t = 18000;
+            else {
+                // numeric — accept positive integers only
+                bool numeric = true;
+                for (char c : val)
+                    if (!std::isdigit((unsigned char)c)) { numeric = false; break; }
+                if (!numeric) return std::string("Unknown value: ") + val;
+                t = std::atol(val.c_str());
+            }
+
+            // Preserve the total day count so only the time-of-day changes
+            long dayCount = level->getTime() / Level::TICKS_PER_DAY;
+            long newTime  = dayCount * Level::TICKS_PER_DAY + (t % Level::TICKS_PER_DAY);
+            level->setTime(newTime);
+            std::ostringstream out;
+            out << "Set the time to " << t;
+            return out.str();
+        }
+
+        // -- time query <daytime|gametime|day> ------------------------------
+        if (sub == "query") {
+            if (args.size() < 3) return "Usage: /time query <daytime|gametime|day>";
+            const std::string& what = args[2];
+
+            long total   = level->getTime();
+            long daytime = total % Level::TICKS_PER_DAY;
+            long day     = total / Level::TICKS_PER_DAY;
+
+            std::ostringstream out;
+            if      (what == "daytime")  { out << "The time of day is " << daytime; }
+            else if (what == "gametime") { out << "The game time is "   << total;   }
+            else if (what == "day")      { out << "The day is "         << day;     }
+            else return std::string("Unknown query: ") + what;
+            return out.str();
+        }
+
+        return "Unknown sub-command. Usage: /time <add|set|query> ...";
+    }
+
+    return std::string("Unknown command: /") + args[0];
+}
+
 // ---------------------------------------------------------------------------
 // render
 // ---------------------------------------------------------------------------

src/client/gui/screens/ConsoleScreen.h

@@ -25,6 +25,7 @@ public:
 
 private:
     void execute();
+    std::string processCommand(const std::string& cmd);
 
     std::string _input;
     int         _cursorBlink; // tick counter for cursor blink

src/client/gui/screens/crafting/PaneCraftingScreen.cpp

@@ -16,12 +16,7 @@
 #include "../../../../world/level/Level.h"
 #include "../../../../world/item/DyePowderItem.h"
 #include "../../../../world/item/crafting/Recipe.h"
-#include "network/RakNetInstance.h"
-#include "network/packet/WantCreatePacket.h"
 #include "platform/input/Keyboard.h"
-#include <cstdint>
-#include <iostream>
-#include <string>
 
 static NinePatchLayer* guiPaneFrame = NULL;
 
@@ -198,26 +193,6 @@ void PaneCraftingScreen::setupPositions() {
 }
 
 void PaneCraftingScreen::tick() {
-	if (minecraft->isOnline()) {
-		// TODO: Make better algorithm
-		static std::map<uint8_t, uint16_t> oldMap = {};
-		std::map<uint8_t, uint16_t> newMap = {};
-
-		for (int i = Inventory::MAX_SELECTION_SIZE; i < minecraft->player->inventory->getContainerSize(); ++i) {
-			auto itm = minecraft->player->inventory->getItem(i);
-
-			if (itm != NULL) {
-				newMap[itm->id] += itm->count;
-			}
-		}
-
-		if (oldMap != newMap) {
-			oldMap = newMap;
-			newMap = {};
-			recheckRecipes();
-		}
-	}
-
 	if (pane) pane->tick();
 }
 
@@ -464,29 +439,25 @@ void PaneCraftingScreen::craftSelectedItem()
 	ItemInstance resultItem = currentItem->item;
 
 	if (minecraft->player) {
-		if (minecraft->isOnline()) {
-			WantCreatePacket packet(minecraft->player->entityId, resultItem.count, resultItem.getAuxValue(), resultItem.id);
-			minecraft->raknetInstance->send(packet);
-		}
 		// Remove all items required for the recipe and ...
 		for (unsigned int i = 0; i < currentItem->neededItems.size(); ++i) {
 			CItem::ReqItem& req = currentItem->neededItems[i];
 
-			// If the recipe allows any aux-value as ingredients, first deplete
+            // If the recipe allows any aux-value as ingredients, first deplete
-			// aux == 0 from inventory. Since I'm not sure if this always is
+            // aux == 0 from inventory. Since I'm not sure if this always is
-			// correct, let's only do it for ingredient sandstone for now.
+            // correct, let's only do it for ingredient sandstone for now.
-			ItemInstance toRemove = req.item;
+            ItemInstance toRemove = req.item;
 
-			if (Tile::sandStone->id == req.item.id
+            if (Tile::sandStone->id == req.item.id
-			&& Recipe::ANY_AUX_VALUE == req.item.getAuxValue()) {
+             && Recipe::ANY_AUX_VALUE == req.item.getAuxValue()) {
-				toRemove.setAuxValue(0);
+                 toRemove.setAuxValue(0);
-				toRemove.count = minecraft->player->inventory->removeResource(toRemove, true);
+                 toRemove.count = minecraft->player->inventory->removeResource(toRemove, true);
-				toRemove.setAuxValue(Recipe::ANY_AUX_VALUE);
+                 toRemove.setAuxValue(Recipe::ANY_AUX_VALUE);
-			}
+            }
 
-			if (toRemove.count > 0) {
+            if (toRemove.count > 0) {
-				minecraft->player->inventory->removeResource(toRemove);
+                minecraft->player->inventory->removeResource(toRemove);
-			}
+            }
 		}
 		// ... add the new one! (in this order, to fill empty slots better)
 		// if it doesn't fit, throw it on the ground!

src/client/player/LocalPlayer.cpp

@@ -456,7 +456,7 @@ void LocalPlayer::tick() {
 		{
 			sentInventoryItemId   = newItemId;
 			sentInventoryItemData = newItemData;
-			PlayerEquipmentPacket packet(entityId, newItemId, newItemData, inventory->selected, inventory->getSlot(newItemId, newItemData));
+			PlayerEquipmentPacket packet(entityId, newItemId, newItemData);
 			minecraft->raknetInstance->send(packet);
 		}
 	}

src/client/renderer/LevelRenderer.cpp

@@ -65,7 +65,7 @@ LevelRenderer::LevelRenderer( Minecraft* mc)
 	destroyProgress(0)
 {
 #ifdef OPENGL_ES
-	int maxChunksWidth = 2 * LevelConstants::LEVEL_WIDTH / CHUNK_SIZE + 1;
+	int maxChunksWidth = 2 * LEVEL_WIDTH / CHUNK_SIZE + 1;
 	numListsOrBuffers = maxChunksWidth * maxChunksWidth * (128/CHUNK_SIZE) * 3;
 	chunkBuffers = new GLuint[numListsOrBuffers];
 	glGenBuffers2(numListsOrBuffers, chunkBuffers);
@@ -1077,54 +1077,53 @@ void LevelRenderer::playSound(const std::string& name, float x, float y, float z
 	float dd = 16;
 
     if (volume > 1) dd *= volume;
-    if (mc->cameraTargetPlayer != NULL && mc->cameraTargetPlayer->distanceToSqr(x, y, z) < dd * dd) {
+    if (mc->cameraTargetPlayer->distanceToSqr(x, y, z) < dd * dd) {
         mc->soundEngine->play(name, x, y, z, volume, pitch);
     }
 }
 
 void LevelRenderer::addParticle(const std::string& name, float x, float y, float z, float xa, float ya, float za, int data) {
-	if (mc->cameraTargetPlayer != NULL) {
-		float xd = mc->cameraTargetPlayer->x - x;
-		float yd = mc->cameraTargetPlayer->y - y;
-		float zd = mc->cameraTargetPlayer->z - z;
-		float distanceSquared = xd * xd + yd * yd + zd * zd;
 
-		//Particle* p = NULL;
+	float xd = mc->cameraTargetPlayer->x - x;
-		//if (name == "hugeexplosion") p = new HugeExplosionSeedParticle(level, x, y, z, xa, ya, za);
+    float yd = mc->cameraTargetPlayer->y - y;
-		//else if (name == "largeexplode") p = new HugeExplosionParticle(textures, level, x, y, z, xa, ya, za);
+    float zd = mc->cameraTargetPlayer->z - z;
+	float distanceSquared = xd * xd + yd * yd + zd * zd;
 
-		//if (p) {
+	//Particle* p = NULL;
-		//	if (distanceSquared < 32 * 32) {
+	//if (name == "hugeexplosion") p = new HugeExplosionSeedParticle(level, x, y, z, xa, ya, za);
-		//		mc->particleEngine->add(p);
+	//else if (name == "largeexplode") p = new HugeExplosionParticle(textures, level, x, y, z, xa, ya, za);
-		//	} else { delete p; }
-		//	return;
-		//}
 
-		const float particleDistance = 16;
+	//if (p) {
-		if (distanceSquared > particleDistance * particleDistance) return;
+	//	if (distanceSquared < 32 * 32) {
+	//		mc->particleEngine->add(p);
+	//	} else { delete p; }
+	//	return;
+	//}
 
-		//static Stopwatch sw;
+    const float particleDistance = 16;
-		//sw.start();
+    if (distanceSquared > particleDistance * particleDistance) return;
 
-		if (name == "bubble") mc->particleEngine->add(new BubbleParticle(level, x, y, z, xa, ya, za));
+	//static Stopwatch sw;
-		else if (name == "crit") mc->particleEngine->add(new CritParticle2(level, x, y, z, xa, ya, za));
+	//sw.start();
-		else if (name == "smoke") mc->particleEngine->add(new SmokeParticle(level, x, y, z, xa, ya, za));
-		//else if (name == "note") mc->particleEngine->add(new NoteParticle(level, x, y, z, xa, ya, za));
-		else if (name == "explode") mc->particleEngine->add(new ExplodeParticle(level, x, y, z, xa, ya, za));
-		else if (name == "flame") mc->particleEngine->add(new FlameParticle(level, x, y, z, xa, ya, za));
-		else if (name == "lava") mc->particleEngine->add(new LavaParticle(level, x, y, z));
-		//else if (name == "splash") mc->particleEngine->add(new SplashParticle(level, x, y, z, xa, ya, za));
-		else if (name == "largesmoke") mc->particleEngine->add(new SmokeParticle(level, x, y, z, xa, ya, za, 2.5f));
-		else if (name == "reddust") mc->particleEngine->add(new RedDustParticle(level, x, y, z, xa, ya, za));
-		else if (name == "iconcrack") mc->particleEngine->add(new BreakingItemParticle(level, x, y, z, xa, ya, za, Item::items[data]));
-		else if (name == "snowballpoof") mc->particleEngine->add(new BreakingItemParticle(level, x, y, z, Item::snowBall));
-		//else if (name == "snowballpoof") mc->particleEngine->add(new BreakingItemParticle(level, x, y, z, Item::snowBall));
-		//else if (name == "slime") mc->particleEngine->add(new BreakingItemParticle(level, x, y, z, Item::slimeBall));
-		//else if (name == "heart") mc->particleEngine->add(new HeartParticle(level, x, y, z, xa, ya, za));
 
-		//sw.stop();
+    if (name == "bubble") mc->particleEngine->add(new BubbleParticle(level, x, y, z, xa, ya, za));
-		//sw.printEvery(50, "add-particle-string");
+	else if (name == "crit") mc->particleEngine->add(new CritParticle2(level, x, y, z, xa, ya, za));
-	}
+	else if (name == "smoke") mc->particleEngine->add(new SmokeParticle(level, x, y, z, xa, ya, za));
+    //else if (name == "note") mc->particleEngine->add(new NoteParticle(level, x, y, z, xa, ya, za));
+    else if (name == "explode") mc->particleEngine->add(new ExplodeParticle(level, x, y, z, xa, ya, za));
+    else if (name == "flame") mc->particleEngine->add(new FlameParticle(level, x, y, z, xa, ya, za));
+    else if (name == "lava") mc->particleEngine->add(new LavaParticle(level, x, y, z));
+    //else if (name == "splash") mc->particleEngine->add(new SplashParticle(level, x, y, z, xa, ya, za));
+	else if (name == "largesmoke") mc->particleEngine->add(new SmokeParticle(level, x, y, z, xa, ya, za, 2.5f));
+    else if (name == "reddust") mc->particleEngine->add(new RedDustParticle(level, x, y, z, xa, ya, za));
+	else if (name == "iconcrack") mc->particleEngine->add(new BreakingItemParticle(level, x, y, z, xa, ya, za, Item::items[data]));
+	else if (name == "snowballpoof") mc->particleEngine->add(new BreakingItemParticle(level, x, y, z, Item::snowBall));
+    //else if (name == "snowballpoof") mc->particleEngine->add(new BreakingItemParticle(level, x, y, z, Item::snowBall));
+    //else if (name == "slime") mc->particleEngine->add(new BreakingItemParticle(level, x, y, z, Item::slimeBall));
+    //else if (name == "heart") mc->particleEngine->add(new HeartParticle(level, x, y, z, xa, ya, za));
+
+	//sw.stop();
+	//sw.printEvery(50, "add-particle-string");
 }
 
 /*

src/client/renderer/entity/PlayerRenderer.cpp

@@ -77,10 +77,10 @@ void PlayerRenderer::render(Entity* mob_, float x, float y, float z, float rot,
 		model = desired;
 		humanoidModel = desired;
 	}
-	/* LOGI("[PlayerRenderer] %s: skin=%s, modelTex=%dx%d, desired=%s\n", 
+	LOGI("[PlayerRenderer] %s: skin=%s, modelTex=%dx%d, desired=%s\n", 
 		((Player*)mob)->name.c_str(), mob->getTexture().c_str(), 
 		humanoidModel->texWidth, humanoidModel->texHeight,
-		(desired == playerModel64 ? "64" : "32")); */
+		(desired == playerModel64 ? "64" : "32"));
 	HumanoidMobRenderer::render(mob_, x, y, z, rot, a);
 }
 

src/client/sound/Sound.cpp

@@ -111,6 +111,7 @@
 #include "data/eat1.pcm"
 #include "data/eat2.pcm"
 #include "data/eat3.pcm"
+#include "data/burp1.pcm"
 #include "data/fuse.pcm"
 
 SoundDesc SA_cloth1((char*)PCM_cloth1);
@@ -221,6 +222,7 @@ SoundDesc SA_creeperdeath((char*)PCM_creeperdeath);
 SoundDesc SA_eat1((char*)PCM_eat1);
 SoundDesc SA_eat2((char*)PCM_eat2);
 SoundDesc SA_eat3((char*)PCM_eat3);
+SoundDesc SA_burp1((char*)PCM_burp1);
 SoundDesc SA_fuse((char*)PCM_fuse);
 
 #endif /*!PRE_ANDROID23 && !__APPLE__*/

src/client/sound/Sound.h

@@ -172,6 +172,7 @@ extern SoundDesc SA_creeperdeath;
 extern SoundDesc SA_eat1;
 extern SoundDesc SA_eat2;
 extern SoundDesc SA_eat3;
+extern SoundDesc SA_burp1;
 extern SoundDesc SA_fuse;
 
 #endif /*!PRE_ANDROID23 && !__APPLE__*/

src/client/sound/SoundEngine.cpp

@@ -144,6 +144,7 @@ void SoundEngine::init( Minecraft* mc, Options* options )
 	sounds.add("random.eat", SA_eat1);
 	sounds.add("random.eat", SA_eat2);
 	sounds.add("random.eat", SA_eat3);
+	sounds.add("random.burp", SA_burp1);
 	sounds.add("random.fuse", SA_fuse);
 
 #endif

src/client/sound/SoundEngine.mm

@@ -227,6 +227,7 @@ void SoundEngine::init( Minecraft* mc, Options* options )
     sounds.add( "random.eat",  _pp("eat1"));
     sounds.add( "random.eat",  _pp("eat2"));
     sounds.add( "random.eat",  _pp("eat3"));
+    sounds.add( "random.burp",  _pp("burp1"));
     sounds.add( "random.fuse", _pp("fuse"));
 
     sounds.add(	"step.cloth", _pp("cloth1"));

src/commands/Command.cpp

@@ -1,10 +0,0 @@
-#include "Command.hpp"
-#include "world/level/Level.h"
-#include <client/Minecraft.h>
-
-bool Command::isPlayerOp(Minecraft& mc, Player& player) {
-    std::string nicknameLower = player.name;
-    std::transform(nicknameLower.begin(), nicknameLower.end(), nicknameLower.begin(), ::tolower);
-
-    return mc.level->ops.find(nicknameLower) != mc.level->ops.end();
-}

src/commands/Command.hpp

@@ -1,28 +0,0 @@
-#pragma once
-#include <string>
-#include <vector>
-
-enum CommandFlags {
-    COMMAND_FLAG_SINGLEPLAYER_ONLY = (1 << 1),
-    COMMAND_FLAG_NO_ARGS = (1 << 2),
-};
-
-class Minecraft;
-class Player;
-
-class Command {
-public:
-    const std::string& getName() { return m_name; }
-    const CommandFlags getFlags() { return m_flags; }
-
-    bool isPlayerOp(Minecraft& mc, Player& player);
-
-    virtual std::string execute(Minecraft& mc, Player& player, const std::vector<std::string>& args) = 0;
-    virtual std::string help(Minecraft& mc) = 0;
-
-protected:
-    Command(const std::string& name, CommandFlags flags = (CommandFlags)0) : m_name(name), m_flags(flags) {}
-
-    const std::string m_name;
-    const CommandFlags m_flags;
-};

src/commands/CommandBan.cpp

@@ -1,52 +0,0 @@
-#include "CommandBan.hpp"
-#include "commands/Command.hpp"
-#include "network/RakNetInstance.h"
-#include "raknet/RakPeerInterface.h"
-#include "world/level/Level.h"
-#include <algorithm>
-#include <client/Minecraft.h>
-
-CommandBan::CommandBan() : Command("ban") {}
-
-std::string CommandBan::execute(Minecraft& mc, Player& player, const std::vector<std::string>& args) {
-    if (!isPlayerOp(mc, player)) {
-        return "You aren't enough priveleged to run this command";
-    }
-    
-    if (args.empty()) {
-        return help(mc);
-    }
-
-    std::string nicknameLower = args[0];
-    std::transform(nicknameLower.begin(), nicknameLower.end(), nicknameLower.begin(), ::tolower);
-
-    auto it = std::find_if(mc.level->players.begin(), mc.level->players.end(), [args, nicknameLower] (auto& it) -> bool {
-        std::string lower = it->name;
-        std::transform(lower.begin(), lower.end(), lower.begin(), ::tolower);
-
-        return lower == nicknameLower;
-    });
-
-    if (*it == (Player*)mc.player) {
-        return "ban: you can't ban urself lol";
-    }
-    
-    if (it != mc.level->players.end()) {
-        mc.level->removePlayer(*it);
-        (*it)->remove();
-        mc.raknetInstance->getPeer()->CloseConnection((*it)->owner, true);
-    } else {
-        for (auto& banned : mc.level->bannedPpl) {
-            if (nicknameLower == banned) {
-                return args[0] + "already banned!";
-            }
-        }
-    }
-
-    mc.level->bannedPpl.insert(nicknameLower);
-    return "ban: successfully banned player " + args[0];
-}
-
-std::string CommandBan::help(Minecraft& mc) {
-    return "Usage: /ban <player>";
-}

src/commands/CommandBan.hpp

@@ -1,9 +0,0 @@
-#include "Command.hpp"
-
-class CommandBan : public Command {
-public:
-    CommandBan();
-
-    std::string execute(Minecraft& mc, Player& player, const std::vector<std::string>& args);
-    std::string help(Minecraft& mc);
-};

src/commands/CommandHelp.cpp

@@ -1,35 +0,0 @@
-#include "CommandHelp.hpp"
-#include "commands/Command.hpp"
-#include "CommandManager.hpp"
-#include <client/Minecraft.h>
-#include <sstream>
-
-CommandHelp::CommandHelp() : Command("help") {}
-
-std::string CommandHelp::execute(Minecraft& mc, Player& player, const std::vector<std::string>& args) {
-    if (args.empty()) {
-        auto cmds = mc.commandManager().getListAllCommands();
-
-        std::ostringstream output;
-
-        output << "List of all commands:" << std::endl;
-        
-        for (auto& cmd : cmds) {
-            output << " - " + cmd << std::endl;;
-        }
-
-        return output.str();
-    }
-
-    Command* cmd = mc.commandManager().getCommand(args[0]);
-
-    if (cmd != nullptr) {
-        return cmd->help(mc);
-    }
-
-    return "help: command " + args[0] + " not found";
-}
-
-std::string CommandHelp::help(Minecraft& mc) {
-    return "Usage: /help <command>";
-}

src/commands/CommandHelp.hpp

@@ -1,9 +0,0 @@
-#include "Command.hpp"
-
-class CommandHelp : public Command {
-public:
-    CommandHelp();
-
-    std::string execute(Minecraft& mc, Player& player, const std::vector<std::string>& args);
-    std::string help(Minecraft& mc);
-};

src/commands/CommandKick.cpp

@@ -1,46 +0,0 @@
-#include "CommandKick.hpp"
-#include "commands/Command.hpp"
-#include "network/RakNetInstance.h"
-#include "raknet/RakPeerInterface.h"
-#include "world/level/Level.h"
-#include <algorithm>
-#include <client/Minecraft.h>
-
-CommandKick::CommandKick() : Command("kick") {}
-
-std::string CommandKick::execute(Minecraft& mc, Player& player, const std::vector<std::string>& args) {
-    if (!isPlayerOp(mc, player)) {
-        return "You aren't enough priveleged to run this command";
-    }
-    
-    if (args.empty()) {
-        return help(mc);
-    }
-
-    std::string nicknameLower = args[0];
-    std::transform(nicknameLower.begin(), nicknameLower.end(), nicknameLower.begin(), ::tolower);
-
-    auto it = std::find_if(mc.level->players.begin(), mc.level->players.end(), [args, nicknameLower] (auto& it) -> bool {
-        std::string lower = it->name;
-        std::transform(lower.begin(), lower.end(), lower.begin(), ::tolower);
-
-        return lower == nicknameLower;
-    });
-
-    if (it == mc.level->players.end()) {
-        return "kick: can't find player with name " + args[0];
-    }
-
-    if (*it == (Player*)mc.player) {
-        return "kick: you can't kick urself lol";
-    }
-
-    mc.level->removePlayer(*it);
-    (*it)->remove();
-    mc.raknetInstance->getPeer()->CloseConnection((*it)->owner, true);
-    return "kick: successfully kicked player " + args[0];
-}
-
-std::string CommandKick::help(Minecraft& mc) {
-    return "Usage: /kick <player>";
-}

src/commands/CommandKick.hpp

@@ -1,9 +0,0 @@
-#include "Command.hpp"
-
-class CommandKick : public Command {
-public:
-    CommandKick();
-
-    std::string execute(Minecraft& mc, Player& player, const std::vector<std::string>& args);
-    std::string help(Minecraft& mc);
-};

src/commands/CommandManager.cpp

@@ -1,75 +0,0 @@
-#include "CommandManager.hpp"
-#include <algorithm>
-#include <string>
-#include <vector>
-#include "client/Minecraft.h"
-#include "commands/Command.hpp"
-#include "commands/CommandHelp.hpp"
-#include "commands/CommandKick.hpp"
-#include "commands/CommandOp.hpp"
-#include "commands/CommandBan.hpp"
-#include "network/packet/ChatPacket.h"
-#include "network/RakNetInstance.h"
-#include "world/level/Level.h"
-
-CommandManager::CommandManager() {
-    registerAllCommands();
-}
-
-void CommandManager::registerAllCommands() {
-    m_commands.push_back(new CommandHelp());
-    m_commands.push_back(new CommandKick());
-    m_commands.push_back(new CommandOp());
-    m_commands.push_back(new CommandBan());
-}
-
-std::vector<std::string> CommandManager::getListAllCommands() {
-    std::vector<std::string> ret;
-
-    for (auto& cmd : m_commands) {
-        ret.push_back(cmd->getName());
-    }
-
-    return ret;
-}
-
-std::string CommandManager::execute(Minecraft& mc, Player& player, const std::string& input) {
-    std::istringstream ss(input);
-    std::string cmd;
-
-    ss >> cmd;
-
-    auto it = std::find_if(m_commands.begin(), m_commands.end(), [cmd](auto& it) -> bool {
-        return it->getName() == cmd;
-    });
-
-    if (it == m_commands.end()) {
-        return "Command /" + cmd + " not found";
-    }
-
-    std::vector<std::string> args;
-
-    std::string tok;
-    while (ss >> tok) args.push_back(tok);
-    
-    if (!mc.level->isClientSide || (*it)->getFlags() & CommandFlags::COMMAND_FLAG_SINGLEPLAYER_ONLY) {
-        return (*it)->execute(mc, player, args);
-    } else {
-        ChatPacket packet("/" + input);
-        mc.raknetInstance->send(packet);
-    }
-
-    return "";
-}
-
-Command* CommandManager::getCommand(const std::string& name) {
-    auto it = std::find_if(m_commands.begin(), m_commands.end(), [name](auto& it) -> bool {
-        return it->getName() == name;
-    });
-
-    if (it == m_commands.end()) {
-        return *it;
-    }
-
-    return nullptr;
-}

src/commands/CommandManager.hpp

@@ -1,21 +0,0 @@
-#pragma once
-#include <string>
-#include <vector>
-
-#include "Command.hpp"
-
-class CommandManager {
-public:
-    CommandManager();
-
-    std::vector<std::string> getListAllCommands();
-
-    std::string execute(Minecraft& mc, Player& player, const std::string& input);
-
-    Command* getCommand(const std::string& name);
-
-private:
-    void registerAllCommands();
-    
-    std::vector<Command*> m_commands;
-};

src/commands/CommandOp.cpp

@@ -1,31 +0,0 @@
-#include "CommandOp.hpp"
-#include "commands/Command.hpp"
-#include "world/level/Level.h"
-#include <algorithm>
-#include <client/Minecraft.h>
-
-CommandOp::CommandOp() : Command("op") {}
-
-std::string CommandOp::execute(Minecraft& mc, Player& player, const std::vector<std::string>& args) {
-    if (!isPlayerOp(mc, player)) {
-        return "You aren't enough priveleged to run this command";
-    }
-    
-    if (args.empty()) {
-        return help(mc);
-    }
-
-    std::string nicknameLower = args[0];
-    std::transform(nicknameLower.begin(), nicknameLower.end(), nicknameLower.begin(), ::tolower);
-    
-    if (mc.level->ops.find(nicknameLower) != mc.level->ops.end()) {
-        return "op: player " + args[0] + " already opped";
-    }
-
-    mc.level->ops.emplace(nicknameLower);
-    return "op: successfully opped player " + args[0];
-}
-
-std::string CommandOp::help(Minecraft& mc) {
-    return "Usage: /op <player>";
-}

src/commands/CommandOp.hpp

@@ -1,9 +0,0 @@
-#include "Command.hpp"
-
-class CommandOp : public Command {
-public:
-    CommandOp();
-
-    std::string execute(Minecraft& mc, Player& player, const std::vector<std::string>& args);
-    std::string help(Minecraft& mc);
-};

src/main_dedicated.cpp

@@ -1,20 +1,16 @@
-#include <fstream>
 #include <iostream>
 #include "NinecraftApp.h"
 #include "AppPlatform.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <signal.h>
-#ifdef __linux__
 #include <unistd.h>
-#endif
 
 #include "world/level/LevelSettings.h"
 #include "world/level/Level.h"
 #include "server/ArgumentsSettings.h"
 #include "platform/time.h"
 #include "SharedConstants.h"
-#include "world/level/LevelConstants.h"
 
 #define MAIN_CLASS NinecraftApp
 static App* g_app = 0;
@@ -31,175 +27,36 @@ void signal_callback_handler(int signum) {
 	}
 }
 
-std::string findStringInConfig(std::string line, std::string config) {
-    auto valuePos = config.find(line);
-
-    if (line.empty()) {
-        throw std::runtime_error("Key cannot be empty");
-    }
-
-    if (valuePos == std::string::npos) {
-        throw std::runtime_error("Cannot find value");
-    }
- 
-    std::string valueStr = "";
-
-    valuePos += 1 + line.size();
-
-    while (true) {
-        auto sym = config.at(valuePos);
-
-        if (sym == '\n') {
-            break;
-        }
-
-        if (valuePos == config.size()) {
-            throw std::runtime_error("Cannot find end of the line");
-        }
-
-        valueStr += sym;
-        valuePos++;
-    }
-
-    return valueStr;
-}
-
-
 int main(int numArguments, char* pszArgs[]) {
-	std::ifstream serverProperties("server.properties");
+	ArgumentsSettings aSettings(numArguments, pszArgs);
-
+	if(aSettings.getShowHelp()) {
-	int port = 0;
+		ArgumentsSettings defaultSettings(0, NULL);
-	int gamemode = 0;
+		printf("Minecraft Pockect Edition Server %s\n", Common::getGameVersionString("").c_str());
-	int worldSize = 0;
+		printf("-------------------------------------------------------\n");
-
+		printf("--cachepath - Path to where the server can store temp stuff (not sure if this is used) [default: \"%s\"]\n", defaultSettings.getCachePath().c_str());
-	std::string levelDir = "";
+		printf("--externalpath - The path to the place where the server should store the levels. [default: \"%s\"]\n", defaultSettings.getExternalPath().c_str());
-	std::string cachePath = "";
+		printf("--levelname - The name of the server [default: \"%s\"]\n", defaultSettings.getLevelName().c_str());
-	std::string externalPath = "";
+		printf("--leveldir - The name of the server [default: \"%s\"]\n", defaultSettings.getLevelDir().c_str());
-	std::string levelName = "";
+		printf("--help - Shows this message.\n");
-
+		printf("--port - The port to run the server on. [default: %d]\n", defaultSettings.getPort());
-	if (serverProperties.is_open()) {
+		printf("--serverkey - The key that the server should use for API calls. [default: \"%s\"]\n", defaultSettings.getServerKey().c_str());
-		std::string propString;
+		printf("-------------------------------------------------------\n");
-        std::string line;
+		return 0;
-        
-        while (std::getline(serverProperties, line)) {
-            propString += line;
-			propString += "\n";
-        }
-
-        if (propString.empty()) {
-            throw std::runtime_error("Config cannot be empty");
-        }
-
-		port = std::stoi(findStringInConfig("port", propString));
-		worldSize = std::stoi(findStringInConfig("world-size", propString));
-
-		if (worldSize < 16 || worldSize > 32) {
-			throw std::runtime_error("Incorrect world size.");
-		}
-
-		LevelConstants::CHUNK_CACHE_WIDTH = worldSize;
-		LevelConstants::LEVEL_WIDTH = LevelConstants::CHUNK_CACHE_WIDTH * LevelConstants::CHUNK_WIDTH;
-		LevelConstants::LEVEL_DEPTH = LevelConstants::CHUNK_CACHE_WIDTH * LevelConstants::CHUNK_DEPTH;
-		
-		cachePath = findStringInConfig("level-cachepath", propString);
-		externalPath = findStringInConfig("level-externalpath", propString);
-		levelName = findStringInConfig("level-name", propString);
-		levelDir = findStringInConfig("level-dir", propString);
-
-		std::string gamemodeStr = findStringInConfig("gamemode", propString);
-
-		if (gamemodeStr == "survival") {
-			gamemode = GameType::Survival;
-		} else if (gamemodeStr == "creative") {
-			gamemode = GameType::Creative;
-		} else {
-			gamemode = GameType::Survival;
-		}
-		
-		printf("%d %s %s %d %d\n", port, cachePath.c_str(), externalPath.c_str(), gamemode, LevelConstants::CHUNK_CACHE_WIDTH);
-	} else {
-		std::ofstream defaultProperties("server.properties");
-
-		if (defaultProperties.is_open()) {
-			ArgumentsSettings defaultSettings(0, NULL);
-
-			std::stringstream buffer;
-			
-			buffer << "// MCPE Server properties" << std::endl;
-			buffer << "port=" << defaultSettings.getPort() << std::endl;
-			buffer << "level-dir=" << defaultSettings.getLevelDir() << std::endl;
-			buffer << "level-cachepath=" << defaultSettings.getCachePath() << std::endl;
-			buffer << "level-externalpath=" << defaultSettings.getExternalPath() << std::endl;
-			buffer << "gamemode=survival" << std::endl;
-			buffer << "level-name=" << defaultSettings.getLevelName() << std::endl;
-			buffer << "world-size=16" << std::endl;
-
-			defaultProperties << buffer.str();
-
-			printf("%s \n", buffer.str().c_str());
-
-			printf("Edit a config file first!\n");
-
-			defaultProperties.close();
-			exit(0);
-		} else {
-			throw std::runtime_error("Cannot create default config.");
-		}
 	}
-
+	printf("Level Name: %s\n", aSettings.getLevelName().c_str());
-	printf("Level Name: %s\n", levelName.c_str());
-
 	AppContext appContext;
 	appContext.platform = new AppPlatform();
 	App* app = new MAIN_CLASS();
 	signal(SIGINT, signal_callback_handler);
 	g_app = app;
-	((MAIN_CLASS*)g_app)->externalStoragePath = externalPath;
+	((MAIN_CLASS*)g_app)->externalStoragePath = aSettings.getExternalPath();
-	((MAIN_CLASS*)g_app)->externalCacheStoragePath = cachePath;
+	((MAIN_CLASS*)g_app)->externalCacheStoragePath = aSettings.getCachePath();
 
 	g_app->init(appContext);
-	LevelSettings settings(getEpochTimeS(), gamemode);
+	LevelSettings settings(getEpochTimeS(), GameType::Creative);
 	float startTime = getTimeS();
-	((MAIN_CLASS*)g_app)->selectLevel(levelDir, levelName, settings);
+	((MAIN_CLASS*)g_app)->selectLevel(aSettings.getLevelDir(), aSettings.getLevelName(),  settings);
-	((MAIN_CLASS*)g_app)->hostMultiplayer(port);
+	((MAIN_CLASS*)g_app)->hostMultiplayer(aSettings.getPort());
-
-	// Reading ops
-	std::ifstream ops("ops.txt");
-
-	if (ops.is_open()) {
-        std::string line;
-        
-        while (std::getline(ops, line)) {
-			if (!line.empty()) {
-            	((MAIN_CLASS*)g_app)->level->ops.insert(line);
-			}
-        }
-	} else {
-		std::ofstream opsDefault("ops.txt");
-
-		if (!opsDefault.is_open()) {
-			throw std::runtime_error("Cannot create ops list.");
-		}
-	}
-
-	// Reading banned ppl
-	std::ifstream banned("banned-players.txt");
-
-	if (banned.is_open()) {
-        std::string line;
-        
-        while (std::getline(banned, line)) {
-			if (!line.empty()) {
-            	((MAIN_CLASS*)g_app)->level->bannedPpl.insert(line);
-			}
-        }
-	} else {
-		std::ofstream bannedPpl("banned-players.txt");
-
-		if (!bannedPpl.is_open()) {
-			throw std::runtime_error("Cannot create banned players list.");
-		}
-	}
 
 	std::cout << "Level has been generated in " << getTimeS() - startTime << std::endl;
 	((MAIN_CLASS*)g_app)->level->saveLevelData();
@@ -210,31 +67,7 @@ int main(int numArguments, char* pszArgs[]) {
 		//pthread_yield();
 		sleepMs(20);
 	}
-	
-	std::ofstream opsWrite("ops.txt"); 
-
-	if (opsWrite.is_open()) {
-		for (auto& op : ((MAIN_CLASS*)g_app)->level->ops) {
-			opsWrite << op << std::endl;
-		}
-		opsWrite.close();
-	} else {
-		throw std::runtime_error("Cannot open ops list.");
-	}
-
-	std::ofstream bannedWrite("banned-players.txt"); 
-
-	if (bannedWrite.is_open()) {
-		for (auto& banned : ((MAIN_CLASS*)g_app)->level->bannedPpl) {
-			bannedWrite << banned << std::endl;
-		}
-		bannedWrite.close();
-	} else {
-		throw std::runtime_error("Cannot open banned players list.");
-	}
-	
 	((MAIN_CLASS*)g_app)->level->saveLevelData();
-
 	delete app;
 	appContext.platform->finish();
 	delete appContext.platform;

src/network/ClientSideNetworkHandler.cpp

@@ -1,7 +1,6 @@
 
 #include "ClientSideNetworkHandler.h"
 #include "client/Options.h"
-#include "network/packet/LoginStatusPacket.h"
 #include "packet/PacketInclude.h"
 #include "RakNetInstance.h"
 #include "../world/level/chunk/ChunkSource.h"
@@ -11,9 +10,6 @@
 #include "../world/entity/player/Inventory.h"
 #include "../client/Minecraft.h"
 #include "../client/gamemode/GameMode.h"
-#include "world/item/ItemInstance.h"
-#include "world/level/LevelConstants.h"
-#include <cstddef>
 #ifndef STANDALONE_SERVER
 #include "../client/gui/screens/DisconnectionScreen.h"
 #endif
@@ -46,9 +42,6 @@ ClientSideNetworkHandler::ClientSideNetworkHandler(Minecraft* minecraft, IRakNet
 	requestNextChunkPosition(0),
     requestNextChunkIndex(0)
 {
-	NumRequestChunks = LevelConstants::CHUNK_CACHE_WIDTH * LevelConstants::CHUNK_CACHE_WIDTH;
-	requestNextChunkIndexList.resize(NumRequestChunks);
-	chunksLoaded.resize(NumRequestChunks);
 	rakPeer = raknetInstance->getPeer();
 }
 
@@ -66,7 +59,7 @@ void ClientSideNetworkHandler::requestNextChunk()
 
         //LOGI("requesting chunks @ (%d, %d)\n", chunk.x, chunk.y);
         
-		//raknetInstance->send(new RequestChunkPacket(requestNextChunkPosition % LevelConstants::CHUNK_CACHE_WIDTH, requestNextChunkPosition / LevelConstants::CHUNK_CACHE_WIDTH));
+		//raknetInstance->send(new RequestChunkPacket(requestNextChunkPosition % CHUNK_CACHE_WIDTH, requestNextChunkPosition / CHUNK_CACHE_WIDTH));
 		requestNextChunkIndex++;
         requestNextChunkPosition++;
 	}
@@ -74,16 +67,16 @@ void ClientSideNetworkHandler::requestNextChunk()
 
 bool ClientSideNetworkHandler::areAllChunksLoaded()
 {
-	return (requestNextChunkPosition >= (LevelConstants::CHUNK_CACHE_WIDTH * LevelConstants::CHUNK_CACHE_WIDTH));
+	return (requestNextChunkPosition >= (CHUNK_CACHE_WIDTH * CHUNK_CACHE_WIDTH));
 }
 
 bool ClientSideNetworkHandler::isChunkLoaded(int x, int z)
 {
-	if (x < 0 || x >= LevelConstants::CHUNK_CACHE_WIDTH || z < 0 || z >= LevelConstants::CHUNK_CACHE_WIDTH) {
+	if (x < 0 || x >= CHUNK_CACHE_WIDTH || z < 0 || z >= CHUNK_CACHE_WIDTH) {
 		LOGE("Error: Tried to request chunk (%d, %d)\n", x, z);
 		return true;
 	}
-	return chunksLoaded[x * LevelConstants::CHUNK_CACHE_WIDTH + z];
+	return chunksLoaded[x * CHUNK_CACHE_WIDTH + z];
 	//return areAllChunksLoaded();
 }
 
@@ -93,7 +86,7 @@ void ClientSideNetworkHandler::onConnect(const RakNet::RakNetGUID& hostGuid)
 	serverGuid = hostGuid;
 
 	clearChunksLoaded();
-	LoginPacket packet(minecraft->options.getStringValue(OPTIONS_USERNAME).c_str(), SharedConstants::NetworkProtocolVersion, true);
+	LoginPacket packet(minecraft->options.getStringValue(OPTIONS_USERNAME).c_str(), SharedConstants::NetworkProtocolVersion);
 	raknetInstance->send(packet);
 }
 
@@ -104,11 +97,6 @@ void ClientSideNetworkHandler::onUnableToConnect()
 
 void ClientSideNetworkHandler::onDisconnect(const RakNet::RakNetGUID& guid)
 {
-	LevelConstants::CHUNK_CACHE_WIDTH = 16;
-	LevelConstants::LEVEL_WIDTH = LevelConstants::CHUNK_CACHE_WIDTH * LevelConstants::CHUNK_WIDTH;
-	LevelConstants::LEVEL_DEPTH = LevelConstants::CHUNK_CACHE_WIDTH * LevelConstants::CHUNK_DEPTH;
-	
-	// TODO: Good disconnecting
 	LOGI("onDisconnect\n");
 	if (level)
 	{
@@ -121,11 +109,8 @@ void ClientSideNetworkHandler::onDisconnect(const RakNet::RakNetGUID& guid)
 			}
 		}
 	}
-	minecraft->setLevel(NULL);
 #ifndef STANDALONE_SERVER
 	minecraft->gui.addMessage("Disconnected from server");
-	// TODO: screen with error
-    minecraft->screenChooser.setScreen(SCREEN_STARTMENU);
 #endif
 }
 
@@ -145,18 +130,6 @@ void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, LoginSta
 		LOGI("Disconnect! Server is outdated!\n");
 #ifndef STANDALONE_SERVER
 		minecraft->setScreen(new DisconnectionScreen("Could not connect: Outdated server!"));
-#endif
-	}
-	if (packet->status == LoginStatus::Failed_TakenNickname) {
-		LOGI("Disconnect! Nickname is taken!\n");
-#ifndef STANDALONE_SERVER
-		minecraft->setScreen(new DisconnectionScreen("Could not connect: Nickname is taken!"));
-#endif
-	}
-	if (packet->status == LoginStatus::Failed_Banned) {
-		LOGI("Disconnect! You're banned from this server!\n");
-#ifndef STANDALONE_SERVER
-		minecraft->setScreen(new DisconnectionScreen("Could not connect: You're banned from this server!"));
 #endif
 	}
 }
@@ -173,19 +146,6 @@ void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, StartGam
 	}
 #endif
 
-	// @todo @note i think its trash
-	// we can put it directly to selectLevel?
-	if (packet->chunkCacheWidth != 0) {
-		printf("lol \n");		
-		LevelConstants::CHUNK_CACHE_WIDTH = packet->chunkCacheWidth;
-		LevelConstants::LEVEL_WIDTH = LevelConstants::CHUNK_CACHE_WIDTH * LevelConstants::CHUNK_WIDTH;
-		LevelConstants::LEVEL_DEPTH = LevelConstants::CHUNK_CACHE_WIDTH * LevelConstants::CHUNK_DEPTH;
-		LevelChunk::ChunkBlockCount = LevelConstants::CHUNK_BLOCK_COUNT;
-	}
-	NumRequestChunks = LevelConstants::CHUNK_CACHE_WIDTH * LevelConstants::CHUNK_CACHE_WIDTH;
-	requestNextChunkIndexList.resize(NumRequestChunks);
-	chunksLoaded.resize(NumRequestChunks);
-
 	const std::string& levelId = LevelStorageSource::TempLevelId;
 	LevelStorageSource* storageSource = minecraft->getLevelSource();
 	storageSource->deleteLevel(levelId);
@@ -364,7 +324,7 @@ void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, RemoveEn
 	if (!level) return;
 
 	Entity* entity = level->getEntity(packet->entityId);
-	// LOGI("RemoveEntityPacket %p %p, %d\n", entity, minecraft->player, entity?(int)(entity->isPlayer()): -1);
+	LOGI("RemoveEntityPacket %p %p, %d\n", entity, minecraft->player, entity?(int)(entity->isPlayer()): -1);
 	if (!entity) return;
 
 	level->removeEntity(entity);
@@ -384,7 +344,6 @@ void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, AddItemE
 }
 
 void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, TakeItemEntityPacket* packet) {
-	printf("TakeItemEntityPacket \n");
 	if (!level) return;
 
 	Entity* e = level->getEntity(packet->itemId);
@@ -427,54 +386,6 @@ void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, MovePlay
 	}
 }
 
-void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, SendInventoryPacket* packet) {
-	if (!level) return;
-
-	if (packet->entityId == minecraft->player->entityId) {
-		auto items = packet->items;
-		
-		minecraft->player->inventory->replace(items);
-
-		for (int i = 0; i < packet->linkedSlot.size(); i++) {
-			minecraft->player->inventory->linkSlot(i, packet->linkedSlot[i].inventorySlot, true);
-			LOGI("%i -> %i\n", packet->linkedSlot[i].inventorySlot, i);
-		}
-	}
-}
-
-void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, TakeItemPacket* packet) {
-	if (!level) return;
-
-	LOGI("TakeItemPacket\n");
-
-	ItemInstance* item;
-
-	item->count = packet->count;
-	item->id = packet->itemId;
-	item->setAuxValue(packet->auxValue);
-
-	// if (minecraft->player->entityId == packet->playerId) {
-	if (!minecraft->player->inventory->add(item)) {
-		minecraft->player->drop(new ItemInstance(*item), false);
-	}
-	// }
-}
-
-void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, RemoveItemPacket* packet) {
-	// Idk how it works...
-	if (!level) return;
-
-	ItemInstance item;
-
-	item.count = packet->count;
-	item.id = packet->itemId;
-	item.setAuxValue(packet->auxValue);
-
-	// if (minecraft->player->entityId == packet->playerId) {
-	minecraft->player->inventory->removeResource(item);
-	// }
-}
-
 void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, MoveEntityPacket* packet)
 {
 	if (!level)
@@ -564,19 +475,19 @@ void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, ChunkDat
 	//unsigned char* blockIds = chunk->getBlockData();
 	DataLayer& blockData = chunk->data;
 
-	const int setSize = LevelConstants::LEVEL_HEIGHT / 8;
+	const int setSize = LEVEL_HEIGHT / 8;
-	const int setShift = 4; // power of LevelConstants::LEVEL_HEIGHT / 8
+	const int setShift = 4; // power of LEVEL_HEIGHT / 8
 
 	bool recalcHeight = false;
 
-	int x0 = 16, x1 = 0, z0 = 16, z1 = 0, y0 = LevelConstants::LEVEL_HEIGHT, y1 = 0;
+	int x0 = 16, x1 = 0, z0 = 16, z1 = 0, y0 = LEVEL_HEIGHT, y1 = 0;
 	int rx = packet->x << 4;
 	int rz = packet->z << 4;
 
-	unsigned char* readBlockBuffer = new unsigned char[setSize];
+	unsigned char readBlockBuffer[setSize];
-	unsigned char* readDataBuffer = new unsigned char[setSize / 2];
+	unsigned char readDataBuffer[setSize / 2];
 
-	for (int i = 0; i < LevelConstants::CHUNK_COLUMNS; i++)
+	for (int i = 0; i < CHUNK_COLUMNS; i++)
 	{
 		unsigned char updateBits = 0;
 		packet->chunkData.Read(updateBits);
@@ -585,8 +496,8 @@ void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, ChunkDat
 		{
 			recalcHeight = true;
 
-			int colX = (i % LevelConstants::CHUNK_WIDTH);
+			int colX = (i % CHUNK_WIDTH);
-			int colZ = (i / LevelConstants::CHUNK_WIDTH);
+			int colZ = (i / CHUNK_WIDTH);
 			int colDataPosition = colX << 11 | colZ << 7;
 
 			for (int set = 0; set < 8; set++)
@@ -620,33 +531,30 @@ void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, ChunkDat
 				{
 					y0 = ((1 << set) << setShift);
 				}
-				if (((1 << set) << setShift) + (LevelConstants::LEVEL_HEIGHT / 8) - 1 > y1)
+				if (((1 << set) << setShift) + (LEVEL_HEIGHT / 8) - 1 > y1)
 				{
-					y1 = ((1 << set) << setShift) + (LevelConstants::LEVEL_HEIGHT / 8) - 1;
+					y1 = ((1 << set) << setShift) + (LEVEL_HEIGHT / 8) - 1;
 				}
 			}
-			if ((i % LevelConstants::CHUNK_WIDTH) < x0)
+			if ((i % CHUNK_WIDTH) < x0)
 			{
-				x0 = (i % LevelConstants::CHUNK_WIDTH);
+				x0 = (i % CHUNK_WIDTH);
 			}
-			if ((i % LevelConstants::CHUNK_WIDTH) > x1)
+			if ((i % CHUNK_WIDTH) > x1)
 			{
-				x1 = (i % LevelConstants::CHUNK_WIDTH);
+				x1 = (i % CHUNK_WIDTH);
 			}
-			if ((i / LevelConstants::CHUNK_WIDTH) < z0)
+			if ((i / CHUNK_WIDTH) < z0)
 			{
-				z0 = (i / LevelConstants::CHUNK_WIDTH);
+				z0 = (i / CHUNK_WIDTH);
 			}
-			if ((i / LevelConstants::CHUNK_WIDTH) > z1)
+			if ((i / CHUNK_WIDTH) > z1)
 			{
-				z1 = (i / LevelConstants::CHUNK_WIDTH);
+				z1 = (i / CHUNK_WIDTH);
 			}
 		}
 	}
 
-	delete[] readBlockBuffer;
-	delete[] readDataBuffer;
-
  	if (recalcHeight)
  	{
 // 		chunk->recalcHeightmap();
@@ -671,7 +579,7 @@ void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, ChunkDat
 	//chunk->terrainPopulated = true;
 	chunk->unsaved = false;
 
-	chunksLoaded[packet->x * LevelConstants::CHUNK_CACHE_WIDTH + packet->z] = true;
+	chunksLoaded[packet->x * CHUNK_CACHE_WIDTH + packet->z] = true;
 
 	if (areAllChunksLoaded())
 	{
@@ -719,18 +627,18 @@ void ClientSideNetworkHandler::arrangeRequestChunkOrder() {
 	clearChunksLoaded();
 
     // Default sort is around center of the world
-    int cx = LevelConstants::CHUNK_CACHE_WIDTH / 2;
+    int cx = CHUNK_CACHE_WIDTH / 2;
-    int cz = LevelConstants::CHUNK_CACHE_WIDTH / 2;
+    int cz = CHUNK_CACHE_WIDTH / 2;
 
     // If player exists, let's sort around him
     Player* p = minecraft? minecraft->player : NULL;
     if (p) {
-        cx = Mth::floor(p->x / (float)LevelConstants::CHUNK_WIDTH);
+        cx = Mth::floor(p->x / (float)CHUNK_WIDTH);
-        cz = Mth::floor(p->z / (float)LevelConstants::CHUNK_DEPTH);
+        cz = Mth::floor(p->z / (float)CHUNK_DEPTH);
     }
 
     _ChunkSorter sorter(cx, cz);
-    std::sort(requestNextChunkIndexList.begin(), requestNextChunkIndexList.end(), sorter);
+    std::sort(requestNextChunkIndexList, requestNextChunkIndexList + NumRequestChunks, sorter);
 }
 
 void ClientSideNetworkHandler::levelGenerated(Level* level)
@@ -874,10 +782,6 @@ void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, AnimateP
 	}
 }
 
-void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, WantCreatePacket* packet)
-{
-}
-
 void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, UseItemPacket* packet)
 {
 }
@@ -887,7 +791,6 @@ void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, SetHealt
 	if (!level || !minecraft->player)
 		return;
 
-	printf("SetHealthPacket \n");
 	minecraft->player->hurtTo(packet->health);
 }
 
@@ -983,11 +886,7 @@ void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, Containe
 void ClientSideNetworkHandler::handle( const RakNet::RakNetGUID& source, ChatPacket* packet )
 {
 #ifndef STANDALONE_SERVER
-	// minecraft->gui.displayClientMessage(packet->message);
+	minecraft->gui.displayClientMessage(packet->message);
-	std::istringstream iss(packet->message);
-	for (std::string line; std::getline(iss, line); ) {
-		minecraft->gui.addMessage(line);
-	}
 #endif
 }
 
@@ -1020,8 +919,8 @@ void ClientSideNetworkHandler::clearChunksLoaded()
 {
 	// Init the chunk positions
 	for (int i = 0; i < NumRequestChunks; ++i) {
-		requestNextChunkIndexList[i].x = i / LevelConstants::CHUNK_WIDTH;
+		requestNextChunkIndexList[i].x = i/CHUNK_WIDTH;
-		requestNextChunkIndexList[i].y = i % LevelConstants::CHUNK_WIDTH;
+		requestNextChunkIndexList[i].y = i%CHUNK_WIDTH;
 		chunksLoaded[i] = false;
 	}
 }

src/network/ClientSideNetworkHandler.h

@@ -77,11 +77,6 @@ public:
 	virtual void handle(const RakNet::RakNetGUID& source, ChatPacket* packet);
 	virtual void handle(const RakNet::RakNetGUID& source, AdventureSettingsPacket* packet);
 	virtual void handle(const RakNet::RakNetGUID& source, SignUpdatePacket* packet);
-	virtual void handle(const RakNet::RakNetGUID& source, RemoveItemPacket* packet);
-	virtual void handle(const RakNet::RakNetGUID& source, TakeItemPacket* packet);
-	virtual void handle(const RakNet::RakNetGUID& source, WantCreatePacket* packet);
-	virtual void handle(const RakNet::RakNetGUID& source, SendInventoryPacket* packet);
-
 private:
 
 	void requestNextChunk();
@@ -102,11 +97,11 @@ private:
 	BlockUpdateList	bufferedBlockUpdates;
 	int	requestNextChunkPosition;
 
-    int NumRequestChunks;
+    static const int NumRequestChunks = CHUNK_CACHE_WIDTH * CHUNK_CACHE_WIDTH;
     
     int requestNextChunkIndex;
-    std::vector<IntPair> requestNextChunkIndexList;
+    IntPair requestNextChunkIndexList[NumRequestChunks];
-	std::vector<bool> chunksLoaded;
+	bool chunksLoaded[NumRequestChunks];
 };
 
 #endif

src/network/NATPunchHandler.cpp

@@ -0,0 +1,33 @@
+#include "NATPunchHandler.h"
+#include "../raknet/TCPInterface.h"
+#include "../raknet/HTTPConnection.h"
+#include "PHPDirectoryServer2.h"
+
+using namespace RakNet;
+NATPuchHandler::NATPuchHandler() {
+	tcpInterface = new TCPInterface;
+}
+NATPuchHandler::~NATPuchHandler() {
+	delete tcpInterface;
+}
+
+void NATPuchHandler::initialize() {
+	tcpInterface->Start(0, 64);
+}
+
+void NATPuchHandler::registerToGameList(const RakNet::RakString& serverName, int port) {
+	HTTPConnection httpConnection;
+	httpConnection.Init(tcpInterface, "johanbernhardsson.se");
+	PHPDirectoryServer2 directoryServer;
+	directoryServer.Init(&httpConnection, "/DirectoryServer.php");
+	directoryServer.UploadTable("", serverName, port, true);
+}
+
+void NATPuchHandler::removeFromGameList() {
+
+}
+
+void NATPuchHandler::close() {
+
+}
+

src/network/NATPunchHandler.h

@@ -0,0 +1,24 @@
+#ifndef _MINECRAFT_NETWORK_NATPUNCHHANDLER_H_
+#define _MINECRAFT_NETWORK_NATPUNCHHANDLER_H_
+#include "../raknet/TCPInterface.h"
+#include "../raknet/RakString.h"
+class NATPuchHandler {
+public:
+	enum NATPuchHandlerStatus {
+		NATPuchInitilized = 0,
+		NATPuchFetchingServerList = 1,
+		NATPuchConnecting = 2,
+		NATPuchConnected = 3,
+		NATPuchDissconnected = 4
+	};
+	NATPuchHandler();
+	~NATPuchHandler();
+	void initialize();
+	void registerToGameList(const RakNet::RakString& serverName, int port);
+	void removeFromGameList();
+	void close();
+private:
+	RakNet::TCPInterface *tcpInterface;
+};
+
+#endif /* _MINECRAFT_NETWORK_NATPUNCHHANDLER_H_ */

src/network/NetEventCallback.h

@@ -18,8 +18,6 @@ class RemovePlayerPacket;
 class RemoveEntityPacket;
 class MoveEntityPacket;
 //class TeleportEntityPacket;
-class RemoveItemPacket;
-class TakeItemPacket;
 class MovePlayerPacket;
 class PlaceBlockPacket;
 class RemoveBlockPacket;
@@ -50,7 +48,6 @@ class ContainerClosePacket;
 class ContainerSetSlotPacket;
 class ContainerSetDataPacket;
 class ContainerSetContentPacket;
-class WantCreatePacket;
 class ChatPacket;
 class SignUpdatePacket;
 class Minecraft;
@@ -122,9 +119,6 @@ public:
 	virtual void handle(const RakNet::RakNetGUID& source, SignUpdatePacket* packet) {}
 	virtual void handle(const RakNet::RakNetGUID& source, AdventureSettingsPacket* packet) {}
 	virtual void handle(const RakNet::RakNetGUID& source, AnimatePacket* packet) {}
-	virtual void handle(const RakNet::RakNetGUID& source, RemoveItemPacket* packet) {}
-	virtual void handle(const RakNet::RakNetGUID& source, TakeItemPacket* packet) {}
-	virtual void handle(const RakNet::RakNetGUID& source, WantCreatePacket* packet) {}
 
 	//
 	// Common implementation for Client and Server

src/network/Packet.cpp

@@ -2,7 +2,6 @@
 #include "Packet.h"
 #include "../world/level/chunk/LevelChunk.h"
 
-#include "network/packet/TakeItemPacket.h"
 #include "packet/PacketInclude.h"
 
 Packet::Packet()
@@ -42,12 +41,6 @@ Packet* MinecraftPackets::createPacket(int id)
 	case PACKET_ADDITEMENTITY:
 		packet = new AddItemEntityPacket();
 		break;
-	case PACKET_REMOVEITEM:
-		packet = new RemoveItemPacket();
-		break;
-	case PACKET_TAKEITEM:
-		packet = new TakeItemPacket();
-		break;
 	case PACKET_TAKEITEMENTITY:
 		packet = new TakeItemEntityPacket();
 		break;
@@ -75,9 +68,6 @@ Packet* MinecraftPackets::createPacket(int id)
 	case PACKET_RESPAWN:
 		packet = new RespawnPacket();
 		break;
-	case PACKET_WANTCREATEITEM:
-		packet = new WantCreatePacket();
-		break;
 	case PACKET_REMOVEENTITY:
 		packet = new RemoveEntityPacket();
 		break;

src/network/Packet.h

@@ -33,9 +33,6 @@ enum MinecraftPacketIds
 	PACKET_REMOVEENTITY,
 	PACKET_ADDITEMENTITY,
 	PACKET_TAKEITEMENTITY,
-	PACKET_TAKEITEM,
-	PACKET_REMOVEITEM,
-	PACKET_WANTCREATEITEM,
 
 	PACKET_MOVEENTITY,
 	PACKET_MOVEENTITY_POS,

src/network/ServerSideNetworkHandler.cpp

@@ -5,16 +5,6 @@
 #include "../world/entity/player/Inventory.h"
 #include "../world/Container.h"
 #include "../world/inventory/BaseContainerMenu.h"
-#include "network/packet/ChatPacket.h"
-#include "network/packet/ContainerSetSlotPacket.h"
-#include "network/packet/LoginStatusPacket.h"
-#include "network/packet/MovePlayerPacket.h"
-#include "network/packet/RemoveBlockPacket.h"
-#include "network/packet/SendInventoryPacket.h"
-#include "network/packet/UpdateBlockPacket.h"
-#include "network/packet/RemoveItemPacket.h"
-#include "network/packet/TakeItemPacket.h"
-#include "network/packet/WantCreatePacket.h"
 #include "packet/PacketInclude.h"
 
 #include "RakNetInstance.h"
@@ -23,17 +13,6 @@
 #include "../client/gamemode/GameMode.h"
 #include "../raknet/RakPeerInterface.h"
 #include "../raknet/PacketPriority.h"
-#include "platform/log.h"
-#include "util/Mth.h"
-#include "util/StringUtils.h"
-#include "world/item/ItemInstance.h"
-#include "world/level/LevelConstants.h"
-#include "world/level/storage/LevelStorage.h"
-#include "world/phys/Vec3.h"
-#include "world/item/crafting/Recipe.h"
-#include "world/item/crafting/Recipes.h"
-#include <cstddef>
-#include <cstdio>
 #ifndef STANDALONE_SERVER
 #include "../client/sound/SoundEngine.h"
 #endif
@@ -74,11 +53,11 @@ void ServerSideNetworkHandler::tileChanged(int x, int y, int z)
 
 Packet* ServerSideNetworkHandler::getAddPacketFromEntity( Entity* entity ) {
 	if (entity->isMob() && !entity->isPlayer()) { //@fix: This code is duplicated. See if it can be unified.
-		// if (minecraft->player) {
+		if (minecraft->player) {
 			// I guess this should always be true, but it crashed somewhere in this
 			// function once and I only see this one as a potential problem
 			return new AddMobPacket((Mob*)entity);
-		// }
+		}
 	}
 	else if (entity->isPlayer()) {
 
@@ -157,18 +136,7 @@ void ServerSideNetworkHandler::displayGameMessage(const std::string& message)
 
 void ServerSideNetworkHandler::handle(const RakNet::RakNetGUID& source, ChatPacket* packet)
 {
-	auto player = getPlayer(source);
+	displayGameMessage(packet->message);
-
-	if (player == nullptr) return; // @todo maybe kick?
-	
-	if (packet->message[0] == '/') {
-		// This is a command
-
-		ChatPacket resp(minecraft->commandManager().execute(*minecraft, *player, Util::stringTrim(packet->message.substr(1))));
-		return sendPrivate(resp, source);
-	}
-
-	displayGameMessage("<" + player->name + "> " + packet->message);
 }
 
 void ServerSideNetworkHandler::onNewClient(const RakNet::RakNetGUID& clientGuid)
@@ -188,8 +156,6 @@ void ServerSideNetworkHandler::onDisconnect(const RakNet::RakNetGUID& guid)
 
 		if (player->owner == guid)
 		{
-			minecraft->level->getLevelStorage()->savePlayer(*player);
-
 			std::string message = player->name;
 			message += " disconnected from the game";
 			displayGameMessage(message);
@@ -220,32 +186,8 @@ void ServerSideNetworkHandler::handle(const RakNet::RakNetGUID& source, LoginPac
 	//
 	bool oldClient = packet->clientNetworkVersion < SharedConstants::NetworkProtocolLowestSupportedVersion;
 	bool oldServer = packet->clientNetworkLowestSupportedVersion > SharedConstants::NetworkProtocolVersion;
-	if (oldClient || oldServer || !packet->newProto)
+	if (oldClient || oldServer)
-		loginStatus = oldClient || !packet->newProto? LoginStatus::Failed_ClientOld : LoginStatus::Failed_ServerOld;
+		loginStatus = oldClient? LoginStatus::Failed_ClientOld : LoginStatus::Failed_ServerOld;
-
-	std::string nicknameLower = packet->clientName.C_String();
-	std::transform(nicknameLower.begin(), nicknameLower.end(), nicknameLower.begin(), ::tolower);
-
-	printf("%s lower \n", nicknameLower.c_str());
-	for (int i = 0; i < level->players.size(); i++) {
-		ServerPlayer* player = (ServerPlayer*) level->players.at(i);
-
-		std::string clientLower = player->name;
-		std::transform(clientLower.begin(), clientLower.end(), clientLower.begin(), ::tolower);
-
-		// @todo to lower case
-		if (nicknameLower == clientLower) {
-			loginStatus = packet->newProto ? LoginStatus::Failed_TakenNickname : LoginStatus::Failed_ClientOld;
-			break;
-		}
-	}
-	
-	for (auto& banned : level->bannedPpl) {
-		if (nicknameLower == banned) {
-			loginStatus = packet->newProto ? LoginStatus::Failed_Banned : LoginStatus::Failed_ClientOld;
-			break;
-		}
-	}
 
 	RakNet::BitStream bitStream;
 	LoginStatusPacket(loginStatus).write(&bitStream);
@@ -257,16 +199,13 @@ void ServerSideNetworkHandler::handle(const RakNet::RakNetGUID& source, LoginPac
 	//
 	// Valid client version
 	//
-	
+	Player* newPlayer = new ServerPlayer(minecraft, level);
-	Player* newPlayer = new ServerPlayer(minecraft, level, packet->newProto);
 
 	minecraft->gameMode->initAbilities(newPlayer->abilities);
 	newPlayer->owner = source;
 	newPlayer->name = packet->clientName.C_String();
 	_pendingPlayers.push_back(newPlayer);
 
-	LOGI("Adding new player... isCreative: %i\n", minecraft->isCreativeMode());
-
 	// Reset the player so he doesn't spawn inside blocks
 	while (newPlayer->y > 0) {
 		newPlayer->setPos(newPlayer->x, newPlayer->y, newPlayer->z);
@@ -289,8 +228,7 @@ void ServerSideNetworkHandler::handle(const RakNet::RakNetGUID& source, LoginPac
             level->getLevelData()->getGeneratorVersion(),
             gameType,
             newPlayer->entityId,
-            newPlayer->x, newPlayer->y - newPlayer->heightOffset, newPlayer->z,
+            newPlayer->x, newPlayer->y - newPlayer->heightOffset, newPlayer->z
-			LevelConstants::CHUNK_CACHE_WIDTH
         ).write(&bitStream);
 
         rakPeer->Send(&bitStream, HIGH_PRIORITY, RELIABLE_ORDERED, 0, source, false);
@@ -306,8 +244,6 @@ void ServerSideNetworkHandler::handle(const RakNet::RakNetGUID& source, ReadyPac
 
 	if (packet->type == ReadyPacket::READY_REQUESTEDCHUNKS)
 		onReady_RequestedChunks(source);
-
-	LOGI("Ready player two ready ready player two!!\n ");
 }
 
 void ServerSideNetworkHandler::onReady_ClientGeneration(const RakNet::RakNetGUID& source)
@@ -365,36 +301,6 @@ void ServerSideNetworkHandler::onReady_ClientGeneration(const RakNet::RakNetGUID
 		}
 	}
 
-	if (!minecraft->level->getLevelStorage()->loadPlayer(*newPlayer)) {
-		LOGW("Failed to load %s data\n", newPlayer->name.c_str());
-	}
-
-	// Credits to EpikIzCool
-	bitStream.Reset();
-	MovePlayerPacket mv(newPlayer->entityId, newPlayer->x, newPlayer->y - newPlayer->heightOffset,
-		newPlayer->z, newPlayer->xRot, newPlayer->yRot);
-	mv.write(&bitStream);
-
-	rakPeer->Send(&bitStream, HIGH_PRIORITY, RELIABLE_ORDERED, 0, source, false);
-	
-	bitStream.Reset();
-	SetHealthPacket hp(newPlayer->health);
-	hp.write(&bitStream);
-	
-	rakPeer->Send(&bitStream, HIGH_PRIORITY, RELIABLE_ORDERED, 0, source, false);
-	
-	if (newPlayer->hasRespawnPosition()) {
-		bitStream.Reset();
-		SetSpawnPositionPacket sp(newPlayer->getRespawnPosition());
-		sp.write(&bitStream);
-		rakPeer->Send(&bitStream, HIGH_PRIORITY, RELIABLE_ORDERED, 0, source, false);
-	}
-
-	bitStream.Reset();
-	SendInventoryPacket(newPlayer, false).write(&bitStream);
-	rakPeer->Send(&bitStream, HIGH_PRIORITY, RELIABLE_ORDERED, 0, source, false);
-
-
 	// Additional packets
 	// * set spawn
 	/*
@@ -433,31 +339,14 @@ void ServerSideNetworkHandler::handle(const RakNet::RakNetGUID& source, MovePlay
 {
 	if (!level) return;
 
-	LOGI("MovePlayerPacket\n");
+	//LOGI("MovePlayerPacket\n");
-	if (Entity* entity = level->getEntity(packet->entityId)) {
+	if (Entity* entity = level->getEntity(packet->entityId))
-		ServerPlayer* player = (ServerPlayer*) getPlayer(source);
+	{
-
-		// int timeElapsed = minecraft->getTicks() - player->getLastMoveTicks();
-
-		// if (timeElapsed > 0) {
-		// 	float dist = player->distanceTo(packet->x, player->y, packet->z);
-		// 	float speed = dist / (minecraft->getTicks() - player->getLastMoveTicks());
-		// 	player->setLastMoveTicks(minecraft->getTicks());
-
-		// 	float maxSpeed = (minecraft->isCreativeMode()) ? 1.65f : 1.f;
-
-		// 	if (speed > maxSpeed) {
-		// 		MovePlayerPacket refuse(player->entityId, player->x, player->y, player->z, player->xRot, player->yRot);
-		//     	return raknetInstance->send(refuse);
-		// 	}
-		// }
-
 		entity->xd = entity->yd = entity->zd = 0;
 		entity->lerpTo(packet->x, packet->y, packet->z, packet->yRot, packet->xRot, 3);
 
 		// broadcast this packet to other clients
 		redistributePacket(packet, source);
-	
 	}
 }
 
@@ -479,29 +368,12 @@ void ServerSideNetworkHandler::handle(const RakNet::RakNetGUID& source, RemoveBl
 	if (oldTile != NULL && changed) {
 		level->playSound(x + 0.5f, y + 0.5f, z + 0.5f, oldTile->soundType->getBreakSound(), (oldTile->soundType->getVolume() + 1) / 2, oldTile->soundType->getPitch() * 0.8f);
 
-		if (minecraft->gameMode->isSurvivalType() && player->canDestroy(oldTile)) {
+		if (minecraft->gameMode->isSurvivalType() && player->canDestroy(oldTile))
-			// From SurvivalMode.cpp
+			//oldTile->spawnResources(level, x, y, z, data, 1); //@todo
-			// Why tf i have to copy this shit from SurvivalMode class
-			// Why SurvivalMode class locked to LOCAL MINECRAFT PLAYER :sob: :sob: :sob: :sob: :sob: :sob: :sob: :sob:
-			// @fix @warn @ahtung @alert
-			ItemInstance* item = player->inventory->getSelected();
-			if (item != NULL) {
-				item->mineBlock(oldTile->id, x, y, z);
-				if (item->count == 0) {
-					//item->snap(minecraft->player);
-					player->inventory->clearSlot(player->inventory->selected);
-				}
-			}
-
-			// oldTile->spawnResources(level, x, y, z, data, 1); //@todo
 			oldTile->playerDestroy(level, player, x, y, z, data);
-		}
-			
 
 		oldTile->destroy(level, x, y, z, data);
 	}
-
-	LOGI("Remove block [%i, %i, %i]\n", packet->x, packet->y, packet->z);
 }
 
 void ServerSideNetworkHandler::handle(const RakNet::RakNetGUID& source, RequestChunkPacket* packet)
@@ -531,8 +403,6 @@ void ServerSideNetworkHandler::handle(const RakNet::RakNetGUID& source, RequestC
             raknetInstance->send(source, p);
         }
     }
-
-	// LOGI("Requested chunk [%i, %i]\n", packet->x, packet->z);
 }
 
 void ServerSideNetworkHandler::levelGenerated( Level* level )
@@ -559,31 +429,23 @@ void ServerSideNetworkHandler::handle(const RakNet::RakNetGUID& source, PlayerEq
 	if (!player) return;
 	if (rakPeer->GetMyGUID() == player->owner) return;
 
-	LOGI("Equip item: id %i aux %i\n", packet->itemId, packet->itemAuxValue);
-
 	// override the player's inventory
-	int slot = player->inventory->getSlot(packet->itemId, packet->itemAuxValue);
+	//int slot = player->inventory->getSlot(packet->itemId, packet->itemAuxValue);
-
+	int slot = Inventory::MAX_SELECTION_SIZE;
-	if (slot >= 0 && slot != packet->inventorySlot && packet->itemId != 0) {
+	if (slot >= 0) {
-		LOGW("PlayerEquipmentPacket: Item in player inventory but slots doesn't match!");
+		if (packet->itemId == 0) {
-		packet->inventorySlot = slot;
+			player->inventory->clearSlot(slot);
+		} else {
+			// @note: 128 is an ugly hack for depletable items.
+			// @todo: fix
+			ItemInstance newItem(packet->itemId, 128, packet->itemAuxValue);
+			player->inventory->replaceSlot(slot, &newItem);
+		}
+		player->inventory->moveToSelectedSlot(slot, true);
+		redistributePacket(packet, source);
+	} else {
+		LOGW("Warning: Remote player doesn't have his thing, Odd!\n");
 	}
-
-	if (slot < 0 && packet->itemId != 0) {
-		LOGW("PlayerEquipmentPacket: Remote player doesn't have his thing (or crafted it)!\n");
-
-		SendInventoryPacket newInventory (player, false);
-		raknetInstance->send(newInventory);
-
-		return;
-	}
-
-	player->inventory->selectSlot(packet->selectedSlot);
-	player->inventory->linkSlot(packet->selectedSlot, packet->inventorySlot, true);
-
-	player->inventory->print();
-
-	redistributePacket(packet, source);
 }
 
 void ServerSideNetworkHandler::handle(const RakNet::RakNetGUID& source, PlayerArmorEquipmentPacket* packet) {
@@ -593,8 +455,6 @@ void ServerSideNetworkHandler::handle(const RakNet::RakNetGUID& source, PlayerAr
     if (!player) return;
     if (rakPeer->GetMyGUID() == player->owner) return;
 
-	// LOGI("Equip armor: %i %i %i %i\n", packet->head, packet->torso, packet->legs, packet->feet);
-
     packet->fillIn(player);
     redistributePacket(packet, source);
 }
@@ -606,8 +466,6 @@ void ServerSideNetworkHandler::handle(const RakNet::RakNetGUID& source, Interact
 	Entity* entity = level->getEntity(packet->targetId);
 	if (src && entity && src->isPlayer())
 	{
-		LOGI("Interact: source %i target %i\n", packet->sourceId, packet->targetId);
-
 		Player* player = (Player*) src;
 		if (InteractPacket::Attack == packet->action) {
 			player->swing();
@@ -648,70 +506,12 @@ void ServerSideNetworkHandler::handle(const RakNet::RakNetGUID& source, AnimateP
 	}
 	redistributePacket(packet, source);
 }
-void ServerSideNetworkHandler::handle(const RakNet::RakNetGUID& source, WantCreatePacket* packet) {
-	LOGI("WantCreatePacket\n");
-	Entity* entity = level->getEntity(packet->playerId);
-
-	if (entity && entity->isPlayer()) {
-		Player* p = (Player*)entity;
-		
-		auto playerInv = p->inventory;
-		
-		ItemInstance wantCreate;
-
-		wantCreate.id = packet->itemId;
-		wantCreate.count = packet->count;
-		wantCreate.setAuxValue(packet->auxValue);
-
-		Recipe* recipe = Recipes::getInstance()->getRecipeFor(wantCreate);
-
-		std::vector<ItemInstance> items = recipe->getItemPack().getItemInstances();
-
-		std::vector<int> checkForExists = {};
-
-		for (int i = Inventory::MAX_SELECTION_SIZE; i < p->inventory->getContainerSize(); ++i) {
-			auto itm = p->inventory->getItem(i);
-
-			if (itm != NULL) {
-				for (int y = 0; y < items.size(); y++) {
-					auto itmRecipe = items.at(y);
-
-					if (itmRecipe.id == itm->id && itm->count >= itmRecipe.count) {
-						checkForExists.push_back(itm->id);
-					}
-				}
-			}
-		}
-		
-		if (checkForExists.empty()) {
-			return;
-		}
-		
-		for (int i = 0; i < items.size(); i++) {
-			auto item = items.at(i);
-			
-    		auto it = std::find(checkForExists.begin(), checkForExists.end(), item.id);
-
-			if (it == checkForExists.end() && checkForExists.size() > 1) {
-				return;
-			}
-		}
-
-		for (int i = 0; i < items.size(); i++) {
-			p->inventory->removeResource(ItemInstance(items.at(i).id, items.at(i).count, items.at(i).getAuxValue()));
-		}
-		// TakeItemPacket itemAdd(p->entityId, wantCreate.count, wantCreate.getAuxValue(), wantCreate.id);
-		// raknetInstance->send(source, itemAdd);
-
-		p->inventory->add(new ItemInstance(wantCreate.id, wantCreate.count, wantCreate.getAuxValue()));
-	}
-}
 
 void ServerSideNetworkHandler::handle(const RakNet::RakNetGUID& source, UseItemPacket* packet)
 {
 	if (!level) return;
 
-	LOGI("UseItemPacket: id %i data %i\n", packet->itemId, packet->itemData);
+	LOGI("UseItemPacket\n");
 	Entity* entity = level->getEntity(packet->entityId);
 	if (entity && entity->isPlayer()) {
 		Player* player = (Player*) entity;
@@ -722,30 +522,7 @@ void ServerSideNetworkHandler::handle(const RakNet::RakNetGUID& source, UseItemP
 		if (t && t->use(level, x, y, z, player)) return;
 		if (packet->item.isNull()) return;
 
-		ItemInstance* packetItem = &packet->item;
+		ItemInstance* item = &packet->item;
-
-		int slot = player->inventory->getSlot(packet->itemId, packet->itemData);
-
-		if (slot < 0) {
-			LOGW("UseItemPacket: Player doesn't have this item!\n");
-
-			auto pos = Vec3(packet->x, packet->y, packet->z);
-
-			if (ItemInstance::isBlock(packetItem)) {
-				LOGI("UseItemPacket: This is even block!!!\n");
-
-				pos.x += packet->clickX;
-				pos.y += packet->clickY;
-				pos.z += packet->clickZ;
-			}
-
-			UpdateBlockPacket refuse(pos.x, pos.y, pos.z, level->getTile(pos.x, pos.y, pos.z), level->getData(pos.x, pos.y, pos.z));
-			raknetInstance->send(refuse);
-
-			return;
-		}
-
-		ItemInstance* item = player->inventory->getItem(slot);
 
 		if(packet->face == 255) {
             // Special case: x,y,z means direction-of-action
@@ -757,10 +534,6 @@ void ServerSideNetworkHandler::handle(const RakNet::RakNetGUID& source, UseItemP
 				Vec3(packet->clickX + packet->x, packet->clickY + packet->y, packet->clickZ + packet->z));
 		}
 		
-		if (item && item->count <= 0) {
-			player->inventory->clearSlot(slot);
-		}
-		
 		//LOGW("Use Item not working! Out of synch?\n");
 
 		// Don't have to redistribute (ugg.. this will mess up), cause tileUpdated is sent
@@ -771,8 +544,6 @@ void ServerSideNetworkHandler::handle(const RakNet::RakNetGUID& source, UseItemP
 void ServerSideNetworkHandler::handle(const RakNet::RakNetGUID& source, EntityEventPacket* packet) {
 	if (!level) return;
 
-	LOGI("EntityEventPacket: id %i\n", packet->eventId);
-
 	if (Entity* e = level->getEntity(packet->entityId))
 		e->handleEntityEvent(packet->eventId);
 }
@@ -806,11 +577,6 @@ void ServerSideNetworkHandler::handle( const RakNet::RakNetGUID& source, SendInv
 {
 	if (!level) return;
 
-	LOGI("SendInventoryPacket:\n");
-	for (int i = 0; i < packet->numItems; i++) {
-		LOGI("\t %i: %s (%i)\n", i, packet->items.at(i).getName().c_str(), packet->items.at(i).count);
-	}
-
 	Entity* entity = level->getEntity(packet->entityId);
 	if (entity && entity->isPlayer()) {
 		Player* p = (Player*)entity;
@@ -826,27 +592,15 @@ void ServerSideNetworkHandler::handle( const RakNet::RakNetGUID& source, DropIte
 {
 	if (!level) return;
 
-	LOGI("DropItemPacket\n");
-
 	Entity* entity = level->getEntity(packet->entityId);
 	if (entity && entity->isPlayer()) {
 		Player* p = (Player*)entity;
-		// p->drop(new ItemInstance(packet->item), packet->dropType != 0);
+		p->drop(new ItemInstance(packet->item), packet->dropType != 0);
-
-		int slot = p->inventory->getSlot(packet->item.id, packet->item.getAuxValue());
-
-		if (slot < 0) {
-			LOGW("DropItemPacket: player doesn't have these items!\n");
-			return;
-		}
-
-		p->inventory->dropSlot(slot, false, packet->dropType != 0);
 	}
 }
 
 void ServerSideNetworkHandler::handle(const RakNet::RakNetGUID& source, ContainerClosePacket* packet) {
 	if (!level) return;
-	LOGI("ContainerClosePacket\n");
 
 	Player* p = findPlayer(level, &source);
 	if (!p) return;
@@ -858,16 +612,6 @@ void ServerSideNetworkHandler::handle(const RakNet::RakNetGUID& source, Containe
 void ServerSideNetworkHandler::handle(const RakNet::RakNetGUID& source, ContainerSetSlotPacket* packet) {
 	if (!level) return;
 
-	const char* type = "unknown";
-
-	switch (packet->setType) {
-		case ContainerSetSlotPacket::SETTYPE_ADD: type = "add"; break;
-		case ContainerSetSlotPacket::SETTYPE_SET: type = "set"; break;
-		case ContainerSetSlotPacket::SETTYPE_TAKE: type = "take"; break;
-	};
-
-	LOGI("ContainerSetSlot: slot %i item %s type %s\n", packet->slot, packet->item.getName().c_str(), type);
-
 	Player* p = findPlayer(level, &source);
 	if (!p) return;
 
@@ -875,80 +619,12 @@ void ServerSideNetworkHandler::handle(const RakNet::RakNetGUID& source, Containe
 		LOGW("User has no container!\n");
 		return;
 	}
-
+	if (p->containerMenu->containerId != packet->containerId)
-	if (p->containerMenu->containerId != packet->containerId) {
+	{
 		LOGW("Wrong container id: %d vs %d\n", p->containerMenu->containerId, packet->containerId);
 		return;
 	}
 	
-	if (packet->item.count > 64) {
-		LOGW("ContainerSetSlotPacket: player tried to put more than 64");
-		return;
-	}
-
-	auto contItems = p->containerMenu->getItems();
-
-	// find same item in player inventory (used not in all cases)
-	int invSlot = p->inventory->getSlot(packet->item.id, packet->item.getAuxValue());
-	auto invItem = p->inventory->getItem(invSlot);
-
-	if (contItems.at(packet->slot).id == 0 && packet->item.id != 0) {
-		LOGI("ContainerSetSlotPacket: player tried to put items to slot %i\n", packet->slot);
-
-		if (invSlot < 0) {
-			LOGW("ContainerSetSlotPacket: player doesn't have this item\n");
-			return;
-		}
-
-		if (invItem->count < packet->item.count) {
-			LOGW("ContainerSetSlotPacket: player tried to put more than he have\n");
-			packet->item.count = invItem->count;
-		}
-
-		invItem->count -= packet->item.count;
-
-		if (invItem->count <= 0) {
-			p->inventory->removeItem(invItem);
-		}
-	} else if(contItems.at(packet->slot).id == packet->item.id) {
-		int deltaItem = packet->item.count - contItems.at(packet->slot).count;
-
-		if (deltaItem > 0) {
-			LOGI("ContainerSetSlotPacket: player tried to add %i items to slot %i\n", deltaItem, packet->slot);
-
-			auto invItem = p->inventory->getItem(invSlot);
-
-			if (invSlot < 0) {
-				LOGW("ContainerSetSlotPacket: player doesn't have this item\n");
-				return;
-			}
-
-			if (invItem->count < deltaItem) {
-				LOGW("ContainerSetSlotPacket: player tried to put more than he have");
-				packet->item.count -= (deltaItem - invItem->count);
-				deltaItem = invItem->count;
-			}
-
-			invItem->count -= deltaItem;
-
-			if (invItem->count <= 0) {
-				p->inventory->removeItem(invItem);
-			}
-		} else if (deltaItem < 0) {
-			LOGW("ContainerSetSlotPacket: player tried to take %i items from slot %i\n", -deltaItem, packet->slot);
-			p->inventory->add(new ItemInstance(packet->item.getItem(), -deltaItem, contItems.at(packet->slot).getAuxValue()));
-		}
-	} else if(contItems.at(packet->slot).id && !packet->item.id) {
-		LOGI("ContainerSetSlotPacket: player tried to take all items from slot %i\n", packet->slot);
-		packet->item.count = 0;
-		packet->item.setAuxValue(0);
-
-		p->inventory->add(new ItemInstance(contItems.at(packet->slot).getItem(), contItems.at(packet->slot).count, contItems.at(packet->slot).getAuxValue()));
-	} else {
-		LOGW("ContainerSetSlotPacket: illegal container operation in slot %i\n", packet->slot);
-		return;
-	}
-	
 	if (ContainerType::FURNACE == p->containerMenu->containerType) {
 		//LOGI("Server:Setting slot %d: %s\n", packet->slot, packet->item.toString().c_str());
 		p->containerMenu->setSlot(packet->slot, &packet->item);
@@ -959,8 +635,6 @@ void ServerSideNetworkHandler::handle(const RakNet::RakNetGUID& source, Containe
 		p->containerMenu->setSlot(packet->slot, &packet->item);
 		//p->containerMenu->setSlot(packet->slot, packet->item.isNull()? NULL : &packet->item);
 	}
-
-	p->inventory->print();
 }
 
 void ServerSideNetworkHandler::handle( const RakNet::RakNetGUID& source, SetHealthPacket* packet )
@@ -983,8 +657,6 @@ void ServerSideNetworkHandler::handle( const RakNet::RakNetGUID& source, SignUpd
 	if (!level)
 		return;
 
-		LOGI("SignUpdate: [%i, %i, %i]\n", packet->x, packet->y, packet->z);
-
 	TileEntity* te = level->getTileEntity(packet->x, packet->y, packet->z);
 	if (TileEntity::isType(te, TileEntityType::Sign)) {
 		SignTileEntity* ste = (SignTileEntity*) te;
@@ -1041,9 +713,3 @@ Player* ServerSideNetworkHandler::getPlayer( const RakNet::RakNetGUID& source )
         if (source == level->players[i]->owner) return level->players[i];
     return NULL;
 }
-
-void ServerSideNetworkHandler::sendPrivate(Packet& packet, const RakNet::RakNetGUID& source) {
-	RakNet::BitStream bitStream;
-	packet.write(&bitStream);
-	rakPeer->Send(&bitStream, HIGH_PRIORITY, RELIABLE_ORDERED, 0, source, false);
-}

src/network/ServerSideNetworkHandler.h

@@ -58,7 +58,6 @@ public:
 	virtual void handle(const RakNet::RakNetGUID& source, ContainerClosePacket* packet);
 	virtual void handle(const RakNet::RakNetGUID& source, SignUpdatePacket* packet);
 	virtual void handle(const RakNet::RakNetGUID& source, ChatPacket* packet);
-	virtual void handle(const RakNet::RakNetGUID& source, WantCreatePacket* packet);
 
 	bool allowsIncomingConnections() { return _allowIncoming; }
 	void allowIncomingConnections(bool doAllow);
@@ -71,12 +70,6 @@ private:
 	 * @brief Send packet to all players
 	 */
 	void redistributePacket(Packet* packet, const RakNet::RakNetGUID& fromPlayer);
-
-	/**
-	 * @brief Send packer private with GUID
-	 */
-	void sendPrivate(Packet& packet, const RakNet::RakNetGUID& source);
-
 	Player* getPlayer(const RakNet::RakNetGUID& source);
 
 	Minecraft*					minecraft;

src/network/command/CommandServer.cpp

@@ -236,9 +236,9 @@ std::string CommandServer::parse(ConnectedClient& client, const std::string& s)
 		if (x0 < 0) x0 = 0;
 		if (y0 < 0) y0 = 0;
 		if (z0 < 0) z0 = 0;
-		if (x1 >= LevelConstants::LEVEL_WIDTH ) x1 = LevelConstants::LEVEL_WIDTH  - 1;
+		if (x1 >= LEVEL_WIDTH ) x1 = LEVEL_WIDTH  - 1;
-		if (y1 >= LevelConstants::LEVEL_HEIGHT) y1 = LevelConstants::LEVEL_HEIGHT - 1;
+		if (y1 >= LEVEL_HEIGHT) y1 = LEVEL_HEIGHT - 1;
-		if (z1 >= LevelConstants::LEVEL_DEPTH ) z1 = LevelConstants::LEVEL_DEPTH  - 1;
+		if (z1 >= LEVEL_DEPTH ) z1 = LEVEL_DEPTH  - 1;
 
 		for (int y = y0; y <= y1; ++y)
 		for (int z = z0; z <= z1; ++z)
@@ -456,7 +456,7 @@ std::string CommandServer::parse(ConnectedClient& client, const std::string& s)
 			sw.start();
 
 			// Save a cuboid around the player
-			const int CSize = LevelConstants::CHUNK_CACHE_WIDTH;
+			const int CSize = CHUNK_CACHE_WIDTH;
 			int cx = (int)e->x / CSize;
 			int cz = (int)e->z / CSize;
 
@@ -504,7 +504,7 @@ bool CommandServer::handleCheckpoint(bool doRestore ) {
 	const int cz = restorePos.z;
 	const int y0 = restorePos.y;
 	const int y1 = y0 + RestoreHeight;
-	const int CSize = LevelConstants::CHUNK_CACHE_WIDTH;
+	const int CSize = CHUNK_CACHE_WIDTH;
 	const int numChunkBytes = RestoreHeight * CSize * CSize * 20 / 8;
 
 	if (!restoreBuffer) {

src/network/packet/ChunkDataPacket.h

@@ -33,18 +33,18 @@ public:
 		unsigned char* blockIds = chunk->getBlockData();
 		DataLayer& blockData = chunk->data;
 
-		const int setSize = LevelConstants::LEVEL_HEIGHT / 8;
+		const int setSize = LEVEL_HEIGHT / 8;
-		const int setShift = 4; // power of LevelConstants::LEVEL_HEIGHT / 8
+		const int setShift = 4; // power of LEVEL_HEIGHT / 8
 
 		chunkData.Reset();
-		for (int i = 0; i < LevelConstants::CHUNK_COLUMNS; i++)
+		for (int i = 0; i < CHUNK_COLUMNS; i++)
 		{
 			unsigned char updateBits = chunk->updateMap[i];
 			chunkData.Write(updateBits);
 
 			if (updateBits > 0)
 			{
-				int colDataPosition = (i % LevelConstants::CHUNK_WIDTH) << 11 | (i / LevelConstants::CHUNK_WIDTH) << 7;
+				int colDataPosition = (i % CHUNK_WIDTH) << 11 | (i / CHUNK_WIDTH) << 7;
 
 				for (int set = 0; set < 8; set++)
 				{

src/network/packet/LoginPacket.h

@@ -9,20 +9,17 @@ public:
 	RakNet::RakString clientName;
 	int clientNetworkVersion;
 	int clientNetworkLowestSupportedVersion;
-	bool newProto;
 
 	LoginPacket()
 	:	clientNetworkVersion(-1),
-		clientNetworkLowestSupportedVersion(-1),
+		clientNetworkLowestSupportedVersion(-1)
-		newProto(false)
 	{
 	}
 
-	LoginPacket(const RakNet::RakString& clientName, int clientVersion, bool newProto)
+	LoginPacket(const RakNet::RakString& clientName, int clientVersion)
 	:	clientName(clientName),
 		clientNetworkVersion(clientVersion),
-		clientNetworkLowestSupportedVersion(clientVersion),
+		clientNetworkLowestSupportedVersion(clientVersion)
-		newProto(newProto)
 	{
 	}
 
@@ -32,7 +29,6 @@ public:
 		bitStream->Write(clientName);
 		bitStream->Write(clientNetworkVersion);
 		bitStream->Write(clientNetworkLowestSupportedVersion);
-		bitStream->Write(newProto);
 	}
 
 	void read(RakNet::BitStream* bitStream)
@@ -43,11 +39,6 @@ public:
 		if (bitStream->GetNumberOfUnreadBits() > 0) {
 			bitStream->Read(clientNetworkVersion);
 			bitStream->Read(clientNetworkLowestSupportedVersion);
-			
-			// Checking for new proto
-			if (bitStream->GetNumberOfUnreadBits() > 0) {
-				bitStream->Read(newProto);
-			}
 		}
 	}
 

src/network/packet/LoginStatusPacket.h

@@ -3,13 +3,10 @@
 
 #include "../Packet.h"
 
-// wtf why not enum
 namespace LoginStatus {
 	const int Success = 0;
 	const int Failed_ClientOld = 1;
 	const int Failed_ServerOld = 2;
-	const int Failed_TakenNickname = 3;
-	const int Failed_Banned = 4;
 }
 
 class LoginStatusPacket : public Packet {

src/network/packet/PacketInclude.h

@@ -50,7 +50,5 @@
 #include "TileEventPacket.h"
 #include "UpdateBlockPacket.h"
 #include "UseItemPacket.h"
-#include "RemoveItemPacket.h"
+
-#include "WantCreatePacket.h"
-#include "TakeItemPacket.h"
 #endif /*NET_MINECRAFT_NETWORK_PACKET__PacketInclude_H__*/

src/network/packet/PlayerEquipmentPacket.h

@@ -9,19 +9,15 @@ public:
 	int entityId;
 	unsigned short itemId;
 	unsigned short itemAuxValue;
-	unsigned char selectedSlot;
-	unsigned char inventorySlot;
 
 	PlayerEquipmentPacket()
 	{
 	}
 
-	PlayerEquipmentPacket(int entityId, int itemId, int data, int selSlot, int invSlot)
+	PlayerEquipmentPacket(int entityId, int itemId, int data)
 	:	entityId(entityId),
 		itemId(itemId),
-		itemAuxValue(data),
+		itemAuxValue(data)
-		selectedSlot(selSlot),
-		inventorySlot(invSlot)
 	{
 	}
 
@@ -32,8 +28,6 @@ public:
 		bitStream->Write(entityId);
 		bitStream->Write(itemId);
 		bitStream->Write(itemAuxValue);
-		bitStream->Write(selectedSlot);
-		bitStream->Write(inventorySlot);
 	}
 
 	void read(RakNet::BitStream* bitStream)
@@ -41,8 +35,6 @@ public:
 		bitStream->Read(entityId);
 		bitStream->Read(itemId);
 		bitStream->Read(itemAuxValue);
-		bitStream->Read(selectedSlot);
-		bitStream->Read(inventorySlot);
 	}
 
 	void handle(const RakNet::RakNetGUID& source, NetEventCallback* callback)

src/network/packet/RemoveItemPacket.h

@@ -1,54 +0,0 @@
-#ifndef NET_MINECRAFT_NETWORK_PACKET__RemoveItemPacket_H__
-#define NET_MINECRAFT_NETWORK_PACKET__RemoveItemPacket_H__
-
-//package net.minecraft.network.packet;
-
-#include "../Packet.h"
-
-class RemoveItemPacket: public Packet
-{
-public:
-    RemoveItemPacket() {
-    }
-
-    RemoveItemPacket(int playerId, int count, int auxValue, int itemId)
-	:
-		playerId(playerId),
-        count(count),
-		auxValue(auxValue),
-		itemId(itemId)
-	{
-    }
-
-	void write(RakNet::BitStream* bitStream)
-	{
-		bitStream->Write((RakNet::MessageID)(ID_USER_PACKET_ENUM + PACKET_REMOVEITEM));
-		bitStream->Write(itemId);
-		bitStream->Write(count);
-		bitStream->Write(auxValue);
-
-		bitStream->Write(playerId);
-	}
-
-	void read(RakNet::BitStream* bitStream)
-	{
-        bitStream->Read(itemId);
-        bitStream->Read(count);
-        bitStream->Read(auxValue);
-
-		bitStream->Read(playerId);
-	}
-
-	void handle(const RakNet::RakNetGUID& source, NetEventCallback* callback)
-	{
-		callback->handle(source, (RemoveItemPacket*)this);
-	}
-    
-    int playerId;
-
-    int itemId;
-	int count;
-	int auxValue;
-};
-
-#endif /*NET_MINECRAFT_NETWORK_PACKET__RemoveItemPacket_H__*/

src/network/packet/SendInventoryPacket.h

@@ -2,14 +2,13 @@
 #define NET_MINECRAFT_NETWORK_PACKET__SendInventoryPacket_H__
 
 #include "../Packet.h"
-#include "world/entity/player/Inventory.h"
-#include "world/inventory/FillingContainer.h"
-#include <array>
 
 class SendInventoryPacket: public Packet
 {
 public:
-	SendInventoryPacket() {}
+	SendInventoryPacket()
+	{
+	}
 
 	SendInventoryPacket(Player* player, bool dropItems)
 	:	entityId(player->entityId),
@@ -22,15 +21,10 @@ public:
 			ItemInstance* item = inv->getItem(i);
 			items.push_back(item? *item : ItemInstance());
         }
-
         for (int i = 0; i < NumArmorItems; ++i) {
             ItemInstance* item = player->getArmor(i);
             items.push_back(item? *item : ItemInstance());
         }
-
-		for (int i = 0; i < inv->numLinkedSlots; ++i) {
-            linkedSlot[i] = inv->linkedSlots[i];
-        }
 	}
 
 	void write(RakNet::BitStream* bitStream)
@@ -45,13 +39,6 @@ public:
         // Armor
         for (int i = 0; i < NumArmorItems; ++i)
             PacketUtil::writeItemInstance(items[i + numItems], bitStream);
-
-		int lSlots = Inventory::MAX_SELECTION_SIZE;
-
-		// Linked slots
-		bitStream->Write(lSlots);
-		for (int i = 0; i < lSlots; ++i)
-            bitStream->Write(linkedSlot[i]);
 	}
 
 	void read(RakNet::BitStream* bitStream)
@@ -63,12 +50,6 @@ public:
         // Inventory, Armor
 		for (int i = 0; i < numItems + NumArmorItems; ++i)
 			items.push_back(PacketUtil::readItemInstance(bitStream));
-
-		// Linked slots
-		int lSlots = 0;
-		bitStream->Read(lSlots);
-		for (int i = 0; i < lSlots; ++i)
-            bitStream->Read(linkedSlot[i]);
 	}
 
 	void handle(const RakNet::RakNetGUID& source, NetEventCallback* callback)
@@ -81,8 +62,6 @@ public:
 	short numItems;
 	unsigned char extra;
 
-	std::array<FillingContainer::LinkedSlot, Inventory::MAX_SELECTION_SIZE> linkedSlot;
-
 	static const int ExtraDrop = 1;
     static const int NumArmorItems = 4;
 };

src/network/packet/StartGamePacket.h

@@ -2,7 +2,6 @@
 #define NET_MINECRAFT_NETWORK_PACKET__StartGamePacket_H__
 
 #include "../Packet.h"
-#include "world/level/LevelConstants.h"
 #include <cstdint>
 
 class StartGamePacket : public Packet
@@ -15,20 +14,18 @@ public:
 	int entityId;
 	float x, y, z;
 
-	int chunkCacheWidth = 0;
 	StartGamePacket()
 	{
 	}
 
-	StartGamePacket(long seed, int levelGeneratorVersion, int gameType, int entityId, float x, float y, float z, int chunkCacheWidth)
+	StartGamePacket(long seed, int levelGeneratorVersion, int gameType, int entityId, float x, float y, float z)
 	:	levelSeed((int32_t)seed),
 		levelGeneratorVersion(levelGeneratorVersion),
 		gameType(gameType),
 		entityId(entityId),
 		x(x),
 		y(y),
-		z(z),
+		z(z)
-		chunkCacheWidth(chunkCacheWidth)
 	{
 	}
 
@@ -43,7 +40,6 @@ public:
 		bitStream->Write(x);
 		bitStream->Write(y);
 		bitStream->Write(z);
-		bitStream->Write(LevelConstants::CHUNK_CACHE_WIDTH);
 	}
 
 	void read(RakNet::BitStream* bitStream)
@@ -55,10 +51,6 @@ public:
 		bitStream->Read(x);
 		bitStream->Read(y);
 		bitStream->Read(z);
-
-		if (bitStream->GetNumberOfUnreadBits() > 0) {
-			bitStream->Read(chunkCacheWidth);
-		}
 	}
 
 	void handle(const RakNet::RakNetGUID& source, NetEventCallback* callback)

src/network/packet/TakeItemPacket.h

@@ -1,54 +0,0 @@
-#ifndef NET_MINECRAFT_NETWORK_PACKET__TakeItemPacket_H__
-#define NET_MINECRAFT_NETWORK_PACKET__TakeItemPacket_H__
-
-//package net.minecraft.network.packet;
-
-#include "../Packet.h"
-
-class TakeItemPacket: public Packet
-{
-public:
-    TakeItemPacket() {
-    }
-
-    TakeItemPacket(int playerId, int count, int auxValue, int itemId)
-	:
-		playerId(playerId),
-        count(count),
-		auxValue(auxValue),
-		itemId(itemId)
-	{
-    }
-
-	void write(RakNet::BitStream* bitStream)
-	{
-		bitStream->Write((RakNet::MessageID)(ID_USER_PACKET_ENUM + PACKET_TAKEITEM));
-		bitStream->Write(itemId);
-		bitStream->Write(count);
-		bitStream->Write(auxValue);
-
-		bitStream->Write(playerId);
-	}
-
-	void read(RakNet::BitStream* bitStream)
-	{
-        bitStream->Read(itemId);
-        bitStream->Read(count);
-        bitStream->Read(auxValue);
-
-		bitStream->Read(playerId);
-	}
-
-	void handle(const RakNet::RakNetGUID& source, NetEventCallback* callback)
-	{
-		callback->handle(source, (TakeItemPacket*)this);
-	}
-    
-    int playerId;
-
-    int itemId;
-	int count;
-	int auxValue;
-};
-
-#endif /*NET_MINECRAFT_NETWORK_PACKET__TakeItemPacket_H__*/

src/network/packet/WantCreatePacket.h

@@ -1,54 +0,0 @@
-#ifndef NET_MINECRAFT_NETWORK_PACKET__WantCreatePacket_H__
-#define NET_MINECRAFT_NETWORK_PACKET__WantCreatePacket_H__
-
-//package net.minecraft.network.packet;
-
-#include "../Packet.h"
-
-class WantCreatePacket: public Packet
-{
-public:
-    WantCreatePacket() {
-    }
-
-    WantCreatePacket(int playerId, int count, int auxValue, int itemId)
-	:
-		playerId(playerId),
-        count(count),
-		auxValue(auxValue),
-		itemId(itemId)
-	{
-    }
-
-	void write(RakNet::BitStream* bitStream)
-	{
-		bitStream->Write((RakNet::MessageID)(ID_USER_PACKET_ENUM + PACKET_WANTCREATEITEM));
-		bitStream->Write(itemId);
-		bitStream->Write(count);
-		bitStream->Write(auxValue);
-
-		bitStream->Write(playerId);
-	}
-
-	void read(RakNet::BitStream* bitStream)
-	{
-        bitStream->Read(itemId);
-        bitStream->Read(count);
-        bitStream->Read(auxValue);
-
-		bitStream->Read(playerId);
-	}
-
-	void handle(const RakNet::RakNetGUID& source, NetEventCallback* callback)
-	{
-		callback->handle(source, (WantCreatePacket*)this);
-	}
-    
-    int playerId;
-
-    int itemId;
-	int count;
-	int auxValue;
-};
-
-#endif /*NET_MINECRAFT_NETWORK_PACKET__WantCreatePacket_H__*/

src/server/ArgumentsSettings.cpp

@@ -17,11 +17,6 @@ ArgumentsSettings::ArgumentsSettings(int numArguments, char** arguments)
 				levelName = std::string(arguments[a+1]);
 				a++; // Skip the next argument since it's part of this one.
 			}
-		} else if(strcmp(arguments[a], "--gamemode") == 0) {
-			if(a + 1 < numArguments) {
-				gamemode = std::string(arguments[a+1]);
-				a++; // Skip the next argument since it's part of this one.
-			}
 		} else if(strcmp(arguments[a], "--leveldir") == 0) {
 			if(a + 1 < numArguments) {
 				levelDir = std::string(arguments[a+1]);
@@ -56,9 +51,6 @@ std::string ArgumentsSettings::getServerKey() {
 std::string ArgumentsSettings::getCachePath() {
 	return cachePath;
 }
-std::string ArgumentsSettings::getGamemode() {
-	return gamemode;
-}
 std::string ArgumentsSettings::getLevelDir() {
 	return levelDir;
 }

src/server/ArgumentsSettings.h

@@ -4,27 +4,20 @@
 class ArgumentsSettings {
 public:
 	ArgumentsSettings(int numArguments, char** arguments);
-
 	std::string getExternalPath();
 	std::string getLevelName();
 	std::string getServerKey();
 	std::string getCachePath();
 	std::string getLevelDir();
-	std::string getGamemode();
-
 	bool getShowHelp();
-
 	int getPort();
 private:
 	std::string cachePath;
 	std::string externalPath;
 	std::string levelName;
-	std::string gamemode;
 	std::string levelDir;
 	std::string serverKey;
-
 	bool showHelp;
-	
 	int port;
 };
 

src/server/ServerLevel.cpp

@@ -12,19 +12,16 @@ ServerLevel::ServerLevel(LevelStorage* levelStorage, const std::string& levelNam
 void ServerLevel::updateSleepingPlayerList() {
 	bool allPlayersWasSleeping = allPlayersAreSleeping;
 	allPlayersAreSleeping = !players.empty();
-	
+	for(PlayerList::iterator it = players.begin(); it != players.end(); ++it) {
-	for (PlayerList::iterator it = players.begin(); it != players.end(); ++it) {
 		Player* player = *it;
-		
+		if(!player->isSleeping()) {
-		if (!player->isSleeping()) {
 			allPlayersAreSleeping = false;
 			break;
 		}
 	}
-	if (!allPlayersWasSleeping && allPlayersAreSleeping) {
+	if(!allPlayersWasSleeping && allPlayersAreSleeping) {
 		levelEvent(NULL, LevelEvent::ALL_PLAYERS_SLEEPING, 0, 0, 0, 0);
-		
+		for(PlayerList::iterator it = players.begin(); it != players.end(); ++it) {
-		for (PlayerList::iterator it = players.begin(); it != players.end(); ++it) {
 			(*it)->setAllPlayersSleeping();
 		}
 	}
@@ -32,26 +29,23 @@ void ServerLevel::updateSleepingPlayerList() {
 
 void ServerLevel::awakenAllPlayers() {
 	allPlayersAreSleeping = false;
-	
+	for(PlayerList::iterator it = players.begin(); it != players.end(); ++it) {
-	for (PlayerList::iterator it = players.begin(); it != players.end(); ++it) {
 		Player* player = *it;
-		
+		if(player->isSleeping()) {
-		if (player->isSleeping()) {
 			player->stopSleepInBed(false, false, true);
 			player->health = Player::MAX_HEALTH;
 			player->lastHealth = Player::MAX_HEALTH; 
 		}
 	}
-	
 	SetHealthPacket packet(Player::MAX_HEALTH);
 	raknetInstance->send(packet);
 }
 
 bool ServerLevel::allPlayersSleeping() {
-	if (allPlayersAreSleeping && !isClientSide) {
+	if(allPlayersAreSleeping && !isClientSide) {
 		// all players are sleeping, but have they slept long enough?
-		for (PlayerList::iterator it = players.begin(); it != players.end(); ++it) {
+		for(PlayerList::iterator it = players.begin(); it != players.end(); ++it) {
-			if (!(*it)->isSleepingLongEnough()) {
+			if(!(*it)->isSleepingLongEnough()) {
 				return false;
 			}
 		}
@@ -61,17 +55,13 @@ bool ServerLevel::allPlayersSleeping() {
 	return false;
 }
 
-void ServerLevel::tick() {
+void ServerLevel::tick(){
 	super::tick();
-
+	if(allPlayersSleeping()) {
-	if (allPlayersSleeping()) {
 		long newTime = levelData.getTime() + TICKS_PER_DAY;
-		
 		levelData.setTime(newTime - (newTime % TICKS_PER_DAY));
-		
 		SetTimePacket packet(levelData.getTime());
 		raknetInstance->send(packet);
-		
 		awakenAllPlayers();
 	}
 }

src/server/ServerPlayer.cpp

@@ -19,17 +19,14 @@
 #include "../network/packet/AnimatePacket.h"
 #include "../world/level/tile/entity/ChestTileEntity.h"
 #include "../network/packet/HurtArmorPacket.h"
-#include "network/packet/SendInventoryPacket.h"
-#include "world/entity/player/Inventory.h"
 
-ServerPlayer::ServerPlayer( Minecraft* minecraft, Level* level, bool proto)
+ServerPlayer::ServerPlayer( Minecraft* minecraft, Level* level )
 :   super(level, minecraft->isCreativeMode()),
 	_mc(minecraft),
 	_prevHealth(-999),
-	_containerCounter(0),
+	_containerCounter(0)
-	isNewProto(proto)
 {
-	// hasFakeInventory = true;
+	hasFakeInventory = true;
 	footSize = 0;
 }
 
@@ -70,16 +67,7 @@ void ServerPlayer::tick() {
 
 void ServerPlayer::take( Entity* e, int orgCount ) {
 	TakeItemEntityPacket packet(e->entityId, entityId);
-	// SendInventoryPacket packet(this, false);
 	_mc->raknetInstance->send(packet);
-	printf("TakeItemEntityPacket \n");
-
-	LOGI("Inventory:\n");
-	for (int i = 0; i < inventory->numLinkedSlots; i++) {
-		auto item = inventory->getItem(i);
-		if (item)
-			LOGI("\t %i: %s (%i)\n", i, item->getName().c_str(), item->count);
-	}
 
 	super::take(e, orgCount);
 }
@@ -130,20 +118,20 @@ bool ServerPlayer::hasResource( int id ) {
 void ServerPlayer::setContainerData( BaseContainerMenu* menu, int id, int value ) {
 	ContainerSetDataPacket p(menu->containerId, id, value);
 	_mc->raknetInstance->send(owner, p);
-	LOGI("Setting container data for id %d: %d\n", id, value);
+	//LOGI("Setting container data for id %d: %d\n", id, value);
 }
 
 void ServerPlayer::slotChanged( BaseContainerMenu* menu, int slot, const ItemInstance& item, bool isResultSlot ) {
 	if (isResultSlot) return;
 	ContainerSetSlotPacket p(menu->containerId, slot, item);
 	_mc->raknetInstance->send(owner, p);
-	LOGI("Slot %d changed\n", slot);
+	//LOGI("Slot %d changed\n", slot);
 }
 
 void ServerPlayer::refreshContainer( BaseContainerMenu* menu, const std::vector<ItemInstance>& items ) {
 	ContainerSetContentPacket p(menu->containerId, menu->getItems());
 	_mc->raknetInstance->send(owner, p);
-	LOGI("Refreshing container with %zu items\n", items.size());
+	//LOGI("Refreshing container with %d items\n", items.size());
 }
 
 void ServerPlayer::nextContainerCounter() {
@@ -175,12 +163,3 @@ void ServerPlayer::displayClientMessage( const std::string& messageId ) {
 	ChatPacket package(messageId);
 	_mc->raknetInstance->send(owner, package);
 }
-
-void ServerPlayer::causeFallDamage(float distance) {
-	int dmg = (int) ceil((distance - 3));
-	if (dmg > 0) {
-		SetHealthPacket packet(SetHealthPacket::HEALTH_MODIFY_OFFSET + dmg);
-		_mc->raknetInstance->send(owner, packet);
-	}
-	super::causeFallDamage(distance);
-}

src/server/ServerPlayer.h

@@ -15,7 +15,7 @@ class ServerPlayer: public Player,
 {
     typedef Player super;
 public:
-    ServerPlayer(Minecraft* minecraft, Level* level, bool proto);
+    ServerPlayer(Minecraft* minecraft, Level* level);
 
 	~ServerPlayer();
 
@@ -43,17 +43,6 @@ public:
 	virtual void stopSleepInBed(bool forcefulWakeUp, bool updateLevelList, bool saveRespawnPoint);
 
 	void completeUsingItem();
-	
-	void setLastMoveTicks(int lastMoveTicks) { this->lastMoveTicks = lastMoveTicks; }
-	int getLastMoveTicks() { return lastMoveTicks; }
-
-	void setTicksInAir(int ticksInAir) { this->ticksInAir = ticksInAir; }
-	int getTicksInAir() { return ticksInAir; }
-
-	void setNewProto(bool proto) { isNewProto = proto; }
-	bool getProto() { return isNewProto; }
-
-	virtual void causeFallDamage(float distance);
 private:
 	void nextContainerCounter();
 	void setContainerMenu( BaseContainerMenu* menu );
@@ -61,11 +50,6 @@ private:
 	Minecraft* _mc;
     int _prevHealth;
 	int _containerCounter;
-
-	int lastMoveTicks = 0;
-	int ticksInAir = 0;
-
-	bool isNewProto = false;
 };
 
 #endif /*ServerPlayer_H__*/

src/world/entity/Entity.cpp

@@ -871,8 +871,8 @@ bool Entity::load( CompoundTag* tag )
 
     // Add a small padding if standing next to the world edges
     const float padding = bbWidth * 0.5f + 0.001f;
-    xx = Mth::clamp(xx, padding, (float)LevelConstants::LEVEL_WIDTH - padding);
+    xx = Mth::clamp(xx, padding, (float)LEVEL_WIDTH - padding);
-    zz = Mth::clamp(zz, padding, (float)LevelConstants::LEVEL_DEPTH - padding);
+    zz = Mth::clamp(zz, padding, (float)LEVEL_DEPTH - padding);
 
     xo = xOld = x = xx;
     yo = yOld = y = yy;

src/world/entity/Entity.h

@@ -129,7 +129,6 @@ public:
 	virtual bool isHangingEntity();
 
 	virtual int getAuxData();
-	virtual void checkFallDamage(float ya, bool onGround);
 
 protected:
 	virtual void setRot(float yRot, float xRot);
@@ -138,6 +137,7 @@ protected:
 	virtual void resetPos(bool clearMore);
 	virtual void outOfWorld();
 
+	virtual void checkFallDamage(float ya, bool onGround);
 	virtual void causeFallDamage(float fallDamage2);
 	virtual void markHurt();
 

src/world/entity/Mob.cpp

@@ -729,6 +729,7 @@ bool Mob::isWaterMob()
 void Mob::aiStep()
 {
 	//@todo? 30 lines of code here in java version
+
 	TIMER_PUSH("ai");
 	if (isImmobile()) {
 		jumping = false;

src/world/entity/Mob.h

@@ -223,9 +223,6 @@ protected:
 	double xc, yc, zc;
 
 public:
-	void setxxa(float xxa) { this->xxa = xxa; }
-	void setyya(float yya) { this->yya = yya; }
-
 	// Cape position accessors (for renderers)
 	double getCapeX() const { return xCape; }
 	double getCapeY() const { return yCape; }

src/world/entity/player/Inventory.cpp

@@ -357,12 +357,3 @@ bool Inventory::removeItem( const ItemInstance* samePtr ) {
 	}
 	return false;
 }
-
-void Inventory::print() {
-	LOGI("%s's Inventory:\n", player->name.c_str());
-
-	for (int i = 0; i < numTotalSlots; i++) {
-		auto item = getItem(i);
-		if (item) LOGI("\t %i: %s (%i) %s\n", i, item->getName().c_str(), item->count, (player->inventory->getLinked(i))? "(Linked)" : "");
-	}
-}

src/world/entity/player/Inventory.h

@@ -45,8 +45,6 @@ public:
 	int				getAttackDamage(Entity* entity);
 	float			getDestroySpeed(Tile* tile);
 	bool			canDestroy(Tile* tile);
-
-	void print();
 private:
 	void			setupDefault();
 public:

src/world/inventory/FillingContainer.cpp

@@ -141,11 +141,6 @@ bool FillingContainer::add( ItemInstance* item )
 	//	// silently destroy the item when having a full inventory
 	//	item->count = 0;
 	//	return true;
-
-		LOGI("Inventory:\n");
-		for (int i = 0; i < numTotalSlots; i++) {
-			LOGI("\t %i: %s (%i)\n", i, items.at(i)->getName().c_str(), items.at(i)->count);
-		}
 	}
 
 	return false;

src/world/item/ItemInstance.cpp

@@ -290,7 +290,3 @@ bool ItemInstance::isArmorItem( const ItemInstance* instance ) {
 
 	return item->isArmor();
 }
-
-bool ItemInstance::isBlock(const ItemInstance* instance) {
-    return instance->id < 256;
-}

src/world/item/ItemInstance.h

@@ -81,8 +81,6 @@ public:
 
 	static bool isArmorItem(const ItemInstance* instance);
 
-    static bool isBlock(const ItemInstance* instance);
-
     /**
      * Checks if this item is the same item as the other one, disregarding the
      * 'count' value.

src/world/level/Level.cpp

@@ -29,9 +29,6 @@
 #include "../Difficulty.h"
 #include "../../network/packet/ExplodePacket.h"
 
-const int Level::DEPTH = LevelConstants::LEVEL_HEIGHT;
-const int Level::SEA_LEVEL = Level::DEPTH / 2 - 1;
-
 Level::Level(LevelStorage* levelStorage, const std::string& levelName, const LevelSettings& settings, int generatorVersion, Dimension* fixedDimension /* = NULL */)
 :	levelStorage(levelStorage),
 	isClientSide(false),
@@ -281,8 +278,8 @@ void Level::tickTiles() {
 		for (int i = 0; i < pollChunkOffsetsSize; i += 2) {
 			const int xp = xx + pollChunkOffsets[i];
 			const int zp = zz + pollChunkOffsets[i+1];
-			if (xp >= 0 && xp < LevelConstants::CHUNK_CACHE_WIDTH &&
+			if (xp >= 0 && xp < CHUNK_CACHE_WIDTH &&
-				zp >= 0 && zp < LevelConstants::CHUNK_CACHE_WIDTH)
+				zp >= 0 && zp < CHUNK_CACHE_WIDTH)
 				_chunksToPoll.insert(ChunkPos(xp, zp));
 		}
     }
@@ -431,17 +428,17 @@ bool Level::findPath(Path* path, Entity* from, int xBest, int yBest, int zBest,
 /*protected*/
 void Level::setInitialSpawn() {
     isFindingSpawn = true;
-    int xSpawn = LevelConstants::CHUNK_CACHE_WIDTH * LevelConstants::CHUNK_WIDTH / 2; // (Level.MAX_LEVEL_SIZE - 100) * 0;
+    int xSpawn = CHUNK_CACHE_WIDTH * CHUNK_WIDTH / 2; // (Level.MAX_LEVEL_SIZE - 100) * 0;
     int ySpawn = 64;
-    int zSpawn = LevelConstants::CHUNK_CACHE_WIDTH * LevelConstants::CHUNK_DEPTH / 2; // (Level.MAX_LEVEL_SIZE - 100) * 0;
+    int zSpawn = CHUNK_CACHE_WIDTH * CHUNK_DEPTH / 2; // (Level.MAX_LEVEL_SIZE - 100) * 0;
     while (!dimension->isValidSpawn(xSpawn, zSpawn)) {
         xSpawn += random.nextInt(32) - random.nextInt(32);
         zSpawn += random.nextInt(32) - random.nextInt(32);
 
 		if (xSpawn < 4) xSpawn += 32;
-		if (xSpawn >= LevelConstants::LEVEL_WIDTH-4) xSpawn -= 32;
+		if (xSpawn >= LEVEL_WIDTH-4) xSpawn -= 32;
 		if (zSpawn < 4) zSpawn += 32;
-		if (zSpawn >= LevelConstants::LEVEL_DEPTH-4) zSpawn -= 32;
+		if (zSpawn >= LEVEL_DEPTH-4) zSpawn -= 32;
     }
     levelData.setSpawn(xSpawn, ySpawn, zSpawn);
     isFindingSpawn = false;
@@ -459,9 +456,9 @@ void Level::validateSpawn() {
         zSpawn += random.nextInt(8) - random.nextInt(8);
 
 		if (xSpawn < 4) xSpawn += 8;
-		if (xSpawn >= LevelConstants::LEVEL_WIDTH-4) xSpawn -= 8;
+		if (xSpawn >= LEVEL_WIDTH-4) xSpawn -= 8;
 		if (zSpawn < 4) zSpawn += 8;
-		if (zSpawn >= LevelConstants::LEVEL_DEPTH-4) zSpawn -= 8;
+		if (zSpawn >= LEVEL_DEPTH-4) zSpawn -= 8;
     }
     levelData.setXSpawn(xSpawn);
     levelData.setZSpawn(zSpawn);
@@ -947,7 +944,7 @@ HitResult Level::clip(const Vec3& A, const Vec3& b, bool liquid /*= false*/, boo
 		if (solidOnly && tile != NULL && tile->getAABB(this, xTile0, yTile0, zTile0) == NULL) {
 			// No collision
 		} else if (t > 0 && tile->mayPick(data, liquid)) {
-			if(xTile0 >= 0 && zTile0 >= 0 && xTile0 < LevelConstants::LEVEL_WIDTH && zTile0 < LevelConstants::LEVEL_WIDTH) {
+			if(xTile0 >= 0 && zTile0 >= 0 && xTile0 < LEVEL_WIDTH && zTile0 < LEVEL_WIDTH) {
 				HitResult r = tile->clip(this, xTile0, yTile0, zTile0, a, b);
 				if (r.isHit()) return r;
 			}
@@ -2225,9 +2222,9 @@ void Level::setNightMode( bool isNightMode ) {
 }
 
 bool Level::inRange( int x, int y, int z ) {
-	return x >= 0 && x < LevelConstants::LEVEL_WIDTH
+	return x >= 0 && x < LEVEL_WIDTH
-		&& y >= 0 && y < LevelConstants::LEVEL_HEIGHT
+		&& y >= 0 && y < LEVEL_HEIGHT
-		&& z >= 0 && z < LevelConstants::LEVEL_DEPTH;
+		&& z >= 0 && z < LEVEL_DEPTH;
 }
 
 //

src/world/level/Level.h

@@ -67,8 +67,8 @@ class Level: public LevelSource
 
 public:
     static const int MAX_LEVEL_SIZE = 32000000;
-    static const int DEPTH;
+    static const short DEPTH = LEVEL_HEIGHT;
-    static const int SEA_LEVEL;
+    static const short SEA_LEVEL = DEPTH / 2 - 1;
 
     static const int MAX_BRIGHTNESS = 15;
     static const int TICKS_PER_DAY = SharedConstants::TicksPerSecond * 60 * 16;// SharedConstants::TicksPerSecond * 60 * 12; // ORG:20*60*20
@@ -307,9 +307,6 @@ public:
 	Dimension* dimension;
 	IRakNetInstance* raknetInstance;
 	Random random;
-
-	std::set<std::string> ops;
-	std::set<std::string> bannedPpl;
 protected:
 	bool isFindingSpawn;
 

src/world/level/LevelConstants.cpp

@@ -1,10 +0,0 @@
-#include "LevelConstants.h"
-
-int LevelConstants::LEVEL_HEIGHT = 128;
-int LevelConstants::CHUNK_CACHE_WIDTH = 16; // in chunks
-int LevelConstants::CHUNK_WIDTH = 16; // in blocks
-int LevelConstants::CHUNK_DEPTH = 16;
-int LevelConstants::LEVEL_WIDTH = LevelConstants::CHUNK_CACHE_WIDTH * CHUNK_WIDTH;
-int LevelConstants::LEVEL_DEPTH = LevelConstants::CHUNK_CACHE_WIDTH * CHUNK_DEPTH;
-int LevelConstants::CHUNK_COLUMNS = LevelConstants::CHUNK_WIDTH * LevelConstants::CHUNK_DEPTH;
-int LevelConstants::CHUNK_BLOCK_COUNT = LevelConstants::CHUNK_COLUMNS * LevelConstants::LEVEL_HEIGHT;

src/world/level/LevelConstants.h

@@ -1,14 +1,14 @@
-#pragma once
+#ifndef _MINECRAFT_WORLD_LEVELCONSTANTS_H_
+#define _MINECRAFT_WORLD_LEVELCONSTANTS_H_
 
-class LevelConstants {
-public:
-    static int CHUNK_CACHE_WIDTH; // in chunks
-    static int LEVEL_WIDTH; 
-    static int LEVEL_DEPTH;
-    static int LEVEL_HEIGHT;
 
-    static int CHUNK_WIDTH; // in blocks
+const int LEVEL_HEIGHT = 128;
-    static int CHUNK_DEPTH;
+const int CHUNK_CACHE_WIDTH = 16; // in chunks
-    static int CHUNK_COLUMNS;
+const int CHUNK_WIDTH = 16; // in blocks
-    static int CHUNK_BLOCK_COUNT;
+const int CHUNK_DEPTH = 16;
-};
+const int LEVEL_WIDTH = CHUNK_CACHE_WIDTH * CHUNK_WIDTH;
+const int LEVEL_DEPTH = CHUNK_CACHE_WIDTH * CHUNK_DEPTH;
+const int CHUNK_COLUMNS = CHUNK_WIDTH * CHUNK_DEPTH;
+const int CHUNK_BLOCK_COUNT = CHUNK_COLUMNS * LEVEL_HEIGHT;
+
+#endif

src/world/level/chunk/ChunkCache.h

@@ -10,7 +10,7 @@
 #include "../LevelConstants.h"
 
 class ChunkCache: public ChunkSource {
-    //static const int LevelConstants::CHUNK_CACHE_WIDTH = LevelConstants::CHUNK_CACHE_WIDTH; // WAS 32;
+    //static const int CHUNK_CACHE_WIDTH = CHUNK_CACHE_WIDTH; // WAS 32;
     static const int MAX_SAVES = 2;
 public:
     ChunkCache(Level* level_, ChunkStorage* storage_, ChunkSource* source_)
@@ -24,17 +24,14 @@ public:
 		isChunkCache = true;
         //emptyChunk = new EmptyLevelChunk(level_, emptyChunkBlocks, 0, 0);
 		emptyChunk = new EmptyLevelChunk(level_, NULL, 0, 0);
-
+		memset(chunks, 0, sizeof(LevelChunk*) * CHUNK_CACHE_WIDTH * CHUNK_CACHE_WIDTH);
-        chunks = new LevelChunk *[LevelConstants::CHUNK_CACHE_WIDTH * LevelConstants::CHUNK_CACHE_WIDTH];
-        memset(chunks, 0, sizeof(LevelChunk*) * LevelConstants::CHUNK_CACHE_WIDTH * LevelConstants::CHUNK_CACHE_WIDTH);
-        LOGI("Chunks allocated.");
     }
 
 	~ChunkCache() {
 		delete source;
 		delete emptyChunk;
 
-		for (int i = 0; i < LevelConstants::CHUNK_CACHE_WIDTH * LevelConstants::CHUNK_CACHE_WIDTH; i++)
+		for (int i = 0; i < CHUNK_CACHE_WIDTH * CHUNK_CACHE_WIDTH; i++)
 		{
 			if (chunks[i])
 			{
@@ -45,7 +42,7 @@ public:
 	}
 
     bool fits(int x, int z) {
-        return (x >= 0 && z >= 0 && x < LevelConstants::CHUNK_CACHE_WIDTH && z < LevelConstants::CHUNK_CACHE_WIDTH);
+        return (x >= 0 && z >= 0 && x < CHUNK_CACHE_WIDTH && z < CHUNK_CACHE_WIDTH);
     }
 
     bool hasChunk(int x, int z) {
@@ -55,9 +52,9 @@ public:
         if (x == xLast && z == zLast && last != NULL) {
             return true;
         }
-        int xs = x & (LevelConstants::CHUNK_CACHE_WIDTH - 1);
+        int xs = x & (CHUNK_CACHE_WIDTH - 1);
-        int zs = z & (LevelConstants::CHUNK_CACHE_WIDTH - 1);
+        int zs = z & (CHUNK_CACHE_WIDTH - 1);
-        int slot = xs + zs * LevelConstants::CHUNK_CACHE_WIDTH;
+        int slot = xs + zs * CHUNK_CACHE_WIDTH;
         return chunks[slot] != NULL && (chunks[slot] == emptyChunk || chunks[slot]->isAt(x, z));
     }
 
@@ -74,9 +71,9 @@ public:
         }
 		if (!fits(x, z)) return emptyChunk;
         //if (!level->isFindingSpawn && !fits(x, z)) return emptyChunk;
-        int xs = x & (LevelConstants::CHUNK_CACHE_WIDTH - 1);
+        int xs = x & (CHUNK_CACHE_WIDTH - 1);
-        int zs = z & (LevelConstants::CHUNK_CACHE_WIDTH - 1);
+        int zs = z & (CHUNK_CACHE_WIDTH - 1);
-        int slot = xs + zs * LevelConstants::CHUNK_CACHE_WIDTH;
+        int slot = xs + zs * CHUNK_CACHE_WIDTH;
         if (!hasChunk(x, z)) {
             if (chunks[slot] != NULL) {
                 chunks[slot]->unload();
@@ -202,8 +199,8 @@ public:
 	void saveAll(bool onlyUnsaved) {
 		if (storage != NULL) {
 			std::vector<LevelChunk*> chunks;
-			for (int z = 0; z < LevelConstants::CHUNK_CACHE_WIDTH; ++z)
+			for (int z = 0; z < CHUNK_CACHE_WIDTH; ++z)
-			for (int x = 0; x < LevelConstants::CHUNK_CACHE_WIDTH; ++x) {
+			for (int x = 0; x < CHUNK_CACHE_WIDTH; ++x) {
 				LevelChunk* chunk = level->getChunk(x, z);
 				if (!onlyUnsaved || chunk->shouldSave(false))
 					chunks.push_back( chunk );
@@ -214,7 +211,7 @@ public:
 private:
     LevelChunk* load(int x, int z) {
         if (storage == NULL) return emptyChunk;
-		if (x < 0 || x >= LevelConstants::CHUNK_CACHE_WIDTH || z < 0 || z >= LevelConstants::CHUNK_CACHE_WIDTH)
+		if (x < 0 || x >= CHUNK_CACHE_WIDTH || z < 0 || z >= CHUNK_CACHE_WIDTH)
 		{
 			return emptyChunk;
 		}
@@ -257,7 +254,7 @@ private:
     LevelChunk* emptyChunk;
     ChunkSource* source;
     ChunkStorage* storage;
-    LevelChunk** chunks;
+    LevelChunk* chunks[CHUNK_CACHE_WIDTH * CHUNK_CACHE_WIDTH];
     Level* level;
 
     LevelChunk* last;

src/world/level/chunk/LevelChunk.cpp

@@ -12,14 +12,13 @@
 
 /*static*/
 bool LevelChunk::touchedSky = false;
-int LevelChunk::ChunkBlockCount;
 
 LevelChunk::LevelChunk( Level* level, int x, int z )
 :	level(level),
 	x(x),
 	z(z),
-	xt(x * LevelConstants::CHUNK_WIDTH),
+	xt(x * CHUNK_WIDTH),
-	zt(z * LevelConstants::CHUNK_DEPTH)
+	zt(z * CHUNK_DEPTH)
 {
 	init();
 }
@@ -28,8 +27,8 @@ LevelChunk::LevelChunk( Level* level, unsigned char* blocks, int x, int z )
 :	level(level),
 	x(x),
 	z(z),
-	xt(x * LevelConstants::CHUNK_WIDTH),
+	xt(x * CHUNK_WIDTH),
-	zt(z * LevelConstants::CHUNK_DEPTH),
+	zt(z * CHUNK_DEPTH),
 	blocks(blocks),
 	data(ChunkBlockCount),
 	skyLight(ChunkBlockCount),
@@ -46,9 +45,6 @@ LevelChunk::~LevelChunk()
 
 void LevelChunk::init()
 {
-	heightmap = new char[LevelConstants::CHUNK_COLUMNS];
-	updateMap = new unsigned char[LevelConstants::CHUNK_COLUMNS];
-	
 	terrainPopulated = false;
 	dontSave = false;
 	unsaved = false;

src/world/level/chunk/LevelChunk.h

@@ -106,9 +106,9 @@ private:
 	void recalcHeight(int x, int yStart, int z);
 public:
     static bool touchedSky;
-	static int ChunkBlockCount;
+	static const int ChunkBlockCount = CHUNK_BLOCK_COUNT;
-	const int ChunkSize = ChunkBlockCount;
+	static const int ChunkSize = ChunkBlockCount;
-	static const int UpdateMapBitShift = 4; // power of (LevelConstants::LEVEL_HEIGHT / 8) == 16
+	static const int UpdateMapBitShift = 4; // power of (LEVEL_HEIGHT / 8) == 16
 
 	int blocksLength; // ? needed or not? (i.e. are all chunks the same size?)
 
@@ -118,12 +118,12 @@ public:
     DataLayer skyLight;
     DataLayer blockLight;
 
-	char* heightmap; // [LevelConstants::CHUNK_COLUMNS]
+	char heightmap[CHUNK_COLUMNS];
-	unsigned char* updateMap; // marks regions within block columns that have been modified [LevelConstants::CHUNK_COLUMNS]
+	unsigned char updateMap[CHUNK_COLUMNS]; // marks regions within block columns that have been modified
 	int minHeight;
 
-	int x, z;
+	const int x, z;
-	int xt, zt;
+	const int xt, zt;
 
     bool terrainPopulated;
     bool unsaved;

src/world/level/levelgen/RandomLevelSource.cpp

@@ -64,7 +64,7 @@ RandomLevelSource::~RandomLevelSource() {
 /*public*/
 void RandomLevelSource::prepareHeights(int xOffs, int zOffs, unsigned char* blocks, /*Biome*/void* biomes, float* temperatures) {
 	
-	int xChunks = 16 / LevelConstants::CHUNK_WIDTH;
+	int xChunks = 16 / CHUNK_WIDTH;
     int waterHeight = Level::DEPTH - 64;
 
     int xSize = xChunks + 1;
@@ -87,23 +87,23 @@ void RandomLevelSource::prepareHeights(int xOffs, int zOffs, unsigned char* bloc
                 float s3a = (buffer[((xc + 1) * zSize + (zc + 1)) * ySize + (yc + 1)] - s3) * yStep;
 
                 for (int y = 0; y < CHUNK_HEIGHT; y++) {
-                    float xStep = 1 / (float) LevelConstants::CHUNK_WIDTH;
+                    float xStep = 1 / (float) CHUNK_WIDTH;
 
                     float _s0 = s0;
                     float _s1 = s1;
                     float _s0a = (s2 - s0) * xStep;
                     float _s1a = (s3 - s1) * xStep;
 
-                    for (int x = 0; x < LevelConstants::CHUNK_WIDTH; x++) {
+                    for (int x = 0; x < CHUNK_WIDTH; x++) {
-                        int offs = (x + xc * LevelConstants::CHUNK_WIDTH) << 11 | (0 + zc * LevelConstants::CHUNK_WIDTH) << 7 | (yc * CHUNK_HEIGHT + y);
+                        int offs = (x + xc * CHUNK_WIDTH) << 11 | (0 + zc * CHUNK_WIDTH) << 7 | (yc * CHUNK_HEIGHT + y);
                         int step = 1 << 7;
-                        float zStep = 1 / (float) LevelConstants::CHUNK_WIDTH;
+                        float zStep = 1 / (float) CHUNK_WIDTH;
 
                         float val = _s0;
                         float vala = (_s1 - _s0) * zStep;
-                        for (int z = 0; z < LevelConstants::CHUNK_WIDTH; z++) {
+                        for (int z = 0; z < CHUNK_WIDTH; z++) {
-// + (zc * LevelConstants::CHUNK_WIDTH + z)];
+// + (zc * CHUNK_WIDTH + z)];
-                            float temp = temperatures[(xc * LevelConstants::CHUNK_WIDTH + x) * 16 + (zc * LevelConstants::CHUNK_WIDTH + z)];
+                            float temp = temperatures[(xc * CHUNK_WIDTH + x) * 16 + (zc * CHUNK_WIDTH + z)];
                             int tileId = 0;
                             if (yc * CHUNK_HEIGHT + y < waterHeight) {
                                 if (temp < SNOW_CUTOFF && yc * CHUNK_HEIGHT + y >= waterHeight - 1) {

src/world/level/storage/ExternalFileLevelStorage.cpp

@@ -1,6 +1,3 @@
-#include <cstddef>
-#include <fstream>
-#include <ios>
 #if !defined(DEMO_MODE) && !defined(APPLE_DEMO_PROMOTION)
 
 #include "LevelData.h"
@@ -91,9 +88,6 @@ ExternalFileLevelStorage::ExternalFileLevelStorage(const std::string& levelId, c
 {
 	createFolderIfNotExists(levelPath.c_str());
 
-	std::string playerFolder = levelPath + "/players";
-	createFolderIfNotExists(playerFolder.c_str());
-
 	std::string datFileName   = levelPath + "/" + fnLevelDat;
 	std::string levelFileName = levelPath + "/" + fnPlayerDat;
 	loadedLevelData = new LevelData();
@@ -119,7 +113,6 @@ void ExternalFileLevelStorage::saveLevelData(LevelData& levelData, std::vector<P
 
 void ExternalFileLevelStorage::saveLevelData( const std::string& levelPath, LevelData& levelData, std::vector<Player*>* players )
 {
-	// @todo: completely rewrite
 	std::string directory = levelPath + "/";
     std::string tmpFile = directory + fnLevelDatNew;
     std::string datFile = directory + fnLevelDat;
@@ -148,67 +141,6 @@ void ExternalFileLevelStorage::saveLevelData( const std::string& levelPath, Leve
 
     // Remove the temporary save, if the rename didn't do it
     remove(tmpFile.c_str());
-
-	// Save players
-	// fuck mojang for that
-	if (!players || players->empty()) {
-		return;
-	}
-
-	for (auto& player : *players) {
-		if (player != NULL) {
-			savePlayer(*player, directory);
-		}
-	}
-}
-
-void ExternalFileLevelStorage::savePlayer(Player& player, const std::string& worldDir) {
-	std::string playerPath = worldDir + "/players/" + player.name + ".dat";
-
-	LOGI("Saving player %s to %s...\n", player.name.c_str(), playerPath.c_str());
-
-	RakNet::BitStream data;
-	RakDataOutput buf(data);
-	CompoundTag playerTag;
-	player.saveWithoutId(&playerTag);
-
-	NbtIo::write(&playerTag, &buf);
-
-	std::ofstream file(playerPath, std::ios::out | std::ios::binary);
-	file.write((const char*)data.GetData(), (size_t)data.GetNumberOfBytesUsed());
-}
-
-bool ExternalFileLevelStorage::loadPlayer(Player& player, const std::string& worldDir) {
-	std::string playerPath = worldDir + "/players/" + player.name + ".dat";
-
-	LOGI("Loading player %s from %s...\n", player.name.c_str(), playerPath.c_str());
-
-	std::ifstream file(playerPath, std::ios::in | std::ios::binary);
-	if (!file.is_open()) {
-		return false;
-	}
-
-	std::vector<uint8_t> data((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
-
-	RakNet::BitStream bitStream(data.data(), data.size(), false);
-	RakDataInput stream(bitStream);
-
-	CompoundTag* tag = NbtIo::read(&stream);
-	if (tag) {
-		player.load(tag);
-		tag->deleteChildren();
-		delete tag;
-	}
-
-	return true;
-}
-
-void ExternalFileLevelStorage::savePlayer(Player& player) {
-	ExternalFileLevelStorage::savePlayer(player, levelPath);
-}
-
-bool ExternalFileLevelStorage::loadPlayer(Player& player) {
-	return ExternalFileLevelStorage::loadPlayer(player, levelPath);
 }
 
 LevelData* ExternalFileLevelStorage::prepareLevel(Level* _level)
@@ -343,8 +275,8 @@ bool ExternalFileLevelStorage::readPlayerData(const std::string& filename, Level
 			Vec3& pos = dest.playerData.pos;
 			if (pos.x < 0.5f) pos.x = 0.5f;
 			if (pos.z < 0.5f) pos.z = 0.5f;
-			if (pos.x > (LevelConstants::LEVEL_WIDTH - 0.5f)) pos.x = LevelConstants::LEVEL_WIDTH - 0.5f;
+			if (pos.x > (LEVEL_WIDTH - 0.5f)) pos.x = LEVEL_WIDTH - 0.5f;
-			if (pos.z > (LevelConstants::LEVEL_DEPTH - 0.5f)) pos.z = LevelConstants::LEVEL_DEPTH - 0.5f;
+			if (pos.z > (LEVEL_DEPTH - 0.5f)) pos.z = LEVEL_DEPTH - 0.5f;
 			if (pos.y < 0) pos.y = 64;
 
 			dest.playerDataVersion = version;
@@ -362,14 +294,14 @@ void ExternalFileLevelStorage::tick()
 		LOGI("Saving level...\n");
 
 		// look for chunks that needs to be saved
-		for (int z = 0; z < LevelConstants::CHUNK_CACHE_WIDTH; z++)
+		for (int z = 0; z < CHUNK_CACHE_WIDTH; z++)
 		{
-			for (int x = 0; x < LevelConstants::CHUNK_CACHE_WIDTH; x++)
+			for (int x = 0; x < CHUNK_CACHE_WIDTH; x++)
 			{
 				LevelChunk* chunk = level->getChunk(x, z);
 				if (chunk && chunk->unsaved)
 				{
-					int pos = x + z * LevelConstants::CHUNK_CACHE_WIDTH;
+					int pos = x + z * CHUNK_CACHE_WIDTH;
 					UnsavedChunkList::iterator prev = unsavedChunkList.begin();
 					for ( ; prev != unsavedChunkList.end(); ++prev)
 					{
@@ -415,13 +347,13 @@ void ExternalFileLevelStorage::save(Level* level, LevelChunk* levelChunk)
 
 	// Write chunk
 	RakNet::BitStream chunkData;
-	chunkData.Write((const char*)levelChunk->getBlockData(), LevelConstants::CHUNK_BLOCK_COUNT);
+	chunkData.Write((const char*)levelChunk->getBlockData(), CHUNK_BLOCK_COUNT);
-	chunkData.Write((const char*)levelChunk->data.data, LevelConstants::CHUNK_BLOCK_COUNT / 2);
+	chunkData.Write((const char*)levelChunk->data.data, CHUNK_BLOCK_COUNT / 2);
 
-	chunkData.Write((const char*)levelChunk->skyLight.data, LevelConstants::CHUNK_BLOCK_COUNT / 2);
+	chunkData.Write((const char*)levelChunk->skyLight.data, CHUNK_BLOCK_COUNT / 2);
-	chunkData.Write((const char*)levelChunk->blockLight.data, LevelConstants::CHUNK_BLOCK_COUNT / 2);
+	chunkData.Write((const char*)levelChunk->blockLight.data, CHUNK_BLOCK_COUNT / 2);
 
-	chunkData.Write((const char*)levelChunk->updateMap, LevelConstants::CHUNK_COLUMNS);
+	chunkData.Write((const char*)levelChunk->updateMap, CHUNK_COLUMNS);
 
 	regionFile->writeChunk(levelChunk->x, levelChunk->z, chunkData);
 
@@ -453,16 +385,16 @@ LevelChunk* ExternalFileLevelStorage::load(Level* level, int x, int z)
 
 	chunkData->ResetReadPointer();
 
-	unsigned char* blockIds = new unsigned char[LevelConstants::CHUNK_BLOCK_COUNT];
+	unsigned char* blockIds = new unsigned char[CHUNK_BLOCK_COUNT];
-	chunkData->Read((char*)blockIds, LevelConstants::CHUNK_BLOCK_COUNT);
+	chunkData->Read((char*)blockIds, CHUNK_BLOCK_COUNT);
 
 	LevelChunk* levelChunk = new LevelChunk(level, blockIds, x, z);
-	chunkData->Read((char*)levelChunk->data.data, LevelConstants::CHUNK_BLOCK_COUNT / 2);
+	chunkData->Read((char*)levelChunk->data.data, CHUNK_BLOCK_COUNT / 2);
 	if (loadedStorageVersion >= ChunkVersion_Light) {
-		chunkData->Read((char*)levelChunk->skyLight.data, LevelConstants::CHUNK_BLOCK_COUNT / 2);
+		chunkData->Read((char*)levelChunk->skyLight.data, CHUNK_BLOCK_COUNT / 2);
-		chunkData->Read((char*)levelChunk->blockLight.data, LevelConstants::CHUNK_BLOCK_COUNT / 2);
+		chunkData->Read((char*)levelChunk->blockLight.data, CHUNK_BLOCK_COUNT / 2);
 	}
-	chunkData->Read((char*)levelChunk->updateMap, LevelConstants::CHUNK_COLUMNS);
+	chunkData->Read((char*)levelChunk->updateMap, CHUNK_COLUMNS);
 	// This will be difficult to maintain.. Storage version could be per chunk
 	// too (but probably better to just read all -> write all, so that all
 	// chunks got same version anyway)
@@ -485,7 +417,7 @@ LevelChunk* ExternalFileLevelStorage::load(Level* level, int x, int z)
 	//bool dbg = (x == 7 && z == 9);
 
 	//int t = 0;
-	//for (int i = 0; i < LevelConstants::CHUNK_COLUMNS; ++i) {
+	//for (int i = 0; i < CHUNK_COLUMNS; ++i) {
 	//	char bits = levelChunk->updateMap[i];
 	//	t += (bits != 0);
 	//	int xx = x * 16 + i%16;

src/world/level/storage/ExternalFileLevelStorage.h

@@ -67,19 +67,6 @@ public:
 	void saveGame(Level* level);
     void saveAll(Level* level, std::vector<LevelChunk*>& levelChunks);
 
-	/**
-	 * @brief Save player to <world name>/player/<player name>.dat file
-	 */
-	static void savePlayer(Player& player, const std::string& worldDir);
-
-	/**
-	 * @brief Load player from <world name>/player/<player name>.dat file
-	 */
-	static bool loadPlayer(Player& player, const std::string& worldDir);
-
-	virtual void savePlayer(Player& player);
-	virtual bool loadPlayer(Player& player);
-
 	virtual void tick();
 	virtual void flush() {}
 private:

src/world/level/storage/LevelStorage.h

@@ -32,9 +32,6 @@ public:
 	virtual void saveGame(Level* level) {}
 	virtual void loadEntities(Level* level, LevelChunk* levelChunk) {}
 
-	virtual void savePlayer(Player& player) = 0;
-	virtual bool loadPlayer(Player& player) = 0;
-
 	//void checkSession() throws LevelConflictException;
 	//PlayerIO getPlayerIO();
 };

src/world/level/tile/Mushroom.cpp

@@ -47,7 +47,7 @@ bool Mushroom::mayPlaceOn( int tile ) {
 }
 
 bool Mushroom::canSurvive( Level* level, int x, int y, int z ) {
-	if (y < 0 || y >= LevelConstants::LEVEL_HEIGHT/*Level::maxBuildHeight*/)
+	if (y < 0 || y >= LEVEL_HEIGHT/*Level::maxBuildHeight*/)
         return false;
 
 	int below = level->getTile(x, y - 1, z);

src/world/level/tile/NetherReactor.cpp

@@ -53,7 +53,7 @@ bool NetherReactor::canSpawnStartNetherReactor( Level* level, int x, int y, int
 	if(!allPlayersCloseToReactor(level, x, y, z)) {
 		player->displayClientMessage("All players need to be close to the reactor.");
 		return false;
-	} else if(y > LevelConstants::LEVEL_HEIGHT - 28) {
+	} else if(y > LEVEL_HEIGHT - 28) {
 		player->displayClientMessage("The nether reactor needs to be built lower down.");
 		return false;
 	} else if(y < 2) {

src/world/level/tile/Tile.cpp

@@ -22,7 +22,6 @@
 #include "../../item/StoneSlabTileItem.h"
 #include "../../item/SaplingTileItem.h"
 #include "../../item/ItemCategory.h"
-#include "world/level/LevelConstants.h"
 
 const int Tile::RENDERLAYER_OPAQUE          = 0;
 const int Tile::RENDERLAYER_ALPHATEST       = 1;
@@ -513,15 +512,10 @@ bool Tile::shouldRenderFace( LevelSource* level, int x, int y, int z, int face )
 {
 	if (face == 0 && y == -1) return false;
 	// For fixed size worlds //@todo: external constants rather than magic numbers
-	// @fixme @ahtung temp fix
-
-	auto xz = LevelConstants::CHUNK_CACHE_WIDTH == 16 ? 256 : 
-	LevelConstants::CHUNK_CACHE_WIDTH * LevelConstants::CHUNK_CACHE_WIDTH / (LevelConstants::CHUNK_CACHE_WIDTH * LevelConstants::CHUNK_CACHE_WIDTH / 256 / 2);
-
 	if (face == 2 && z == -1)  return false;
-	if (face == 3 && z == xz) return false;
+	if (face == 3 && z == 256) return false;
 	if (face == 4 && x == -1)  return false;
-	if (face == 5 && x == xz) return false;
+	if (face == 5 && x == 256) return false;
 	// Common
 	if (face == 0 && yy0 > 0) return true;
 	if (face == 1 && yy1 < 1) return true;

src/world/level/tile/entity/NetherReactorTileEntity.cpp

@@ -130,7 +130,7 @@ Vec3 NetherReactorTileEntity::getSpawnPosition( float minDistance, float varible
 void NetherReactorTileEntity::spawnEnemy() {
 	Mob* mob = MobFactory::CreateMob(MobTypes::PigZombie, level);
 	Vec3 enemyPosition = getSpawnPosition(3, 4, -1);
-	while(enemyPosition.x < 0 || enemyPosition.z < 0 || enemyPosition.x >= LevelConstants::LEVEL_WIDTH || enemyPosition.z >= LevelConstants::LEVEL_DEPTH) {
+	while(enemyPosition.x < 0 || enemyPosition.z < 0 || enemyPosition.x >= LEVEL_WIDTH || enemyPosition.z >= LEVEL_DEPTH) {
 		enemyPosition = getSpawnPosition(3, 4, -1);
 	}
 	MobSpawner::addMob(level, mob, enemyPosition.x, enemyPosition.y, enemyPosition.z, 0, 0, true);
@@ -140,7 +140,7 @@ void NetherReactorTileEntity::spawnEnemy() {
 
 void NetherReactorTileEntity::spawnItem() {
 	Vec3 itemPosition= getSpawnPosition(3, 4, -1);
-	while(itemPosition.x < 0 || itemPosition.z < 0 || itemPosition.x >= LevelConstants::LEVEL_WIDTH || itemPosition.z >= LevelConstants::LEVEL_DEPTH) {
+	while(itemPosition.x < 0 || itemPosition.z < 0 || itemPosition.x >= LEVEL_WIDTH || itemPosition.z >= LEVEL_DEPTH) {
 		itemPosition = getSpawnPosition(3, 4, -1);
 	}
 	ItemEntity* item = new ItemEntity(level, itemPosition.x, itemPosition.y, itemPosition.z, getSpawnItem());