server compilable

CMakeLists.txt

@@ -39,6 +39,8 @@ if (${PLATFORM} STREQUAL "Desktop")
         set(EXTRA_LIBS pthread m)
     endif()
 
+    include_directories("glad/include")
+
 elseif (${PLATFORM} STREQUAL "Web")
     set(PLATFORM_CPP "PLATFORM_WEB")
     set(EXTRA_LIBS "idbfs.js")
@@ -111,36 +113,41 @@ CPMAddPackage(
         "ALSOFT_STATIC_LIBGCC ON"
 )
 
+# TODO: Clear this paths with *
 file(GLOB SERVER_SOURCES
     "project/lib_projects/raknet/jni/RaknetSources/*.cpp"
-    "src/NinecraftApp.cpp"
     "src/Performance.cpp"
     "src/SharedConstants.cpp"
+    "src/Minecraft.cpp"
+    "src/MinecraftServer.cpp"
+    "src/App.cpp"
+    "src/IPlatform.cpp"
 
-    "src/client/IConfigListener.cpp"
-    "src/client/Minecraft.cpp"
-    "src/client/OptionStrings.cpp"
-    "src/client/Option.cpp"
-    "src/client/Options.cpp"
-    "src/client/OptionsFile.cpp"
-    "src/client/ServerProfiler.cpp"
 
-    "src/client/gamemode/CreativeMode.cpp"
+    # "src/client/IConfigListener.cpp"
-    "src/client/gamemode/GameMode.cpp"
+    # "src/client/Minecraft.cpp"
-    "src/client/gamemode/SurvivalMode.cpp"
+    # "src/client/OptionStrings.cpp"
+    # "src/client/Option.cpp"
+    # "src/client/Options.cpp"
+    # "src/client/OptionsFile.cpp"
+    # "src/client/ServerProfiler.cpp"
 
-    "src/client/player/LocalPlayer.cpp"
+    # "src/client/gamemode/CreativeMode.cpp"
-    "src/client/player/RemotePlayer.cpp"
+    # "src/client/gamemode/GameMode.cpp"
-    "src/client/player/input/KeyboardInput.cpp"
+    # "src/client/gamemode/SurvivalMode.cpp"
+
+    # "src/client/player/LocalPlayer.cpp"
+    # "src/client/player/RemotePlayer.cpp"
+    # "src/client/player/input/KeyboardInput.cpp"
+
+    "src/gamemode/*.cpp"
 
     "src/locale/I18n.cpp"
 
-    "src/main.cpp"
     "src/main_dedicated.cpp"
 
     "src/nbt/Tag.cpp"
 
-    "src/network/ClientSideNetworkHandler.cpp"
     "src/network/NetEventCallback.cpp"
     "src/network/Packet.cpp"
     "src/network/RakNetInstance.cpp"
@@ -151,11 +158,7 @@ file(GLOB SERVER_SOURCES
     "src/platform/HttpClient.cpp"
     "src/platform/PngLoader.cpp"
     "src/platform/time.cpp"
-
+    "src/platform/server/PlatformServer.cpp"
-    "src/platform/input/Controller.cpp"
-    "src/platform/input/Keyboard.cpp"
-    "src/platform/input/Mouse.cpp"
-    "src/platform/input/Multitouch.cpp"
 
     "src/server/ArgumentsSettings.cpp"
     "src/server/ServerLevel.cpp"
@@ -211,7 +214,6 @@ file(GLOB SERVER_SOURCES
     "src/world/level/tile/entity/*.cpp"
 
     "src/world/phys/HitResult.cpp"
-    "src/commands/*.cpp"
 ) 
 
 file(GLOB CLIENT_SOURCES 
@@ -293,8 +295,6 @@ file(GLOB CLIENT_SOURCES
 
     "src/AppPlatform_glfw.cpp"
     "src/main.cpp"
-
-    "src/commands/*.cpp"
 )
 
 if (${PLATFORM} STREQUAL "Desktop")
@@ -371,7 +371,7 @@ if(${PLATFORM} MATCHES "Web")
 endif()
 
 # Client
-target_compile_definitions(${PROJECT_NAME} PUBLIC "OPENGL_ES" "NO_EGL" ${PLATFORM})
+target_compile_definitions(${PROJECT_NAME} PUBLIC "OPENGL_ES" "NO_EGL" "${PLATFORM_CPP}")
 target_link_libraries(${PROJECT_NAME} zlib ${PNG_LIB} OpenAL::OpenAL glfw ${EXTRA_LIBS})
 
 if (OpenSSL_FOUND)

src/App.cpp

@@ -0,0 +1,26 @@
+#include "App.h"
+#include "IPlatform.h"
+
+#include "platform/server/PlatformServer.h"
+#include "platform/glfw/PlatformGlfw.h"
+
+std::unique_ptr<IPlatform> App::CreatePlatform() {
+#if defined(STANDALONE_SERVER)
+    return std::make_unique<PlatformServer>();
+#elif defined(PLATFORM_DESKTOP)
+    return std::make_unique<PlatformGlfw>();
+#else 
+    static_assert(false, "Unsupported platform!");
+#endif
+}
+
+void App::run() {
+    init();
+
+    m_platform->runMainLoop(*this);
+}
+
+void App::swapBuffers() {
+    m_platform->swapBuffers();
+}
+

src/App.h

@@ -1,6 +1,6 @@
-#ifndef APP_H__
+#pragma once
-#define APP_H__
 
+#include <memory>
 #ifdef __APPLE__
 #define NO_EGL
 #endif
@@ -8,47 +8,36 @@
 #define NO_EGL
 #endif
 
-#include "AppPlatform.h"
+#include <IPlatform.h>
 #ifndef NO_EGL 
     #include <EGL/egl.h>
 #endif
-#include "platform/log.h"
-
-typedef struct AppContext {
-#ifndef NO_EGL
-	EGLDisplay display;
-	EGLContext context;
-	EGLSurface surface;
-#endif
-	AppPlatform* platform;
-	bool doRender;
-} AppContext;
 
 
-class App
+// typedef struct AppContext {
-{
+// #ifndef NO_EGL
+// 	EGLDisplay display;
+// 	EGLContext context;
+// 	EGLSurface surface;
+// #endif
+// 	AppPlatform* platform;
+// 	bool doRender;
+// } AppContext;
+
+class App {
+protected:
+	std::unique_ptr<IPlatform> m_platform;
+
 public:
-    App()
+	static std::unique_ptr<IPlatform> CreatePlatform();
-	:	_finished(false),
+
-		_inited(false)
+    App(std::unique_ptr<IPlatform> platform) : m_platform(std::move(platform)), m_finished(false), m_inited(false) {}
-	{
+	App() = delete;
-		_context.platform = 0;
-	}
 	virtual ~App() {}
 
-	void init(AppContext& c) {
+	void run();
-        _context = c;
-		init();
-		_inited = true;
-    }
-	bool isInited() { return _inited; }
 
-	virtual AppPlatform* platform() { return _context.platform; }
+	bool isInited() { return m_inited; }
-
-	void onGraphicsReset(AppContext& c) {
-		_context = c;
-		onGraphicsReset();
-	}
 
     virtual void audioEngineOn () {}
     virtual void audioEngineOff() {}
@@ -58,30 +47,25 @@ public:
     virtual void loadState(void* state, int stateSize) {}
     virtual bool saveState(void** state, int* stateSize) { return false; }
     
-	void swapBuffers() {
+	void swapBuffers();
-#ifndef NO_EGL
+// 	{
-		if (_context.doRender)
+// #ifndef NO_EGL
-			eglSwapBuffers(_context.display, _context.surface);
+// 		if (_context.doRender)
-#endif
+// 			eglSwapBuffers(_context.display, _context.surface);
-	}
+// #endif
+// 		m_platform->swapBuffers();
+// 	}
 
-	virtual void draw() {}
+	virtual void update() = 0;
-	virtual void update() {};// = 0;
-	virtual void setSize(int width, int height) {}
 	
-	virtual void quit() { _finished = true; }
+	virtual void quit() { m_finished = true; }
-	virtual bool wantToQuit() { return _finished; }
+	virtual bool wantToQuit() { return m_finished; }
 	virtual bool handleBack(bool isDown) { return false; }
 
 protected:
-	virtual void init() {}
+	virtual void init() { m_inited = true;}
-	//virtual void onGraphicsLost() = 0;
-	virtual void onGraphicsReset() = 0;
 
 private:
-	bool _inited;
+	bool m_inited = false;
-	bool _finished;
+	bool m_finished = false;
-    AppContext _context;
+};
-};
-
-#endif//APP_H__

src/AppConstants.h

@@ -1,10 +0,0 @@
-#ifndef _MINECRAFT_APPCONSTANTS_H_
-#define _MINECRAFT_APPCONSTANTS_H_
-
-
-#define APP_VERSION_STRING "Demo"
-#define APP_NAME "Minecraft - Pocket Edition " APP_VERSION_STRING
-
-
-
-#endif

src/AppPlatform.h

@@ -1,143 +0,0 @@
-#ifndef APPPLATFORM_H__
-#define APPPLATFORM_H__
-
-#include <vector>
-#include <string>
-#include <cstring>
-#include "client/renderer/TextureData.h"
-
-typedef std::vector<std::string> StringVector;
-
-/*
-typedef struct UserInput
-{
-    static const int STATUS_INVALID = -1;
-    static const int STATUS_NOTINITED = -2;
-    static const int STATUS_OK = 1;
-    static const int STATUS_CANCEL = 0;
-
-    UserInput(int id)
-    :   _id(id),
-        status(STATUS_NOTINITED)
-    {}
-    UserInput(int id, int status)
-    :   _id(id),
-        status(status)
-    {}
-    int getId() { return _id; }
-
-    int status;
-private:
-    int _id;
-} UserInput;
-
-
-class UserInputStatus {
-	int _status;
-public:
-	UserInputStatus(int status)
-	:	_status(status)
-	{}
-	bool isAnswered() { return _status >= 0; }
-	bool isOk() { return _status == UserInput::STATUS_OK; }
-	bool isCancel() { return _status == UserInput::STATUS_CANCEL; }
-};
-*/
-
-class BinaryBlob {
-public:
-	BinaryBlob()
-	:	data(NULL),
-		size(-1) {}
-
-	BinaryBlob(unsigned char* data, unsigned int size)
-	:	data(data),
-		size(size) {}
-
-	unsigned char* data;
-	int size;
-};
-
-class PlatformStringVars {
-public:
-	static const int DEVICE_BUILD_MODEL = 0;
-};
-
-class AppPlatform
-{
-public:
-	AppPlatform() : keyboardVisible(false) {}
-    virtual ~AppPlatform() {}
-
-	virtual void saveScreenshot(const std::string& filename, int glWidth, int glHeight) {}
-	virtual TextureData loadTexture(const std::string& filename_, bool textureFolder) { return TextureData(); }
-	virtual TextureData loadTextureFromMemory(const unsigned char* data, size_t size) { return TextureData(); }
-
-    virtual void playSound(const std::string& fn, float volume, float pitch) {}
-	
-	virtual void hideCursor(bool hide) {}
-
-	virtual void showDialog(int dialogId) {}
-    virtual void createUserInput() {}
-	
-	bool is_big_endian(void)  {
-		union {
-			unsigned int i;
-			char c[4];
-		} bint = {0x01020304};
-		return bint.c[0] == 1;
-	} 
-
-	void createUserInput(int dialogId)
-	{
-		showDialog(dialogId);
-		createUserInput();
-	}
-	virtual int getUserInputStatus() { return 0; }
-	virtual StringVector getUserInput() { return StringVector(); }
-
-	virtual std::string getDateString(int s) { return ""; }
-	//virtual void createUserInputScreen(const char* types) {}
-
-	virtual void uploadPlatformDependentData(int id, void* data) {}
-	virtual BinaryBlob readAssetFile(const std::string& filename) { return BinaryBlob(); }
-	virtual void _tick() {}
-
-	virtual int getScreenWidth() { return 854; }
-	virtual int getScreenHeight() { return 480; }
-    virtual float getPixelsPerMillimeter() { return 10; }
-
-	virtual bool isNetworkEnabled(bool onlyWifiAllowed) { return true; }
-
-	virtual bool isPowerVR() {
-		return false;
-	}
-	virtual int getKeyFromKeyCode(int keyCode, int metaState, int deviceId) {return 0;}
-#ifdef __APPLE__
-    virtual bool isSuperFast() = 0;
-#endif
-
-	virtual void openURL(const std::string& url) {}
-
-	virtual void finish() {}
-	
-	virtual bool supportsTouchscreen() { return false; }
-	
-	virtual void vibrate(int milliSeconds) {}
-
-	virtual std::string getPlatformStringVar(int stringId) {
-		return "<getPlatformStringVar NotImplemented>";
-	}
-
-	virtual void showKeyboard() {
-		keyboardVisible = true;
-	}
-	virtual void hideKeyboard() {
-		keyboardVisible = false;
-	}
-	virtual bool isKeyboardVisible() {return keyboardVisible;}
-protected:
-	bool keyboardVisible;
-};
-
-#endif /*APPPLATFORM_H__*/

src/AppPlatform_glfw.cpp

@@ -1,12 +0,0 @@
-#include "AppPlatform_glfw.h"
-
-float AppPlatform_glfw::getPixelsPerMillimeter() {
-    GLFWmonitor* monitor = glfwGetPrimaryMonitor();
-
-    int width_mm, height_mm;
-    glfwGetMonitorPhysicalSize(monitor, &width_mm, &height_mm);
-
-    const GLFWvidmode* mode = glfwGetVideoMode(monitor);
-
-    return (float)mode->width / (float)width_mm;
-}

src/AppPlatform_glfw.h

@@ -1,155 +0,0 @@
-#ifndef APPPLATFORM_GLFW_H__
-#define APPPLATFORM_GLFW_H__
-
-#include "AppPlatform.h"
-#include "platform/log.h"
-#include "platform/HttpClient.h"
-#include "platform/PngLoader.h"
-#include "client/renderer/gles.h"
-#include "world/level/storage/FolderMethods.h"
-#include <png.h>
-#include <cmath>
-#include <fstream>
-#include <sstream>
-#include <GLFW/glfw3.h>
-#include <ctime>
-#include "util/StringUtils.h"
-
-#ifdef _WIN32
-#include <windows.h>
-#include <shellapi.h>
-#endif
-
-#ifdef __EMSCRIPTEN__
-	#include <emscripten/html5.h>
-#endif
-
-static void png_funcReadFile(png_structp pngPtr, png_bytep data, png_size_t length) {
-	((std::istream*)png_get_io_ptr(pngPtr))->read((char*)data, length);
-}
-
-class AppPlatform_glfw: public AppPlatform
-{
-public:
-    AppPlatform_glfw()
-    {
-    }
-
-	BinaryBlob readAssetFile(const std::string& filename) override {
-		FILE* fp = fopen(("data/" + filename).c_str(), "r");
-		if (!fp)
-			return BinaryBlob();
-
-		int size = getRemainingFileSize(fp);
-
-		BinaryBlob blob;
-		blob.size = size;
-		blob.data = new unsigned char[size];
-
-		fread(blob.data, 1, size, fp);
-		fclose(fp);
-
-		return blob;
-	}
-
-    void saveScreenshot(const std::string& filename, int glWidth, int glHeight) override {
-        //@todo
-    }
-
-    __inline unsigned int rgbToBgr(unsigned int p) {
-        return (p & 0xff00ff00) | ((p >> 16) & 0xff) | ((p << 16) & 0xff0000);
-    }
-
-    TextureData loadTexture(const std::string& filename_, bool textureFolder) override
-	{
-		// Support fetching PNG textures via HTTP/HTTPS (for skins, etc)
-		if (Util::startsWith(filename_, "http://") || Util::startsWith(filename_, "https://")) {
-			std::vector<unsigned char> body;
-			if (HttpClient::download(filename_, body) && !body.empty()) {
-				return loadTextureFromMemory(body.data(), body.size());
-			}
-			return TextureData();
-		}
-
-		TextureData out;
-
-		std::string filename = textureFolder? "data/images/" + filename_
-								: filename_;
-		std::ifstream source(filename.c_str(), std::ios::binary);
-
-		if (!source) {
-			LOGI("Couldn't find file: %s\n", filename.c_str());
-			return out;
-		}
-
-		std::vector<unsigned char> fileData((std::istreambuf_iterator<char>(source)), std::istreambuf_iterator<char>());
-		source.close();
-
-		if (fileData.empty()) {
-			LOGI("Couldn't read file: %s\n", filename.c_str());
-			return out;
-		}
-
-		return loadTextureFromMemory(fileData.data(), fileData.size());
-    }
-
-	TextureData loadTextureFromMemory(const unsigned char* data, size_t size) override {
-		return loadPngFromMemory(data, size);
-	}
-
-	virtual std::string getDateString(int s) override {
-		time_t tm = s;
-
-		char mbstr[100];
-		std::strftime(mbstr, sizeof(mbstr), "%F %T", std::localtime(&tm));
-
-		return std::string(mbstr);
-	}
-
-	virtual int getScreenWidth() override { 
-		#ifdef __EMSCRIPTEN__
-			int w, h;
-			emscripten_get_canvas_element_size("canvas", &w, &h);
-
-			return w;
-		#endif
-
-		return 854; 
-	};
-
-	virtual int getScreenHeight() override { 
-		#ifdef __EMSCRIPTEN__
-			int w, h;
-			emscripten_get_canvas_element_size("canvas", &w, &h);
-
-			return h;
-		#endif
-
-		return 480; 
-	};
-
-	virtual float getPixelsPerMillimeter() override;
-
-	virtual bool supportsTouchscreen() override { return false; /* glfw supports only mouse and keyboard */ }
-
-	virtual void hideCursor(bool hide) override {
-		int isHide = hide ? GLFW_CURSOR_NORMAL : GLFW_CURSOR_HIDDEN;
-		glfwSetInputMode(window, GLFW_CURSOR, isHide);
-	}
-
-	virtual void openURL(const std::string& url) override {
-#ifdef _WIN32
-		ShellExecuteA(NULL, "open", url.c_str(), NULL, NULL, SW_SHOWNORMAL);
-#elif __linux__
-		std::string command = "xdg-open " + url;
-		system(command.c_str());
-#elif __EMSCRIPTEN__
-		emscripten_run_script(std::string("window.open('" + url + "', '_blank')").c_str());
-#endif
-	}
-
-	GLFWwindow* window;
-
-private:
-};
-#endif /*APPPLATFORM_GLFW_H__*/

src/ErrorCodes.h

@@ -1,13 +0,0 @@
-#ifndef ERRORCODES_H__
-#define ERRORCODES_H__
-
-namespace ErrorCodes {
-
-enum Enum {
-	Unknown,
-	ContainerRefStillExistsAfterDestruction
-};
-
-}
-
-#endif /*ERRORCODES_H__*/

src/IPlatform.cpp

@@ -0,0 +1,14 @@
+#include <IPlatform.h>
+#include <App.h>
+#include <fstream>
+
+void IPlatform::runMainLoop(App& app) {
+    while(!app.wantToQuit()) app.update();
+}
+
+ByteVector IPlatform::readAssetFile(const std::string& path) {
+    std::ifstream instream(path, std::ios::in | std::ios::binary);
+    std::vector<uint8_t> data((std::istreambuf_iterator<char>(instream)), std::istreambuf_iterator<char>());
+    
+    return data;
+}

src/IPlatform.h

@@ -0,0 +1,81 @@
+#pragma once
+#include <vector>
+#include <string>
+#include "client/renderer/TextureData.h"
+#include <cstdint>
+
+typedef std::vector<std::string> StringVector;
+typedef std::vector<uint8_t> ByteVector; 
+
+class App;
+
+class IPlatform {
+public:
+	IPlatform() : keyboardVisible(false), windowSizeChanged(false), m_targetFrametime(0.f) {}
+    virtual ~IPlatform() {}
+
+	virtual bool init() { return true; }
+	virtual void swapBuffers() {}
+
+	virtual void runMainLoop(App& app);
+
+	virtual ByteVector readAssetFile(const std::string& path);
+
+
+	// Mojang functions here
+	virtual TextureData loadTexture(const std::string& filename_, bool textureFolder) { return TextureData(); }
+	virtual TextureData loadTextureFromMemory(const unsigned char* data, size_t size) { return TextureData(); }
+
+    virtual void playSound(const std::string& fn, float volume, float pitch) {}
+	
+	virtual void hideCursor(bool hide) {}
+
+	virtual std::string getDateString(int s) = 0;
+
+	virtual void uploadPlatformDependentData(int id, void* data) {}
+	// virtual BinaryBlob readAssetFile(const std::string& filename) { return BinaryBlob(); }
+	virtual void _tick() {}
+
+	virtual int getScreenWidth() { return 854; }
+	virtual int getScreenHeight() { return 480; }
+    virtual float getPixelsPerMillimeter() { return 10; }
+
+	virtual bool isNetworkEnabled(bool onlyWifiAllowed) { return true; }
+
+	virtual bool isPowerVR() {
+		return false;
+	}
+	virtual int getKeyFromKeyCode(int keyCode, int metaState, int deviceId) {return 0;}
+#ifdef __APPLE__
+    virtual bool isSuperFast() = 0;
+#endif
+
+	virtual void openURL(const std::string& url) {}
+
+	virtual void finish() {}
+	
+	virtual bool supportsTouchscreen() { return false; }
+	
+	virtual void vibrate(int milliSeconds) {}
+
+	virtual std::string getPlatformStringVar(int stringId) = 0;
+
+	virtual void showKeyboard() { keyboardVisible = true; }
+
+	virtual void hideKeyboard() { keyboardVisible = false; }
+
+	virtual bool isKeyboardVisible() { return keyboardVisible; }
+
+	virtual void setTargetFPS(int fps) { m_targetFrametime = 1.0 / fps; }
+
+	bool isWindowSizeChanged() { return windowSizeChanged; }
+
+	virtual void setVSync(bool on) { vsync = on; }
+
+protected:
+	bool keyboardVisible;
+	bool windowSizeChanged;
+	bool vsync;
+
+	double m_targetFrametime;
+};

src/Minecraft.cpp

@@ -0,0 +1,502 @@
+#include <Minecraft.h>
+#include "gamemode/CreativeMode.h"
+#include "gamemode/SurvivalMode.h"
+#include "gamemode/CreatorMode.h"
+#include "world/entity/player/Player.h"
+#include "world/item/Item.h"
+#include "world/item/ItemInstance.h"
+#include "world/item/crafting/Recipes.h"
+#include "world/level/Level.h"
+#include "world/level/tile/entity/TileEntity.h"
+#include <string>
+#include <cstdlib>
+#include "client/gui/Screen.h"
+#include "world/level/storage/ExternalFileLevelStorageSource.h"
+
+#if defined(APPLE_DEMO_PROMOTION)
+    #define NO_NETWORK
+#endif
+
+#if defined(RPI)
+	#define CREATORMODE
+#endif
+#include "network/RakNetInstance.h"
+#include "network/ClientSideNetworkHandler.h"
+#include "network/ServerSideNetworkHandler.h"
+//#include "network/Packet.h"
+#include "world/entity/player/Inventory.h"
+#include "world/level/tile/Tile.h"
+#include "world/level/storage/LevelStorageSource.h"
+#include "world/level/storage/LevelStorage.h"
+#include "world/level/chunk/ChunkSource.h"
+
+#include "platform/CThread.h"
+#include <IPlatform.h>
+#include "util/PerfTimer.h"
+#include "util/PerfRenderer.h"
+
+#include "world/entity/MobFactory.h"
+#include "world/level/MobSpawner.h"
+#include "util/Mth.h"
+#include "world/entity/MobCategory.h"
+#include "server/ServerLevel.h"
+
+#ifdef CREATORMODE
+#include "server/CreatorLevel.h"
+#endif
+
+#include "network/command/CommandServer.h"
+
+/*static*/
+const char* Minecraft::progressMessages[] = {
+	"Locating server",
+	"Building terrain",
+	"Preparing",
+	"Saving chunks"
+};
+
+// int Minecraft::customDebugId = Minecraft::CDI_NONE;
+bool Minecraft::_hasInitedStatics = false;
+
+#if defined(_MSC_VER)
+	#pragma warning( disable : 4355 ) // 'this' pointer in initialization list which is perfectly legal
+#endif
+
+// Minecraft::Minecraft() :
+// #ifdef __APPLE__
+//     _isSuperFast(false),
+// #endif
+
+
+// #if defined(NO_NETWORK)
+//     raknetInstance = new IRakNetInstance();
+// #else
+// 	raknetInstance = new RakNetInstance();
+// #endif
+// #ifndef STANDALONE_SERVER
+// 	soundEngine = new SoundEngine(20.0f);
+// 	soundEngine->init(this, &options);
+// #endif
+// 	//setupPieces();
+
+// 	#if defined(ANDROID) || defined(__APPLE__) || defined(RPI)
+//         signal(SIGPIPE, SIG_IGN);
+//     #endif
+
+// 	externalCacheStoragePath = '.';
+// 	externalCacheStoragePath = '.';
+// }
+
+Minecraft::~Minecraft() {
+	delete netCallback;
+	delete raknetInstance;
+	delete gameMode;
+
+	if (level != NULL) {
+		level->saveGame();
+		if (level->getChunkSource())
+			level->getChunkSource()->saveAll(true);
+		delete level->getLevelStorage();
+		delete level;
+		level = NULL;
+	}
+
+	//delete player;
+	delete storageSource;
+	delete _commandServer;
+
+	MobFactory::clearStaticTestMobs();
+
+	// Note: Don't tear down statics if we run on Android
+	// (we might change this in the future)
+#ifndef ANDROID
+	Biome::teardownBiomes();
+	Item ::teardownItems();
+	Tile ::teardownTiles();
+	Material::teardownMaterials();
+	Recipes ::teardownRecipes();
+	TileEntity::teardownTileEntities();
+#endif
+}
+
+// Only called by server
+void Minecraft::selectLevel( const std::string& levelId, const std::string& levelName, const LevelSettings& settings ) {
+	level = (Level*)new ServerLevel(
+		storageSource->selectLevel(levelId, false),
+		levelName,
+		settings,
+		SharedConstants::GeneratorVersion
+	);
+
+	// note: settings is useless beyond this point, since it's
+	//       either copied to LevelData (or LevelData read from file)
+	setLevel(level, "Generating level");
+	setIsCreativeMode(level->getLevelData()->getGameType() == GameType::Creative);
+	_running = true;
+}
+
+void Minecraft::setLevel(Level* level, const std::string& message, Player* forceInsertPlayer) {
+	LOGI("Seed is %ld\n", level->getSeed());
+	
+	if (level != NULL) {
+		level->raknetInstance = raknetInstance;
+        gameMode->initLevel(level);
+
+		this->level = level;
+		_hasSignaledGeneratingLevelFinished = false;
+#ifdef STANDALONE_SERVER
+		const bool threadedLevelCreation = false;
+#else
+		const bool threadedLevelCreation = true;
+#endif
+
+		if (threadedLevelCreation) {
+			// Threaded
+			// "Lock"
+			isGeneratingLevel = true;
+			generateLevelThread = new CThread(Minecraft::prepareLevel_tspawn, this);
+		} else {
+			// Non-threaded
+			generateLevel("Currently not used", level);
+		}
+    }
+
+    this->lastTickTime = 0;
+	this->_running = true;
+}
+
+void Minecraft::prepareLevel(const std::string& title) {
+	LOGI("status: 1\n");
+	progressStageStatusId = 1;
+
+	Stopwatch A, B, C, D;
+	A.start();
+
+	Stopwatch L;
+
+	// Dont update lights if we load the level (ok, actually just with leveldata version=1.+(?))
+	if (!level->isNew())
+		level->setUpdateLights(false);
+
+	int Max = CHUNK_CACHE_WIDTH * CHUNK_CACHE_WIDTH;
+	int pp = 0;
+	for (int x = 8; x < (CHUNK_CACHE_WIDTH * CHUNK_WIDTH); x += 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();
+            level->getTile(x, 64, z);
+			B.stop();
+			L.start();
+			if (level->isNew())
+				while (level->updateLights())
+					;
+			L.stop();
+        }
+    }
+	A.stop();
+	level->setUpdateLights(true);
+
+	C.start();
+	for (int x = 0; x < CHUNK_CACHE_WIDTH; x++)
+	{
+		for (int z = 0; z < CHUNK_CACHE_WIDTH; z++)
+		{
+			LevelChunk* chunk = level->getChunk(x, z);
+			if (chunk && !chunk->createdFromSave)
+			{
+				chunk->unsaved = false;
+				chunk->clearUpdateMap();
+			}
+		}
+	}
+	C.stop();
+
+	LOGI("status: 3\n");
+	progressStageStatusId = 3;
+	if (level->isNew()) {
+		level->setInitialSpawn(); // @note: should obviously be called from Level itself
+		level->saveLevelData();
+		level->getChunkSource()->saveAll(false);
+		level->saveGame();
+	} else {
+		level->saveLevelData();
+		level->loadEntities();
+	}
+
+	progressStagePercentage = -1;
+	progressStageStatusId = 2;
+	LOGI("status: 2\n");
+
+	D.start();
+	level->prepare();
+	D.stop();
+
+	A.print("Generate level: ");
+	L.print(" - light: ");
+	B.print(" - getTl: ");
+	C.print(" - clear: ");
+	D.print(" - prepr: ");
+	progressStageStatusId = 0;
+}
+
+void Minecraft::update() {
+
+	timer.advanceTime();
+	raknetInstance->runEvents(netCallback);
+
+	TIMER_PUSH("tick");
+	int toTick = timer.ticks;
+	timer.ticks = 0;
+	for (int i = 0; i < toTick; ++i, ++ticks) tick(i, toTick-1);
+
+	TIMER_POP_PUSH("updatelights");
+	{
+		if (level && !isGeneratingLevel) {
+			level->updateLights();
+		}
+	}
+	TIMER_POP();
+
+
+    // Restart the server if (our modded) RakNet reports an error
+    if (level && raknetInstance->isProbablyBroken() && raknetInstance->isServer()) {
+        restartServer();
+    }
+}
+
+void Minecraft::restartServer() {
+    if (!level) return;
+
+	raknetInstance->resetIsBroken();
+
+    hostMultiplayer();
+    if (netCallback) netCallback->levelGenerated(level);
+}
+
+void Minecraft::tick(int nTick, int maxTick) {
+	if (missTime > 0) missTime--;
+
+	TIMER_PUSH("gameMode");
+	if (level) {
+		gameMode->tick();
+	}
+
+	TIMER_POP_PUSH("commandServer");
+	if (level && _commandServer) {
+		_commandServer->tick();
+	}
+	
+	//
+	// Ongoing level generation in a (perhaps) different thread. When it's
+	// ready, _levelGenerated() is called once and any threads are deleted.
+	//
+	if (isGeneratingLevel) {
+		return;
+	} else if (!_hasSignaledGeneratingLevelFinished) {
+		if (generateLevelThread) {
+			delete generateLevelThread;
+			generateLevelThread = NULL;
+		}
+		_levelGenerated();
+	}
+
+	//
+	// Normal game loop, run before or efter level generation
+	//
+	if (level != NULL) {
+		TIMER_POP_PUSH("level");
+		level->tickEntities();
+		level->tick();
+	}
+
+	TIMER_POP();
+}
+
+bool Minecraft::isOnlineClient() {
+    return false;
+}
+
+bool Minecraft::isOnline() {
+	return netCallback != NULL;
+}
+
+void Minecraft::init()
+{
+	// WHY DO WE NEED THIS ON MODERN PLATFORMS :sob:
+	// Global initialization goes here
+	Mth::initMth();
+
+	if (raknetInstance != nullptr) {
+		delete raknetInstance;
+	}
+
+	raknetInstance = new RakNetInstance();
+
+	// If we're running Android, only initialize
+	// the first time class is instanced
+#ifdef ANDROID
+	if (!_hasInitedStatics) {
+		_hasInitedStatics = true;
+#endif
+		Material::initMaterials();
+		MobCategory::initMobCategories();
+		Tile::initTiles();
+		Item::initItems();
+		Biome::initBiomes();
+		TileEntity::initTileEntities();
+
+#ifdef ANDROID
+	}
+#endif
+
+	setIsCreativeMode(false); // false means it's Survival Mode
+
+#if !defined(NO_STORAGE)
+	storageSource = new ExternalFileLevelStorageSource(externalStoragePath, externalCacheStoragePath);
+#else
+	storageSource = new MemoryLevelStorageSource();
+#endif
+
+	// Server-only featire @todo server class app
+	hostMultiplayer();
+}
+
+
+//
+// Multiplayer
+//
+
+void Minecraft::hostMultiplayer(int port) {
+    // Tear down last instance
+    raknetInstance->disconnect();
+    delete netCallback;
+    netCallback = nullptr;
+
+#if !defined(NO_NETWORK)
+	netCallback = new ServerSideNetworkHandler(this, raknetInstance);
+#endif
+}
+
+//
+// Level generation
+//
+/*static*/
+
+void* Minecraft::prepareLevel_tspawn(void *p_param) {
+	Minecraft* mc = (Minecraft*) p_param;
+	mc->generateLevel("Currently not used", mc->level);
+	return 0;
+}
+
+void Minecraft::generateLevel( const std::string& message, Level* level ) {
+	Stopwatch s;
+	s.start();
+	prepareLevel(message);
+	s.stop();
+	s.print("Level generated: ");
+
+	// "Unlock"
+	isGeneratingLevel = false;
+}
+
+void Minecraft::_levelGenerated() {
+	level->validateSpawn();
+
+	if (raknetInstance->isServer())
+		raknetInstance->announceServer(getServerName());
+
+	if (netCallback) {
+		netCallback->levelGenerated(level);
+	}
+
+	_hasSignaledGeneratingLevelFinished = true;
+}
+
+Player* Minecraft::respawnPlayer(int playerId) {
+	for (unsigned int i = 0; i < level->players.size(); ++i) {
+		if (level->players[i]->entityId == playerId) {
+			resetPlayer(level->players[i]);
+			return level->players[i];
+		}
+	}
+	return NULL;
+}
+
+void Minecraft::resetPlayer(Player* player) {
+	level->validateSpawn();
+	player->reset();
+
+	Pos p;
+	if(player->hasRespawnPosition()) {
+		p = player->getRespawnPosition();
+	}
+	else {
+		p = level->getSharedSpawnPos();
+	}
+	player->setPos((float)p.x + 0.5f, (float)p.y + 1.0f, (float)p.z + 0.5f);
+	player->resetPos(true);
+
+	if (isCreativeMode())
+		player->inventory->clearInventoryWithDefault();
+}
+
+int Minecraft::getProgressStatusId() {
+	return progressStageStatusId;
+}
+
+const char* Minecraft::getProgressMessage()
+{
+	return progressMessages[progressStageStatusId];
+}
+
+bool Minecraft::isLevelGenerated()
+{
+	return level != NULL && !isGeneratingLevel;
+}
+
+LevelStorageSource* Minecraft::getLevelSource()
+{
+	return storageSource;
+}
+
+void Minecraft::setIsCreativeMode(bool isCreative)
+{
+#ifdef CREATORMODE
+	delete gameMode;
+	gameMode = new CreatorMode(this);
+	_isCreativeMode = true;
+#else
+	if (!gameMode || isCreative != _isCreativeMode)
+	{
+		delete gameMode;
+		if (isCreative) gameMode = new CreativeMode(*this);
+		else			gameMode = new SurvivalMode(*this);
+		_isCreativeMode = isCreative;
+	}
+#endif
+}
+
+bool Minecraft::isCreativeMode() {
+	return _isCreativeMode;
+}
+
+ICreator* Minecraft::getCreator()
+{
+#ifdef CREATORMODE
+	return ((CreatorMode*)gameMode)->getCreator();
+#else
+	return NULL;
+#endif
+}
+
+void Minecraft::optionUpdated(OptionId option, bool value ) {
+	if(netCallback != NULL && option == OPTIONS_SERVER_VISIBLE) {
+		ServerSideNetworkHandler* ss = (ServerSideNetworkHandler*) netCallback;
+		ss->allowIncomingConnections(value);
+	}
+}
+
+void Minecraft::optionUpdated(OptionId option, float value ) {}
+
+void Minecraft::optionUpdated(OptionId option, int value ) {}

src/Minecraft.h

@@ -0,0 +1,140 @@
+#ifndef NET_MINECRAFT_CLIENT__Minecraft_H__
+#define NET_MINECRAFT_CLIENT__Minecraft_H__
+
+#include "client/Options.h"
+#include "client/Timer.h"
+
+//#include "../network/RakNetInstance.h"
+#include "world/phys/HitResult.h"
+
+#include "App.h"
+#include <cstddef>
+
+class Level;
+class LocalPlayer;
+class IInputHolder;
+class Mob;
+class Player;
+class Entity;
+class ICreator;
+class GameMode;
+class CThread;
+class LevelStorageSource;
+class BuildActionIntention;
+class PerfRenderer;
+class LevelSettings;
+class IRakNetInstance;
+class NetEventCallback;
+class CommandServer;
+struct PingedCompatibleServer;
+
+class Minecraft: public App {
+public:
+	using App::App;
+	virtual ~Minecraft();
+
+	virtual void init();
+	virtual void update();
+	virtual void restartServer();
+	virtual void tick(int nTick, int maxTick);
+
+	virtual bool isOnlineClient();
+	virtual bool isOnline();
+
+	virtual void setIsCreativeMode(bool isCreative);
+
+	virtual void optionUpdated(OptionId option, bool value);
+	virtual void optionUpdated(OptionId option, float value);
+	virtual void optionUpdated(OptionId option, int value);
+
+	/**
+	 * @brief Get public name that will be listed in JoinGame menu
+	 */
+	virtual std::string getServerName() { return "Unknown"; }
+
+	void toggleDimension() {}
+	bool isCreativeMode();
+
+	virtual void selectLevel(const std::string& levelId, const std::string& levelName, const LevelSettings& settings);
+	virtual void setLevel(Level* level, const std::string& message = "", Player* forceInsertPlayer = NULL);
+
+	virtual void onBlockDestroyed(Player* player, int x, int y, int z, int face) {}
+
+	void generateLevel( const std::string& message, Level* level );
+	LevelStorageSource* getLevelSource();
+
+	virtual void hostMultiplayer(int port=19132);
+	Player* respawnPlayer(int playerId);
+	void respawnPlayer();
+	void resetPlayer(Player* player);
+	void doActuallyRespawnPlayer();
+
+	void prepareLevel(const std::string& message);
+
+	int getProgressStatusId();
+	const char* getProgressMessage();
+
+	ICreator* getCreator();
+
+	bool isLevelGenerated();
+
+#ifdef __APPLE__
+    bool _isSuperFast = false;
+    bool isSuperFast() { return _isSuperFast; }
+#endif
+
+protected:
+	virtual void _levelGenerated();
+
+private:
+	static void* prepareLevel_tspawn(void *p_param);
+public:
+	Level* level = nullptr;
+	CommandServer* _commandServer = nullptr;
+	GameMode* gameMode = nullptr;
+	IRakNetInstance*  raknetInstance = nullptr;
+	NetEventCallback* netCallback = nullptr;
+
+	int commandPort = 4711;
+
+	int lastTime = 0;
+	int lastTickTime = -1;
+	int missTime = 0;
+	int ticks = 0;
+
+	CThread* generateLevelThread = nullptr;
+	// static int customDebugId;
+
+	HitResult hitResult;
+	volatile int progressStagePercentage = 0;
+
+	// This field is initialized in main()
+	// It sets the base path to where worlds can be written (sdcard on android)
+	std::string externalStoragePath;
+	std::string externalCacheStoragePath;
+protected:
+	Timer timer{20};
+    // @note @attn @warn: this is dangerous as fuck!
+	volatile bool isGeneratingLevel = false;
+	bool _hasSignaledGeneratingLevelFinished = true;
+
+	LevelStorageSource* storageSource;
+	bool _running;
+
+protected:
+	volatile int progressStageStatusId = 0;
+	static const char* progressMessages[];
+
+	int _licenseId;
+
+	bool _isCreativeMode;
+	Player* _pendingRemovePlayer; // @attn @todo @fix: remove this shait and fix the respawn behaviour
+
+	// from NinecraftApp
+	bool _verbose = true;
+	int _lastTickMs = 0;
+
+	static bool _hasInitedStatics;
+};
+
+#endif /*NET_MINECRAFT_CLIENT__Minecraft_H__*/

src/MinecraftClient.h

@@ -0,0 +1,142 @@
+#pragma once
+#include "client/gui/Font.h"
+#include "client/gui/Screen.h"
+#include "client/particle/ParticleEngine.h"
+#include "client/player/LocalPlayer.h"
+#include "client/renderer/GameRenderer.h"
+#include "client/renderer/Textures.h"
+#include "client/sound/SoundEngine.h"
+#include <Minecraft.h>
+
+#include <client/MouseHandler.h>
+#include <client/gui/Gui.h>
+#include <client/gui/screens/ScreenChooser.h>
+#include <client/PixelCalc.h>
+#include <client/renderer/LevelRenderer.h>
+
+class MinecraftClient : public Minecraft {
+public:
+    using Minecraft::Minecraft;
+    ~MinecraftClient();
+
+    void init() override;
+
+    void update() override;
+
+    void setSize(int width, int height);
+    void reloadOptions();
+    
+    bool supportNonTouchScreen();
+	bool useTouchscreen();
+	void grabMouse();
+	void releaseMouse();
+
+    void setScreen(Screen*);
+    void leaveGame(bool renameLevel = false);
+
+	void setLevel(Level* level, const std::string& message = "", Player* forceInsertPlayer = NULL) override;
+
+    void updateStats();
+
+    void restartServer() override;
+
+    bool handleBack(bool isDown) override;
+
+    void onGraphicsReset();
+    void initGLStates();
+
+    void tick(int nTick, int maxTick) override;
+    void tickInput();
+
+    void handleBuildAction(BuildActionIntention* action);
+
+    bool isOnlineClient() override;
+
+    void pauseGame(bool isBackPaused);
+    void gameLostFocus();
+
+    void respawnPlayer();
+
+    void audioEngineOn() override;
+    void audioEngineOff() override;
+
+    void setIsCreativeMode(bool isCreative) override;
+
+    void optionUpdated(OptionId option, bool value) override;
+	void optionUpdated(OptionId option, float value) override;
+	void optionUpdated(OptionId option, int value) override;
+
+    LocalPlayer* getPlayer() { return player; }
+    Font* getFont() { return font; }
+    Textures& textures() { return m_textures; }
+    Options& options() { return m_options;}
+    Screen* getScreen() { return m_screen; }
+    Gui& gui() { return m_gui; }
+    ParticleEngine* getParticleEngine() {return particleEngine; }
+
+    int getScreenWidth() { return width; }
+    int getScreenHeigth() { return height; }
+
+    virtual void hostMultiplayer(int port) override;
+
+    bool isPowerVR() { return _powerVr; }
+	bool isKindleFire(int kindleVersion);
+	bool transformResolution(int* w, int* h);
+
+    virtual std::string getServerName() override;
+
+    void locateMultiplayer();
+	void cancelLocateMultiplayer();
+	bool joinMultiplayer(const PingedCompatibleServer& server);
+	bool joinMultiplayerFromString(const std::string& server);
+
+    void onBlockDestroyed(Player* player, int x, int y, int z, int face) override;
+
+protected:
+    void _reloadInput();
+    void _levelGenerated() override;
+
+    int width = 1, height = 1;
+
+	Font* font = nullptr;
+    // @warn This is unsafe cuz Gui may call some MinecraftClient method while MinecraftClient is not ready 
+    MouseHandler mouseHandler;
+
+    LevelRenderer*  levelRenderer = nullptr;
+	GameRenderer*   gameRenderer = nullptr;
+	ParticleEngine* particleEngine = nullptr;
+	SoundEngine*    soundEngine = nullptr;
+    PerfRenderer* _perfRenderer = nullptr;
+
+	bool mouseGrabbed = false;
+
+    PixelCalc pixelCalc;
+    PixelCalc pixelCalcUi;
+
+    Screen* m_screen = nullptr;
+
+    bool screenMutex = false;
+	bool hasScheduledScreen = false;
+	Screen* scheduledScreen = nullptr;
+
+    int m_frames = 0;
+
+    volatile bool pause = false;
+
+    // @todo make static
+    LocalPlayer*	player = nullptr;
+	IInputHolder*	inputHolder = nullptr;
+	Mob*			cameraTargetPlayer = nullptr;
+
+    bool _supportsNonTouchscreen = false;
+    bool isLookingForMultiplayer = false;
+    bool _powerVr = false;
+
+    Options m_options{*this};
+
+    Textures m_textures{m_options, *m_platform};
+
+    ScreenChooser screenChooser{*this};
+
+    Gui m_gui{*this};
+};

src/MinecraftServer.cpp

@@ -0,0 +1,15 @@
+#include "MinecraftServer.h"
+#include <Minecraft.h>
+#include <network/RakNetInstance.h>
+
+
+void MinecraftServer::hostMultiplayer(int port) {
+    Minecraft::hostMultiplayer(port);
+
+    raknetInstance->host("Server", port, 16);
+}
+
+std::string MinecraftServer::getServerName() {
+	// @todo read server name from config
+    return "Dedicated server 0.6.1";
+}

src/MinecraftServer.h

@@ -0,0 +1,10 @@
+#pragma once
+#include <Minecraft.h>
+
+class MinecraftServer : public Minecraft { 
+public:
+    using Minecraft::Minecraft;
+
+    void hostMultiplayer(int port) override;
+    std::string getServerName() override;
+};

src/NinecraftApp.cpp

@@ -1,428 +0,0 @@
-#include "NinecraftApp.h"
-//#include <EGL/egl.h>
-
-#ifdef RPI
-//#define NO_STORAGE
-#endif
-
-#include <errno.h>
-
-#include "platform/input/Mouse.h"
-#include "platform/input/Multitouch.h"
-
-#include "world/item/Item.h"
-#include "world/level/Level.h"
-#include "world/level/biome/Biome.h"
-#include "world/level/material/Material.h"
-#include "world/entity/MobCategory.h"
-//#include "world/level/storage/FolderMethods.h"
-#ifndef STANDALONE_SERVER
-#include "client/gui/screens/StartMenuScreen.h"
-#include "client/gui/screens/UsernameScreen.h"
-#endif
-#include "client/player/LocalPlayer.h"
-#ifndef STANDALONE_SERVER
-#include "client/renderer/gles.h"
-#include "client/renderer/Chunk.h"
-#include "client/renderer/LevelRenderer.h"
-#include "client/renderer/Tesselator.h"
-#endif
-// sorry for raknet dependency, but I'm too lazy to find another getTime method
-#include "raknet/GetTime.h"
-#include "network/RakNetInstance.h"
-#include "network/ClientSideNetworkHandler.h"
-#include "client/gui/screens/ProgressScreen.h"
-
-//#include "world/entity/player/Inventory2.h"
-
-#if !defined(DEMO_MODE) && !defined(APPLE_DEMO_PROMOTION) && !defined(NO_STORAGE)
-	#include "world/level/storage/ExternalFileLevelStorageSource.h"
-#else
-	#include "world/level/storage/MemoryLevelStorageSource.h"
-#endif
-#ifndef STANDALONE_SERVER
-#include "client/renderer/Textures.h"
-#include "client/renderer/entity/ItemRenderer.h"
-#endif
-#include "world/item/crafting/Recipes.h"
-#include "world/level/tile/entity/TileEntity.h"
-#ifndef STANDALONE_SERVER
-#include "client/renderer/EntityTileRenderer.h"
-#endif
-
-bool NinecraftApp::_hasInitedStatics = false;
-
-NinecraftApp::NinecraftApp()
-:   _verbose(true),
-	_lastTickMs(0),
-	_frames(0)
-{
-    #if defined(ANDROID) || defined(__APPLE__) || defined(RPI)
-        signal(SIGPIPE, SIG_IGN);
-    #endif
-}
-
-NinecraftApp::~NinecraftApp()
-{
-	teardown();
-}
-
-void NinecraftApp::init()
-{
-	// Global initialization goes here
-	Mth::initMth();
-
-	//#ifdef DEMO_MODE
-	//writeDemoFile();
-	//#endif
-
-	// If we're running Android, only initialize
-	// the first time class is instanced
-	#ifdef ANDROID
-	if (!_hasInitedStatics) {
-		_hasInitedStatics = true;
-	#endif
-		Material::initMaterials();
-		MobCategory::initMobCategories();
-		Tile::initTiles();
-		Item::initItems();
-		Biome::initBiomes();
-		TileEntity::initTileEntities();
-
-	#ifdef ANDROID
-	}
-	#endif
-
-#ifndef STANDALONE_SERVER
-	initGLStates();
-	Tesselator::instance.init();
-	I18n::loadLanguage(platform(), "en_US");
-#endif
-
-	if (!externalStoragePath.empty()) {
-		options.setOptionsFilePath(externalStoragePath);
-	}
-	Minecraft::init();
-
-#if !defined(DEMO_MODE) && !defined(APPLE_DEMO_PROMOTION) && !defined(NO_STORAGE)
-	storageSource = new ExternalFileLevelStorageSource(externalStoragePath, externalCacheStoragePath);
-#else
-	storageSource = new MemoryLevelStorageSource();
-#endif
-	_running = false;
-
-#ifndef STANDALONE_SERVER
-	LOGI("This: %p\n", this);
-	screenChooser.setScreen(SCREEN_STARTMENU);
-
-	if (options.getBooleanValue(OPTIONS_FIRST_LAUNCH)) {
-		options.toggle(OPTIONS_FIRST_LAUNCH);
-		setScreen(new UsernameScreen());
-	}
-#else
-	hostMultiplayer();
-#endif
-}
-
-void NinecraftApp::teardown()
-{
-	// Note: Don't tear down statics if we run on Android
-	// (we might change this in the future)
-#ifndef ANDROID
-	Biome::teardownBiomes();
-	Item ::teardownItems();
-	Tile ::teardownTiles();
-	Material::teardownMaterials();
-	Recipes ::teardownRecipes();
-	TileEntity::teardownTileEntities();
-#endif
-#ifdef WIN32
-	ItemRenderer::teardown_static();
-	if (EntityTileRenderer::instance != NULL) {
-		delete EntityTileRenderer::instance;
-		EntityTileRenderer::instance = NULL;
-	}
-	TileEntityRenderDispatcher::destroy();
-#endif
-}
-
-void NinecraftApp::update()
-{
-	++_frames;
-
-	// Generate Multitouch active pointer list
-	Multitouch::commit();
-
-#ifndef ANDROID_PUBLISH
-	//testCreationAndDestruction();
-	//testJoiningAndDestruction();
-#endif /*ANDROID_PUBLISH*/
-
-	Minecraft::update();
-
-	swapBuffers();
-	Mouse::reset2();
-
-    // Restart the server if (our modded) RakNet reports an error
-    if (level && raknetInstance->isProbablyBroken() && raknetInstance->isServer()) {
-        restartServer();
-    }
-
-#ifndef WIN32
-	updateStats();
-#endif
-}
-
-void NinecraftApp::updateStats()
-{
-#ifndef STANDALONE_SERVER
-	if (Options::debugGl)
-		LOGI("--------------------------------------------\n");
-
-	//*
-	int now = getTimeMs();
-	//int since = now - _lastTickMs;
-
-	if (now >= lastTime + 1000)
-	{
-		if (player) {
-			LOGI("%d fps   \t%3d chunk updates.   (%.2f, %.2f, %.2f)\n",
-				_frames, Chunk::updates, player->x, player->y, player->z);
-			Chunk::resetUpdates();
-
-			//static int _n = 0;
-			//if (++_n % 5 == -1) { // @note: -1
-			//	static char filename[256];
-			//	sprintf(filename, "%s/games/com.mojang/img_%.4d.jpg", externalStoragePath.c_str(), _n/5);
-			//	_context.platform->saveScreenshot(filename, width, height);
-			//}
-
-			LOGI("%s", levelRenderer->gatherStats1().c_str());
-			//printf("Texture swaps (this frame): %d\n", Textures::textureChanges);
-		} else {
-			LOGI("%d fps\n", _frames);
-		}
-
-		//const int* pointerIds;
-		//int pointerCount = Multitouch::getActivePointerIds(&pointerIds);
-		//if (pointerCount) {
-		//	std::string s = "Pointers (";
-		//	s += (char)(48 + pointerCount);
-		//	s += ": ";
-		//	for (int i = 0; i < pointerCount; ++i) {
-		//		s += (char)(48 + pointerIds[i]);
-		//		s += ", ";
-		//	}
-		//	LOGI("%s\n", s.c_str());
-		//}
-
-		lastTime = now;
-		_frames = 0;
-#ifdef GLDEBUG
-		while (1) {
-			int error = glGetError();
-			if (error == GL_NO_ERROR) break;
-
-			LOGI("#################### GL-ERROR: %d\t#####################\n", error);
-			LOGI("#################### GL-ERROR: %d\t#####################\n", error);
-			LOGI("#################### GL-ERROR: %d\t#####################\n", error);
-		}
-#endif
-	}
-	Textures::textureChanges = 0;
-	/**/
-#endif /* STANDALONE_SERVER */
-}
-
-void NinecraftApp::initGLStates()
-{
-#ifndef STANDALONE_SERVER
-	//glShadeModel2(GL_SMOOTH);
-	//glClearDepthf(1.0f);
-	glEnable2(GL_DEPTH_TEST);
-	glDepthFunc(GL_LEQUAL);
-	glDepthRangef(0, 1);
-	glEnable2(GL_ALPHA_TEST);
-	glAlphaFunc(GL_GREATER, 0.1f);
-	glEnable(GL_CULL_FACE);
-	glCullFace(GL_BACK);
-
-	glEnable2(GL_TEXTURE_2D);
-#ifndef _EMSCRIPTEN_
-	glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST);
-#endif
-	// Both updates isPowerVR flag in java and returns if the graphics chip is PowerVR SGX or not
-	_powerVr = platform()->isPowerVR();
-#ifdef __APPLE__
-    _isSuperFast = platform()->isSuperFast();
-#endif
-	//glLineWidth(4);
-#endif /* STANDALONE_SERVER */
-}
-
-void NinecraftApp::restartServer() {
-    if (!level) return;
-
-    for (int i = level->players.size()-1; i >= 0; --i) {
-        Player* p = level->players[i];
-        if (p != player)
-            level->removeEntity(p);
-    }
-
-	raknetInstance->resetIsBroken();
-#ifndef STANDALONE_SERVER
-    gui.addMessage("This server has restarted!");
-#endif
-    hostMultiplayer();
-    if (netCallback) netCallback->levelGenerated(level);
-}
-
-bool NinecraftApp::handleBack(bool isDown)
-{
-	if (isGeneratingLevel)
-	{
-		return true;
-	}
-	if (level)
-	{
-		if (!isDown)
-		{
-			if (screen)
-			{
-				if (!screen->handleBackEvent(isDown))
-				{
-					if (player->containerMenu) player->closeContainer();
-					setScreen(NULL);
-				}
-				return true;
-			} else {
-				pauseGame(true);
-			}
-			//leaveGame();
-			return false;
-		}
-		return true;
-	}
-	else if (screen)
-	{
-		return screen->handleBackEvent(isDown);
-	}
-	return false;
-}
-
-void NinecraftApp::onGraphicsReset()
-{
-#ifndef STANDALONE_SERVER
-	initGLStates();
-	Tesselator::instance.init();
-
-	Minecraft::onGraphicsReset();
-#endif
-}
-
-#ifndef ANDROID_PUBLISH
-
-static int _state = -1;
-static int _stateTicksLeft = 0;
-void NinecraftApp::testCreationAndDestruction()
-{
-	if (_state == -1) {
-		_stateTicksLeft = 100;
-		_state = 0;
-	}
-	if (_state == 0) {
-		if (--_stateTicksLeft <= 0)
-			_state = 1;
-	}
-	else if (_state == 1) {
-		getLevelSource()->deleteLevel("perf");
-		int seed = getEpochTimeS();
-		LOGI(">seed %d\n", seed);
-		selectLevel("perf", "perf", LevelSettings(seed, GameType::Creative));
-		hostMultiplayer();
-#ifndef STANDALONE_SERVER
-		setScreen(new ProgressScreen());
-#endif
-		_state = 2;
-		_stateTicksLeft = 1000;//25000;//00;
-	}
-	else if (_state == 2) {
-		if (isLevelGenerated()) {
-			if (--_stateTicksLeft <= 0) {
-				_state = 3;
-			}
-		}
-	} else if (_state == 3) {
-		leaveGame();
-		_state = 1;
-	}
-}
-
-
-void NinecraftApp::testJoiningAndDestruction()
-{
-	if (_state == -1) {
-		//LightUpdate sz[2] = {	LightUpdate(LightLayer::Block, 0, 0, 0, 1, 1, 1), 
-		//						LightUpdate(LightLayer::Sky, 0, 0, 0, 1, 1, 1) };
-		//LOGI("size of lightupdate: %lu == %d\n", sizeof(LightUpdate), (const char*)&sz[1] - (const char*)&sz[0]);
-		_stateTicksLeft = 100;
-		_state = 0;
-	}
-	if (_state == 0) {
-		if (--_stateTicksLeft <= 0) {
-			raknetInstance->clearServerList();
-			locateMultiplayer();
-			_state = 1;
-		}
-	}
-	else if (_state == 1) {
-		if (!raknetInstance->getServerList().empty()) {
-			PingedCompatibleServer s = raknetInstance->getServerList().at(0);
-			if (s.name.GetLength() > 0) {
-				joinMultiplayer(s);
-#ifndef STANDALONE_SERVER
-				setScreen(new ProgressScreen());
-#endif
-				_state = 2;
-				_stateTicksLeft = 80;//1000;
-			}
-		}
-	}
-	else if (_state == 2) {
-		if (isLevelGenerated()) {
-			if (--_stateTicksLeft <= 0) {
-				_state = 3;
-			}
-		}
-	} else if (_state == 3) {
-		leaveGame();
-		_stateTicksLeft = 50;
-		_state = 0;
-	}
-}
-
-#endif /*ANDROID_PUBLISH*/
-
-/*
-void NinecraftApp::writeDemoFile() {
-	std::string path = externalStoragePath + "/games";
-
-	if (createFolderIfNotExists(path.c_str())) {
-	path += "/com.mojang";
-	if (createFolderIfNotExists(path.c_str())) {
-	path += "/minecraftpe";
-	if (createFolderIfNotExists(path.c_str())) {
-		path += "/played_demo";
-		FILE* fp = fopen(path.c_str(), "w");
-		if (fp) fclose(fp);
-	}}}
-}
-
-bool NinecraftApp::hasPlayedDemo() {
-	std::string filename = externalStoragePath + "/games/com.mojang/minecraftpe/played_demo";
-	FILE* fp = fopen(filename.c_str(), "r");
-	if (!fp) return false;
-	fclose(fp);
-	return true;
-}
-*/

src/NinecraftApp.h

@@ -1,52 +0,0 @@
-#ifndef NINECRAFTAPP_H__
-#define NINECRAFTAPP_H__
-
-#include "world/Pos.h"
-#include "App.h"
-#include "client/Minecraft.h"
-#include "world/level/storage/MemoryLevelStorage.h"
-#include <string>
-
-
-class Level;
-class LocalPlayer;
-class ExternalFileLevelStorageSource;
-
-class NinecraftApp: public Minecraft
-{
-public:
-    NinecraftApp();
-	~NinecraftApp();
-
-	void init();
-	void teardown();
-
-	void update();
-
-	virtual bool handleBack(bool isDown);
-
-protected:
-	void onGraphicsReset();
-
-private:
-	void initGLStates();
-    void restartServer();
-
-	void updateStats();
-
-	//void writeDemoFile();
-	//bool hasPlayedDemo();
-
-#ifndef ANDROID_PUBLISH
-	void testCreationAndDestruction();
-	void testJoiningAndDestruction();
-#endif /*ANDROID_PUBLISH*/
-
-	bool _verbose;
-	int _frames;
-	int _lastTickMs;
-
-	static bool _hasInitedStatics;
-};
-
-#endif//NINECRAFTAPP_H__

src/client/Minecraft.h

@@ -1,239 +0,0 @@
-#ifndef NET_MINECRAFT_CLIENT__Minecraft_H__
-#define NET_MINECRAFT_CLIENT__Minecraft_H__
-
-#include "Options.h"
-#include "commands/CommandManager.hpp"
-#ifndef STANDALONE_SERVER
-#include "MouseHandler.h"
-#include "gui/Gui.h"
-#include "gui/screens/ScreenChooser.h"
-#endif
-
-#include "Timer.h"
-
-//#include "../network/RakNetInstance.h"
-#include "../world/phys/HitResult.h"
-
-class Level;
-class LocalPlayer;
-class IInputHolder;
-class Mob;
-class Player;
-class LevelRenderer;
-class GameRenderer;
-class ParticleEngine;
-class Entity;
-class ICreator;
-class GameMode;
-class Textures;
-class CThread;
-class SoundEngine;
-class Screen;
-class Font;
-class LevelStorageSource;
-class BuildActionIntention;
-class PerfRenderer;
-class LevelSettings;
-class IRakNetInstance;
-class NetEventCallback;
-class CommandServer;
-struct PingedCompatibleServer;
-//class ExternalFileLevelStorageSource;
-
-
-#include "../App.h"
-#include "PixelCalc.h"
-class AppPlatform;
-class AppPlatform_android;
-
-class Minecraft: public App
-{
-protected:
-	Minecraft();
-public:
-	virtual ~Minecraft();
-
-	void init();
-	void setSize(int width, int height);
-	void reloadOptions();
-
-	bool supportNonTouchScreen();
-	bool useTouchscreen();
-	void grabMouse();
-	void releaseMouse();
-
-	void handleBuildAction(BuildActionIntention*);
-
-	void toggleDimension(){}
-	bool isCreativeMode();
-	void setIsCreativeMode(bool isCreative);
-	void setScreen(Screen*);
-
-	virtual void selectLevel(const std::string& levelId, const std::string& levelName, const LevelSettings& settings);
-	virtual void setLevel(Level* level, const std::string& message = "", LocalPlayer* forceInsertPlayer = NULL);
-
-	void generateLevel( const std::string& message, Level* level );
-	LevelStorageSource* getLevelSource();
-
-	bool isLookingForMultiplayer;
-	void locateMultiplayer();
-	void cancelLocateMultiplayer();
-	bool joinMultiplayer(const PingedCompatibleServer& server);
-	bool joinMultiplayerFromString(const std::string& server);
-	void hostMultiplayer(int port=19132);
-	Player* respawnPlayer(int playerId);
-	void respawnPlayer();
-	void resetPlayer(Player* player);
-	void doActuallyRespawnPlayer();
-
-	void update();
-
-	void tick(int nTick, int maxTick);
-	void tickInput();
-
-	bool isOnlineClient();
-	bool isOnline();
-	void pauseGame(bool isBackPaused);
-	void gameLostFocus();
-
-	void prepareLevel(const std::string& message);
-
-	void leaveGame(bool renameLevel = false);
-
-	int getProgressStatusId();
-	const char* getProgressMessage();
-
-	ICreator* getCreator();
-
-	// void onGraphicsLost() {}
-	void onGraphicsReset();
-
-	bool isLevelGenerated();
-
-	void handleMouseDown(int button, bool down);
-	
-    void audioEngineOn();
-    void audioEngineOff();
-    
-	bool isPowerVR() { return _powerVr; }
-	bool isKindleFire(int kindleVersion);
-	bool transformResolution(int* w, int* h);
-	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();
-
-private:
-	static void* prepareLevel_tspawn(void *p_param);
-
-	void _reloadInput();
-public:
-	int width;
-	int height;
-
-	// Vars that the platform is allowed to use in the future
-	int commandPort;
-	int reserved_d1, reserved_d2;
-	float reserved_f1, reserved_f2;
-
-	Options options;
-
-	static bool useAmbientOcclusion;
-	//static bool threadInterrupt;
-
-	volatile bool pause;
-
-	LevelRenderer*  levelRenderer;
-	GameRenderer*   gameRenderer;
-	ParticleEngine* particleEngine;
-	SoundEngine*    soundEngine;
-
-	GameMode* gameMode;
-#ifndef STANDALONE_SERVER
-	Textures* textures;
-	ScreenChooser screenChooser;
-	Font* font;
-#endif
-	IRakNetInstance*  raknetInstance;
-	NetEventCallback* netCallback;
-
-	int lastTime;
-	int lastTickTime;
-	float ticksSinceLastUpdate;
-
-	Level* level;
-
-	LocalPlayer*	player;
-	IInputHolder*	inputHolder;
-	Mob*			cameraTargetPlayer;
-#ifndef STANDALONE_SERVER
-	Gui gui;
-#endif
-	CThread* generateLevelThread;
-	Screen* screen;
-	static int customDebugId;
-
-	static const int CDI_NONE = 0;
-	static const int CDI_GRAPHICS = 1;
-#ifndef STANDALONE_SERVER
-	MouseHandler mouseHandler;
-#endif
-	bool mouseGrabbed;
-
-    PixelCalc pixelCalc;
-    PixelCalc pixelCalcUi;
-
-	HitResult hitResult;
-	volatile int progressStagePercentage;
-
-	// This field is initialized in main()
-	// It sets the base path to where worlds can be written (sdcard on android)
-	std::string externalStoragePath;
-	std::string externalCacheStoragePath;
-protected:
-	Timer timer;
-
-	// @note @attn @warn: this is dangerous as fuck!
-	volatile bool isGeneratingLevel;
-	bool _hasSignaledGeneratingLevelFinished;
-
-	LevelStorageSource* storageSource;
-	bool _running;
-	bool _powerVr;
-
-private:
-	volatile int progressStageStatusId;
-	static const char* progressMessages[];
-
-	int missTime;
-	int ticks;
-	bool screenMutex;
-	bool hasScheduledScreen;
-	Screen* scheduledScreen;
-
-	int _licenseId;
-	bool _supportsNonTouchscreen;
-
-	bool _isCreativeMode;
-	//int _respawnPlayerTicks;
-	Player* _pendingRemovePlayer; // @attn @todo @fix: remove this shait and fix the respawn behaviour
-
-	PerfRenderer* _perfRenderer;
-	CommandServer* _commandServer;
-
-	CommandManager m_commandManager;
-};
-
-#endif /*NET_MINECRAFT_CLIENT__Minecraft_H__*/

src/client/Options.cpp

@@ -1,11 +1,6 @@
 #include "Options.h"
-#include "OptionStrings.h"
-#include "Minecraft.h"
-#include "../platform/log.h"
 #include "../world/Difficulty.h"
-#include <cmath>
+#include <MinecraftClient.h>
-
-#include <memory>
 
 bool Options::debugGl = false;
 
@@ -290,13 +285,13 @@ void Options::setOptionsFilePath(const std::string& path) {
 }
 
 void Options::notifyOptionUpdate(OptionId key, bool value) {
-	minecraft->optionUpdated(key, value);
+	minecraft.optionUpdated(key, value);
 }
 
 void Options::notifyOptionUpdate(OptionId key, float value) {
-	minecraft->optionUpdated(key, value);
+	minecraft.optionUpdated(key, value);
 }
 
 void Options::notifyOptionUpdate(OptionId key, int value) {
-	minecraft->optionUpdated(key, value);
+	minecraft.optionUpdated(key, value);
 }

src/client/Options.h

@@ -15,9 +15,8 @@
 //#include "locale/Language.h"
 
 #include <string>
-#include <cstdio>
+#include <platform/input/Keyboard.h>
-#include "../platform/input/Keyboard.h"
+#include <util/StringUtils.h>
-#include "../util/StringUtils.h"
 #include "OptionsFile.h"
 #include "Option.h"
 #include <array>
@@ -88,7 +87,7 @@ enum OptionId {
 	OPTIONS_COUNT
 };
 
-class Minecraft;
+class MinecraftClient;
 typedef std::vector<std::string> StringVector;
 
 class Options
@@ -96,7 +95,7 @@ class Options
 public:
     static bool debugGl;
 
-    Options(Minecraft* minecraft, const std::string& workingDirectory = "") 
+    Options(MinecraftClient& minecraft, const std::string& workingDirectory = "") 
 	: minecraft(minecraft) {
         // elements werent initialized so i was getting a garbage pointer and a crash
         m_options.fill(nullptr);
@@ -161,7 +160,7 @@ private:
 	std::array<Option*, OPTIONS_COUNT> m_options;
 	OptionsFile optionsFile;
 
-	Minecraft* minecraft;
+	MinecraftClient& minecraft;
 };
 
 #endif /*NET_MINECRAFT_CLIENT__Options_H__*/

src/client/gamemode/CreativeMode.cpp

@@ -1,56 +0,0 @@
-#include "CreativeMode.h"
-#include "../Minecraft.h"
-#ifndef STANDALONE_SERVER
-#include "../particle/ParticleEngine.h"
-#endif
-#include "../player/LocalPlayer.h"
-#ifndef STANDALONE_SERVER
-#include "../renderer/LevelRenderer.h"
-#include "../sound/SoundEngine.h"
-#endif
-#include "../../world/level/Level.h"
-//#include "../../network/Packet.h"
-#include "../../network/packet/RemoveBlockPacket.h"
-#include "../../world/entity/player/Abilities.h"
-
-static const int DestructionTickDelay = 5;
-
-CreativeMode::CreativeMode(Minecraft* minecraft)
-: 	super(minecraft)
-{
-}
-
-void CreativeMode::startDestroyBlock(int x, int y, int z, int face) {
-	if(minecraft->player->getCarriedItem() != NULL && minecraft->player->getCarriedItem()->id == Item::bow->id)
-		return;
-
-	creativeDestroyBlock(x, y, z, face);
-	destroyDelay = DestructionTickDelay;
-}
-
-void CreativeMode::creativeDestroyBlock(int x, int y, int z, int face) {
-	minecraft->level->extinguishFire(x, y, z, face);
-	destroyBlock(x, y, z, face);
-}
-
-void CreativeMode::continueDestroyBlock(int x, int y, int z, int face) {
-	destroyDelay--;
-	if (destroyDelay <= 0) {
-		destroyDelay = DestructionTickDelay;
-		creativeDestroyBlock(x, y, z, face);
-	}
-}
-
-void CreativeMode::stopDestroyBlock() {
-	destroyDelay = 0;
-}
-
-void CreativeMode::initAbilities( Abilities& abilities ) {
-	abilities.mayfly = true;
-	abilities.instabuild = true;
-	abilities.invulnerable = true;
-}
-
-bool CreativeMode::isCreativeType() {
-	return true;
-}

src/client/gamemode/CreatorMode.cpp

@@ -1,102 +0,0 @@
-#include "CreatorMode.h"
-#include "../Minecraft.h"
-#include "../particle/ParticleEngine.h"
-#include "../player/LocalPlayer.h"
-#include "../renderer/LevelRenderer.h"
-#include "../sound/SoundEngine.h"
-#include "../../world/level/Level.h"
-//#include "../../network/Packet.h"
-#include "../../network/packet/RemoveBlockPacket.h"
-#include "../../world/entity/player/Abilities.h"
-
-static const int DestructionTickDelay = 5;
-
-class Creator: public ICreator {
-	//virtual void getEvents();
-
-public:
-	Creator(/*int eventLifeTime*/)
-	:	_tileEvents(32),
-		_tickId(0)
-	{
-	}
-
-	void setTick(int tick) {
-		_tickId = tick;
-	}
-
-	EventList<TileEvent>& getTileEvents() { return _tileEvents; }
-
-	void addevent_blockUse(int entityId, int x, int y, int z, int face) {
-		TileEvent t = {
-			entityId,
-			x,y,z,
-			face
-		};
-		_tileEvents.add(t, _tickId);
-	}
-
-private:
-	EventList<TileEvent> _tileEvents;
-	int _tickId;
-};
-
-CreatorMode::CreatorMode(Minecraft* minecraft)
-:	super(minecraft)
-{
-	_creator = new Creator();
-}
-
-CreatorMode::~CreatorMode() {
-	delete _creator;
-}
-
-void CreatorMode::startDestroyBlock(int x, int y, int z, int face) {
-	if(minecraft->player->getCarriedItem() != NULL && minecraft->player->getCarriedItem()->id == Item::bow->id)
-		return;
-
-	CreatorDestroyBlock(x, y, z, face);
-	destroyDelay = DestructionTickDelay;
-}
-
-void CreatorMode::CreatorDestroyBlock(int x, int y, int z, int face) {
-	minecraft->level->extinguishFire(x, y, z, face);
-	destroyBlock(x, y, z, face);
-}
-
-void CreatorMode::continueDestroyBlock(int x, int y, int z, int face) {
-	destroyDelay--;
-	if (destroyDelay <= 0) {
-		destroyDelay = DestructionTickDelay;
-		CreatorDestroyBlock(x, y, z, face);
-	}
-}
-
-bool CreatorMode::useItemOn( Player* player, Level* level, ItemInstance* item, int x, int y, int z, int face, const Vec3& hit ) {
-	if (item && item->id == ((Item*)Item::sword_iron)->id)
-		_creator->addevent_blockUse(player->entityId, x, y, z, face);
-	return super::useItemOn(player, level, item, x, y, z, face, hit);
-}
-
-void CreatorMode::stopDestroyBlock() {
-	destroyDelay = 0;
-}
-
-void CreatorMode::initAbilities( Abilities& abilities ) {
-	abilities.mayfly = true;
-	abilities.instabuild = true;
-	abilities.invulnerable = true;
-}
-
-bool CreatorMode::isCreativeType() {
-	return true;
-}
-
-ICreator* CreatorMode::getCreator() {
-	return _creator;
-}
-
-void CreatorMode::tick() {
-	_creator->setTick(minecraft->level->getTime());
-	super::tick();
-}

src/client/gamemode/SurvivalMode.cpp

@@ -1,99 +0,0 @@
-#include "SurvivalMode.h"
-#include "../Minecraft.h"
-#include "../player/LocalPlayer.h"
-#ifndef STANDALONE_SERVER
-#include "../particle/ParticleEngine.h"
-#include "../sound/SoundEngine.h"
-#endif
-#include "../../world/level/Level.h"
-#include "../../world/entity/player/Abilities.h"
-
-SurvivalMode::SurvivalMode( Minecraft* minecraft )
-:	super(minecraft),
-	xDestroyBlock(-1),
-	yDestroyBlock(-1),
-	zDestroyBlock(-1)
-{
-}
-
-void SurvivalMode::continueDestroyBlock( int x, int y, int z, int face ) {
-	if (destroyDelay > 0) {
-		destroyDelay--;
-		return;
-	}
-
-	if (x == xDestroyBlock && y == yDestroyBlock && z == zDestroyBlock) {
-		int t = minecraft->level->getTile(x, y, z);
-		if (t == 0) return;
-		Tile* tile = Tile::tiles[t];
-
-		destroyProgress += tile->getDestroyProgress(minecraft->player);
-
-		if ((++destroyTicks & 3) == 1) {
-#ifndef STANDALONE_SERVER
-			if (tile != NULL) {
-				minecraft->soundEngine->play(tile->soundType->getStepSound(), x + 0.5f, y + 0.5f, z + 0.5f, (tile->soundType->getVolume() + 1) / 8, tile->soundType->getPitch() * 0.5f);
-			}
-#endif
-		}
-
-		if (destroyProgress >= 1) {
-			destroyBlock(x, y, z, face);
-			destroyProgress = 0;
-			oDestroyProgress = 0;
-			destroyTicks = 0;
-			destroyDelay = 5;
-		}
-	} else {
-		destroyProgress = 0;
-		oDestroyProgress = 0;
-		destroyTicks = 0;
-		xDestroyBlock = x;
-		yDestroyBlock = y;
-		zDestroyBlock = z;
-	}
-}
-
-bool SurvivalMode::destroyBlock( int x, int y, int z, int face ) {
-	int t = minecraft->level->getTile(x, y, z);
-	int data = minecraft->level->getData(x, y, z);
-	bool changed = GameMode::destroyBlock(x, y, z, face);
-	bool couldDestroy = minecraft->player->canDestroy(Tile::tiles[t]);
-
-	ItemInstance* item = minecraft->player->inventory->getSelected();
-	if (item != NULL) {
-		item->mineBlock(t, x, y, z);
-		if (item->count == 0) {
-			//item->snap(minecraft->player);
-			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);
-	}
-	return changed;
-}
-
-void SurvivalMode::stopDestroyBlock() {
-	destroyProgress = 0;
-	destroyDelay = 0;
-}
-
-void SurvivalMode::initAbilities( Abilities& abilities ) {
-	abilities.flying = false;
-	abilities.mayfly = false;
-	abilities.instabuild = false;
-	abilities.invulnerable = false;
-}
-
-void SurvivalMode::startDestroyBlock( int x, int y, int z, int face ) {
-	if(minecraft->player->getCarriedItem() != NULL && minecraft->player->getCarriedItem()->id == Item::bow->id)
-		return;
-
-	int t = minecraft->level->getTile(x, y, z);
-	if (t > 0 && destroyProgress == 0) Tile::tiles[t]->attack(minecraft->level, x, y, z, minecraft->player);
-	if (t > 0 && Tile::tiles[t]->getDestroyProgress(minecraft->player) >= 1)
-		destroyBlock(x, y, z, face);
-}

src/client/gui/Gui.cpp

@@ -1,11 +1,12 @@
 #include "Gui.h"
 #include "Font.h"
+#include "MinecraftClient.h"
 #include "client/Options.h"
 #include "platform/input/Keyboard.h"
 #include "screens/IngameBlockSelectionScreen.h"
 #include "screens/ChatScreen.h"
 #include "screens/ConsoleScreen.h"
-#include "../Minecraft.h"
+#include <Minecraft.h>
 #include "../player/LocalPlayer.h"
 #include "../renderer/Tesselator.h"
 #include "../renderer/TileRenderer.h"
@@ -29,39 +30,23 @@
 #include <algorithm>
 #include <sstream>
 
+#define MAX_MESSAGE_WIDTH 240
+
 float Gui::InvGuiScale = 1.0f / 3.0f;
 float Gui::GuiScale = 1.0f / Gui::InvGuiScale;
 const float Gui::DropTicks = 40.0f;
 
 //#include <android/log.h>
 
-Gui::Gui(Minecraft* minecraft)
+// @todo virtual controlConfigurationChanged() when player switches from keyboard to touch for example 
-:	minecraft(minecraft),
+Gui::Gui(MinecraftClient& minecraft) : minecraft(minecraft), _openInventorySlot(minecraft.useTouchscreen()) {
-	tickCount(0),
-	progress(0),
-	overlayMessageTime(0),
-	animateOverlayMessageColor(false),
-	chatScrollOffset(0),
-	tbr(1),
-	_inventoryNeedsUpdate(true),
-	_flashSlotId(-1),
-	_flashSlotStartTime(-1),
-	_slotFont(NULL),
-	_numSlots(4),
-	_currentDropTicks(-1),
-	_currentDropSlot(-1),
-	MAX_MESSAGE_WIDTH(240),
-	itemNameOverlayTime(2),
-	_openInventorySlot(minecraft->useTouchscreen())
-{
 	glGenBuffers2(1, &_inventoryRc.vboId);
 	glGenBuffers2(1, &rcFeedbackInner.vboId);
 	glGenBuffers2(1, &rcFeedbackOuter.vboId);
 	//Gui::InvGuiScale = 1.0f / (int) (3 * Minecraft::width / 854);
 }
 
-Gui::~Gui()
+Gui::~Gui() {
-{
 	if (_slotFont)
 		delete _slotFont;
 
@@ -69,17 +54,16 @@ Gui::~Gui()
 }
 
 void Gui::render(float a, bool mouseFree, int xMouse, int yMouse) {
-
+	if (!minecraft.level || !minecraft.getPlayer())
-	if (!minecraft->level || !minecraft->player)
 		return;
 
 	//minecraft->gameRenderer->setupGuiScreen();
-	Font* font = minecraft->font;
+	Font* font = minecraft.getFont();
 
-	const bool isTouchInterface = minecraft->useTouchscreen();
+	const bool isTouchInterface = minecraft.useTouchscreen();
 	
-	const int screenWidth = (int)(minecraft->width * InvGuiScale);
+	const int screenWidth = (int)(minecraft.getScreenWidth() * InvGuiScale);
-	const int screenHeight = (int)(minecraft->height * InvGuiScale);
+	const int screenHeight = (int)(minecraft.getScreenHeigth() * InvGuiScale);
 	blitOffset = -90;
 	renderProgressIndicator(isTouchInterface, screenWidth, screenHeight, a);
 
@@ -91,9 +75,9 @@ void Gui::render(float a, bool mouseFree, int xMouse, int yMouse) {
     // F: 3
 	int ySlot = screenHeight - 16 - 3;
 
-	if (!minecraft->options.getBooleanValue(OPTIONS_HIDEGUI)) {
+	if (!minecraft.options.getBooleanValue(OPTIONS_HIDEGUI)) {
-		if (minecraft->gameMode->canHurtPlayer()) {
+		if (minecraft.gameMode->canHurtPlayer()) {
-			minecraft->textures->loadAndBindTexture("gui/icons.png");
+			minecraft.getTextures()->loadAndBindTexture("gui/icons.png");
 			Tesselator& t = Tesselator::instance;
 			t.beginOverride();
 			t.colorABGR(0xffffffff);
@@ -103,7 +87,7 @@ void Gui::render(float a, bool mouseFree, int xMouse, int yMouse) {
 		}
 	}
 
-	if(minecraft->player->getSleepTimer() > 0) {
+	if(minecraft.getPlayer()->getSleepTimer() > 0) {
 		glDisable(GL_DEPTH_TEST);
 		glDisable(GL_ALPHA_TEST);
 
@@ -112,7 +96,7 @@ void Gui::render(float a, bool mouseFree, int xMouse, int yMouse) {
 		glEnable(GL_ALPHA_TEST);
 		glEnable(GL_DEPTH_TEST);
 	}
-	if (!minecraft->options.getBooleanValue(OPTIONS_HIDEGUI)) {
+	if (!minecraft.options.getBooleanValue(OPTIONS_HIDEGUI)) {
 	renderToolBar(a, ySlot, screenWidth);
 
 	glEnable(GL_BLEND);
@@ -730,6 +714,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/Gui.h

@@ -10,7 +10,7 @@
 #include "../../util/Random.h"
 #include "../IConfigListener.h"
 
-class Minecraft;
+class MinecraftClient;
 class ItemInstance;
 class Textures;
 class Tesselator;
@@ -27,7 +27,7 @@ typedef std::vector<GuiMessage> GuiMessageList;
 class Gui: public GuiComponent, IConfigListener
 {
 public:
-    Gui(Minecraft* minecraft);
+    Gui(MinecraftClient& minecraft);
 	~Gui();
 
 	int getSlotIdAt(int x, int y);
@@ -90,43 +90,42 @@ private:
 	void tickItemDrop();
 	float cubeSmoothStep(float percentage, float min, float max);
 public:
-	float progress;
+	float progress = 0.f;
 	std::string selectedName;
 	static float InvGuiScale;
 	static float GuiScale;
 
 private:
-	int MAX_MESSAGE_WIDTH;
 	//ItemRenderer itemRenderer;
 	GuiMessageList guiMessages;
-	int chatScrollOffset;
+	int chatScrollOffset = 0;
 	Random random;
 
-	Minecraft* minecraft;
+	MinecraftClient& minecraft;
-	int tickCount;
+	int tickCount = 0;
-	float itemNameOverlayTime;
+	float itemNameOverlayTime = 2;
 	std::string overlayMessageString;
-	int overlayMessageTime;
+	int overlayMessageTime = 0;
-	bool animateOverlayMessageColor;
+	bool animateOverlayMessageColor = false;
 
-	float tbr;
+	float tbr = 1.f;
 
 	RenderChunk _inventoryRc;
-	bool _inventoryNeedsUpdate;
+	bool _inventoryNeedsUpdate = true;
 	
-	int _flashSlotId;
+	int _flashSlotId = -1;
-	float _flashSlotStartTime;
+	float _flashSlotStartTime = -1;
 
-	Font* _slotFont;
+	Font* _slotFont = nullptr;
-	int _numSlots;
+	int _numSlots = 4;
 
 	RenderChunk rcFeedbackOuter;
 	RenderChunk rcFeedbackInner;
 
 	// For dropping
 	static const float DropTicks;
-	float  _currentDropTicks;
+	float  _currentDropTicks = -1;
-	int    _currentDropSlot;
+	int    _currentDropSlot = -1;
 
 	bool   _openInventorySlot;
 };

src/client/gui/Screen.cpp

@@ -1,7 +1,7 @@
 #include "Screen.h"
 #include "components/Button.h"
 #include "components/TextBox.h"
-#include "../Minecraft.h"
+#include <Minecraft.h>
 #include "../renderer/Tesselator.h"
 #include "../sound/SoundEngine.h"
 #include "../../platform/input/Keyboard.h"

src/client/gui/components/RolledSelectionListH.cpp

@@ -1,14 +1,14 @@
 #include "RolledSelectionListH.h"
-#include "../../Minecraft.h"
 #include "../../renderer/Tesselator.h"
 #include "../../renderer/gles.h"
 #include "../../../platform/input/Mouse.h"
 #include "../../../platform/input/Multitouch.h"
 #include "../../../util/Mth.h"
 #include "../../renderer/Textures.h"
+#include "MinecraftClient.h"
 
 
-RolledSelectionListH::RolledSelectionListH( Minecraft* minecraft, int width, int height, int x0, int x1, int y0, int y1, int itemWidth )
+RolledSelectionListH::RolledSelectionListH( MinecraftClient& minecraft, int width, int height, int x0, int x1, int y0, int y1, int itemWidth )
 :	minecraft(minecraft),
 	width(width),
 	height(height),
@@ -172,7 +172,7 @@ void RolledSelectionListH::render( int xm, int ym, float a )
 
 	//LOGI("x: %f\n", xo);
 
-	minecraft->textures->loadAndBindTexture("gui/background.png");
+	minecraft.textures().loadAndBindTexture("gui/background.png");
 	glColor4f2(1.0f, 1, 1, 1);
 	float s = 32;
 	t.begin();
@@ -280,7 +280,7 @@ void RolledSelectionListH::render( int xm, int ym, float a )
 void RolledSelectionListH::renderHoleBackground( /*float x0, float x1,*/ float y0, float y1, int a0, int a1 )
 {
 	Tesselator& t = Tesselator::instance;
-	minecraft->textures->loadAndBindTexture("gui/background.png");
+	minecraft.textures().loadAndBindTexture("gui/background.png");
 	glColor4f2(1.0f, 1, 1, 1);
 	float s = 32;
 	t.begin();

src/client/gui/components/RolledSelectionListH.h

@@ -2,7 +2,7 @@
 #define NET_MINECRAFT_CLIENT_GUI_COMPONENTS__RolledSelectionListH_H__
 
 #include "../GuiComponent.h"
-class Minecraft;
+class MinecraftClient;
 class Tesselator;
 
 
@@ -12,7 +12,7 @@ class RolledSelectionListH : public GuiComponent
 	static const int DRAG_OUTSIDE	= -2;
 	static const int DRAG_NORMAL	=  0;
 public:
-	RolledSelectionListH(Minecraft* minecraft, int width, int height, int x0, int x1, int y0, int y1, int itemWidth);
+	RolledSelectionListH(MinecraftClient& minecraft, int width, int height, int x0, int x1, int y0, int y1, int itemWidth);
 
 	virtual int getItemAtPosition(int x, int y);
 
@@ -45,7 +45,7 @@ protected:
 	virtual void clickedHeader(int headerMouseX, int headerMouseY) {}
 	int getItemAtXPositionRaw(int x);
 protected:
-	Minecraft* minecraft;
+	MinecraftClient& minecraft;
 
 	float x0;
 	float x1;

src/client/gui/screens/ChestScreen.cpp

@@ -22,7 +22,7 @@
 
 //static NinePatchLayer* guiPaneFrame = NULL;
 
-static __inline void setIfNotSet(bool& ref, bool condition) {
+static inline void setIfNotSet(bool& ref, bool condition) {
 	ref = (ref || condition);
 }
 

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,33 +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);
-        minecraft->commandManager().execute(*minecraft, *minecraft->player, _input);
+        if (!result.empty())
+            minecraft->gui.addMessage(result);
     } 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(_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/IngameBlockSelectionScreen.cpp

@@ -9,7 +9,7 @@
 
 #include "../Gui.h"
 #include "../../renderer/Textures.h"
-#include "../../gamemode/GameMode.h"
+#include <gamemode/GameMode.h>
 #include "ArmorScreen.h"
 #include "../components/Button.h"
 

src/client/gui/screens/RenameMPLevelScreen.cpp

@@ -1,55 +0,0 @@
-#include "RenameMPLevelScreen.h"
-#include "StartMenuScreen.h"
-#include "DialogDefinitions.h"
-#include "../Gui.h"
-#include "../../Minecraft.h"
-#include "../../../AppPlatform.h"
-#include "../../../platform/log.h"
-#include "../../../world/level/storage/LevelStorageSource.h"
-
-
-static char ILLEGAL_FILE_CHARACTERS[] = {
-	'/', '\n', '\r', '\t', '\0', '\f', '`', '?', '*', '\\', '<', '>', '|', '\"', ':'
-};
-
-RenameMPLevelScreen::RenameMPLevelScreen( const std::string& levelId )
-:	_levelId(levelId)
-{
-}
-
-void RenameMPLevelScreen::init() {
-	minecraft->platform()->createUserInput(DialogDefinitions::DIALOG_RENAME_MP_WORLD);
-}
-
-void RenameMPLevelScreen::render(int xm, int ym, float a)
-{
-	renderBackground();
-
-	#ifdef WIN32
-		minecraft->getLevelSource()->renameLevel(_levelId, "Save?Level");
-		minecraft->screenChooser.setScreen(SCREEN_STARTMENU);
-	#else
-		int status = minecraft->platform()->getUserInputStatus();
-		if (status > -1) {
-			if (status == 1) {
-				std::vector<std::string> v = minecraft->platform()->getUserInput();
-
-				if (!v.empty()) {
-                    // Read the level name.
-					// 1) Trim name 2) Remove all bad chars -) We don't have to getUniqueLevelName, since renameLevel will do that
-					std::string levelId = v[0];
-
-					for (int i = 0; i < sizeof(ILLEGAL_FILE_CHARACTERS) / sizeof(char); ++i)
-						levelId = Util::stringReplace(levelId, std::string(1, ILLEGAL_FILE_CHARACTERS[i]), "");
-                    if ((int)levelId.length() == 0) {
-                        levelId = "saved_world";
-                    }
-
-					minecraft->getLevelSource()->renameLevel(_levelId, levelId);
-                }
-			}
-
-			minecraft->screenChooser.setScreen(SCREEN_STARTMENU);
-		}
-	#endif
-}

src/client/gui/screens/RenameMPLevelScreen.h

@@ -1,18 +0,0 @@
-#ifndef NET_MINECRAFT_CLIENT_GUI_SCREENS__RenameMPLevelScreen_H__
-#define NET_MINECRAFT_CLIENT_GUI_SCREENS__RenameMPLevelScreen_H__
-
-#include "../Screen.h"
-
-class RenameMPLevelScreen: public Screen
-{
-public:
-    RenameMPLevelScreen(const std::string& levelId);
-
-    virtual void init();
-	virtual void render(int xm, int ym, float a);
-
-private:
-    std::string _levelId;
-};
-
-#endif /*NET_MINECRAFT_CLIENT_GUI_SCREENS__RenameMPLevelScreen_H__*/

src/client/gui/screens/ScreenChooser.cpp

@@ -1,5 +1,6 @@
 #include "ScreenChooser.h"
 #include "StartMenuScreen.h"
+#include "MinecraftClient.h"
 #include "SelectWorldScreen.h"
 #include "JoinGameScreen.h"
 #include "PauseScreen.h"
@@ -58,6 +59,6 @@ Screen* ScreenChooser::createScreen( ScreenId id )
 Screen* ScreenChooser::setScreen(ScreenId id)
 {
 	Screen* screen = createScreen(id);
-	_mc->setScreen(screen);
+	_mc.setScreen(screen);
 	return screen;
 }

src/client/gui/screens/ScreenChooser.h

@@ -14,19 +14,17 @@ enum ScreenId {
 };
 
 class Screen;
-class Minecraft;
+class MinecraftClient;
 
 class ScreenChooser
 {
 public:
-	ScreenChooser(Minecraft* mc)
+	ScreenChooser(MinecraftClient& mc) : _mc(mc) {}
-	:	_mc(mc)
-	{}
 
 	Screen* createScreen(ScreenId id);
 	Screen* setScreen(ScreenId id);
 private:
-	Minecraft* _mc;
+	MinecraftClient& _mc;
 };
 
 #endif /*NET_MINECRAFT_CLIENT_GUI_SCREENS__ScreenChooser_H__*/

src/client/gui/screens/SelectWorldScreen.cpp

@@ -1,4 +1,5 @@
 #include "SelectWorldScreen.h"
+#include "MinecraftClient.h"
 #include "StartMenuScreen.h"
 #include "ProgressScreen.h"
 #include "DialogDefinitions.h"
@@ -22,7 +23,7 @@ static float Max(float a, float b) {
 //
 // World Selection List
 //
-WorldSelectionList::WorldSelectionList( Minecraft* minecraft, int width, int height )
+WorldSelectionList::WorldSelectionList( MinecraftClient& minecraft, int width, int height )
 :	_height(height),
 	hasPickedLevel(false),
 	currentTick(0),

src/client/gui/screens/SelectWorldScreen.h

@@ -5,11 +5,11 @@
 #include "../TweenData.h"
 #include "../components/Button.h"
 #include "../components/RolledSelectionListH.h"
-#include "../../Minecraft.h"
 #include "../../../world/level/storage/LevelStorageSource.h"
 
 
 class SelectWorldScreen;
+class MinecraftClient;
 
 //
 // Scrolling World selection list
@@ -17,7 +17,7 @@ class SelectWorldScreen;
 class WorldSelectionList : public RolledSelectionListH
 {
 public:
-	WorldSelectionList(Minecraft* _minecraft, int _width, int _height);
+	WorldSelectionList(MinecraftClient& _minecraft, int _width, int _height);
 	virtual void tick();
 	void stepLeft();
 	void stepRight();

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/gui/screens/touch/TouchIngameBlockSelectionScreen.cpp

@@ -3,7 +3,7 @@
 #include "../../Screen.h"
 #include "../../components/ImageButton.h"
 #include "../../components/InventoryPane.h"
-#include "../../../gamemode/GameMode.h"
+#include <gamemode/GameMode.h>
 #include "../../../renderer/TileRenderer.h"
 #include "../../../player/LocalPlayer.h"
 #include "../../../renderer/gles.h"
@@ -91,8 +91,7 @@ void IngameBlockSelectionScreen::init()
 	//for (int i = 0; i < inventory->getContainerSize(); ++i)
 		//LOGI("> %d - %s\n", i, inventory->getItem(i)? inventory->getItem(i)->getDescriptionId().c_str() : "<-->\n");
 
-	// Grid indices are 0..N-1 for main inventory only; slots 0..MAX_SELECTION_SIZE-1 are hotbar links.
+	InventorySize = inventory->getContainerSize();
-	InventorySize = inventory->getContainerSize() - Inventory::MAX_SELECTION_SIZE;
 	InventoryRows = 1 + (InventorySize-1) / InventoryColumns;
 
     //
@@ -266,8 +265,7 @@ void IngameBlockSelectionScreen::buttonClicked(Button* button) {
 
 bool IngameBlockSelectionScreen::isAllowed( int slot )
 {
-	const int gridCount = minecraft->player->inventory->getContainerSize() - Inventory::MAX_SELECTION_SIZE;
+	if (slot < 0 || slot >= minecraft->player->inventory->getContainerSize())
-	if (slot < 0 || slot >= gridCount)
 		return false;
 
 #ifdef DEMO_MODE

src/client/model/HumanoidModel.cpp

@@ -1,5 +1,5 @@
 #include "HumanoidModel.h"
-#include "../Minecraft.h"
+#include <Minecraft.h>
 #include "../../util/Mth.h"
 #include "../../world/entity/player/Player.h"
 #include "../../world/entity/player/Inventory.h"

src/client/player/LocalPlayer.cpp

@@ -1,6 +1,5 @@
 #include "LocalPlayer.h"
-#include "../Minecraft.h"
+#include <Minecraft.h>
-#include "../../ErrorCodes.h"
 #include "../../world/entity/EntityEvent.h"
 #include "../../world/entity/player/Player.h"
 #include "../../world/inventory/BaseContainerMenu.h"
@@ -35,7 +34,7 @@
 #include <errno.h>
 #endif
 
-#ifndef STANDALONE_SERVER
+
 #include "../gui/Screen.h"
 #include "../gui/screens/FurnaceScreen.h"
 #include "../gui/screens/ChestScreen.h"
@@ -44,13 +43,13 @@
 #include "../gui/screens/InBedScreen.h"
 #include "../gui/screens/TextEditScreen.h"
 #include "../particle/TakeAnimationParticle.h"
-#endif
 #include "../../network/packet/AnimatePacket.h"
 #include "../../world/item/ArmorItem.h"
 #include "../../network/packet/PlayerArmorEquipmentPacket.h"
+#include <MinecraftClient.h>
 
 namespace {
-#ifndef STANDALONE_SERVER
+
 
 static bool isBase64(unsigned char c) {
     return (std::isalnum(c) || (c == '+') || (c == '/'));
@@ -233,7 +232,7 @@ static bool fileExists(const std::string& path) {
 #endif
 }
 
-#ifndef STANDALONE_SERVER
+
 
 static void* fetchSkinForPlayer(void* param) {
     LocalPlayer* player = (LocalPlayer*)param;
@@ -345,33 +344,21 @@ static bool isJumpable(int tileId) {
 
 } // anonymous namespace
 
-LocalPlayer::LocalPlayer(Minecraft* minecraft, Level* level, const std::string& username, int dimension, bool isCreative)
+LocalPlayer::LocalPlayer(MinecraftClient& minecraft, Level* level, const std::string& username, int dimension, bool isCreative)
-:	Player(level, isCreative),
+:	Player(level, isCreative), minecraft(minecraft) {
-	minecraft(minecraft),
-	input(NULL),
-	sentInventoryItemId(-1),
-	sentInventoryItemData(-1),
-	autoJumpEnabled(true),
-	armorTypeHash(0),
-	sprinting(false),
-	sprintDoubleTapTimer(0),
-	prevForwardHeld(false)
-{
 	this->dimension = dimension;
 	_init();
-#ifndef STANDALONE_SERVER
 
-	if (minecraft->options.getStringValue(OPTIONS_USERNAME).size() != 0) {
+	if (minecraft.options().getStringValue(OPTIONS_USERNAME).size() != 0) {
 		textureName = "mob/char.png";
 
-		this->name = minecraft->options.getStringValue(OPTIONS_USERNAME);
+		this->name = minecraft.options().getStringValue(OPTIONS_USERNAME);
 		printf("test \n");
 		// Fetch user skin and cape from Mojang servers in the background (avoids blocking the main thread)
 		// TODO: Fix this memory leak
 		new CThread(fetchSkinForPlayer, this);
 		new CThread(fetchCapeForPlayer, this);
 	}
-#endif
 }
 
 LocalPlayer::~LocalPlayer() {
@@ -381,8 +368,8 @@ LocalPlayer::~LocalPlayer() {
 
 /*private*/
 void LocalPlayer::calculateFlight(float xa, float ya, float za) {
-	float flySpeed = minecraft->options.getProgressValue(OPTIONS_FLY_SPEED);
+	float flySpeed = minecraft.options().getProgressValue(OPTIONS_FLY_SPEED);
-	float sensivity = minecraft->options.getProgressValue(OPTIONS_SENSITIVITY);
+	float sensivity = minecraft.options().getProgressValue(OPTIONS_SENSITIVITY);
 
     xa = xa * flySpeed;
     ya = 0;
@@ -434,12 +421,12 @@ void LocalPlayer::tick() {
 			stopUsingItem();
 		}
 	}
-	if (minecraft->isOnline())
+	if (minecraft.isOnline())
 	{
 		if (std::abs(x - sentX) > .1f || std::abs(y - sentY) > .01f || std::abs(z - sentZ) > .1f || std::abs(sentRotX - xRot) > 1 || std::abs(sentRotY - yRot) > 1)
 		{
-			MovePlayerPacket packet(entityId, xxa, y - heightOffset, yya, xRot, yRot);
+			MovePlayerPacket packet(entityId, x, y - heightOffset, z, xRot, yRot);
-			minecraft->raknetInstance->send(packet);
+			minecraft.raknetInstance->send(packet);
 			sentX = x;
 			sentY = y;
 			sentZ = z;
@@ -456,8 +443,8 @@ 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);
+			minecraft.raknetInstance->send(packet);
 		}
 	}
 /*
@@ -472,15 +459,14 @@ void LocalPlayer::tick() {
 */
 
 	updateArmorTypeHash();
-#ifndef STANDALONE_SERVER
+	if (!minecraft.getScreen() && containerMenu) {
-	if (!minecraft->screen && containerMenu) {
 		static bool hasPostedError = false;
 		if (!hasPostedError) {
-			minecraft->gui.postError( ErrorCodes::ContainerRefStillExistsAfterDestruction );
+			// @todo
+			// minecraft.gui().postError( ErrorCodes::ContainerRefStillExistsAfterDestruction );
 			hasPostedError = true;
 		}
 	}
-#endif
 	//LOGI("biome: %s\n", level->getBiomeSource()->getBiome((int)x >> 4, (int)z >> 4)->name.c_str());
 }
 
@@ -491,15 +477,14 @@ void LocalPlayer::aiStep() {
 	descendTriggerTime--;
 
 	bool wasJumping = input->jumping;
-#ifndef STANDALONE_SERVER
+    bool screenCovering = minecraft.getScreen() && !minecraft.getScreen()->passEvents;
-    bool screenCovering = minecraft->screen && !minecraft->screen->passEvents;
 	if (!screenCovering)
 		input->tick(this);
 
 	// Sprint: detect W double-tap
 	{
 		bool forwardHeld = (input->ya > 0);
-		if (forwardHeld && !prevForwardHeld && minecraft->options.getBooleanValue(OPTIONS_ALLOW_SPRINT)) {
+		if (forwardHeld && !prevForwardHeld && minecraft.options().getBooleanValue(OPTIONS_ALLOW_SPRINT)) {
 			// leading edge of W press
 			if (sprintDoubleTapTimer > 0)
 				sprinting = true;
@@ -518,7 +503,7 @@ void LocalPlayer::aiStep() {
     if (input->sneaking) {
         if (ySlideOffset < 0.2f) ySlideOffset = 0.2f;
     }
-#endif
+
 	if (abilities.mayfly) {
 		// Check for flight toggle
 		if (!wasJumping && input->jumping) {
@@ -559,16 +544,16 @@ void LocalPlayer::aiStep() {
 void LocalPlayer::closeContainer() {
 	if (level->isClientSide) {
 		ContainerClosePacket packet(containerMenu->containerId);
-		minecraft->raknetInstance->send(packet);
+		minecraft.raknetInstance->send(packet);
 	}
 	super::closeContainer();
-    minecraft->setScreen(NULL);
+    minecraft.setScreen(NULL);
 }
 
 //@Override
 void LocalPlayer::move(float xa, float ya, float za) {
-    //@note: why is this == minecraft->player needed?
+    //@note: why is this == minecraft.player needed?
-    if (this == minecraft->player  && minecraft->options.getBooleanValue(OPTIONS_IS_FLYING)) {
+    if (this == minecraft.getPlayer()  && minecraft.options().getBooleanValue(OPTIONS_IS_FLYING)) {
         noPhysics = true;
         float tmp = walkDist; // update
         calculateFlight((float) xa, (float) ya, (float) za);
@@ -588,7 +573,7 @@ void LocalPlayer::move(float xa, float ya, float za) {
 
 		float newX = x, newZ = z;
 
-		if (autoJumpTime <= 0 && minecraft->options.getBooleanValue(OPTIONS_AUTOJUMP))
+		if (autoJumpTime <= 0 && minecraft.options().getBooleanValue(OPTIONS_AUTOJUMP))
 		{
 			// auto-jump when crossing the middle of a tile, and the tile in the front is blocked
 			bool jump = false;
@@ -617,12 +602,9 @@ void LocalPlayer::updateAi() {
     this->jumping = input->jumping || autoJumpTime > 0;
 }
 
-void LocalPlayer::take( Entity* e, int orgCount )
+void LocalPlayer::take( Entity* e, int orgCount ) {
-{
-#ifndef STANDALONE_SERVER
 	if (e->isItemEntity())
-		minecraft->particleEngine->add(new TakeAnimationParticle(minecraft->level, (ItemEntity*)e, this, -0.5f));
+		minecraft.getParticleEngine()->add(new TakeAnimationParticle(minecraft.level, (ItemEntity*)e, this, -0.5f));
-#endif
 }
 
 void LocalPlayer::setKey( int eventKey, bool eventKeyState )
@@ -684,28 +666,25 @@ void LocalPlayer::hurtTo( int newHealth )
 		lastHealth = health;
 		invulnerableTime = invulnerableDuration;
 
-		minecraft->player->bypassArmor = true;
+		minecraft.getPlayer()->bypassArmor = true;
 		actuallyHurt(dmg);
-		minecraft->player->bypassArmor = false;
+		minecraft.getPlayer()->bypassArmor = false;
 
 		hurtTime = hurtDuration = 10;
 	}
 }
 
-void LocalPlayer::actuallyHurt( int dmg )
+void LocalPlayer::actuallyHurt( int dmg ) {
-{
+    if (minecraft.getScreen() && minecraft.getScreen()->closeOnPlayerHurt()) {
-#ifndef STANDALONE_SERVER
-    if (minecraft->screen && minecraft->screen->closeOnPlayerHurt()) {
 		if (containerMenu) closeContainer();
-        else minecraft->setScreen(NULL);
+        else minecraft.setScreen(NULL);
 	}
-#endif
+
     super::actuallyHurt(dmg);
 }
 
-void LocalPlayer::respawn()
+void LocalPlayer::respawn() {
-{
+	minecraft.respawnPlayer();
-	minecraft->respawnPlayer();
 }
 
 void LocalPlayer::die(Entity* source)
@@ -714,7 +693,7 @@ void LocalPlayer::die(Entity* source)
 	// If we're the server, drop the inventory immediately
 	if (level->isClientSide) {
 		SendInventoryPacket packet(this, true);
-		minecraft->raknetInstance->send(packet);
+		minecraft.raknetInstance->send(packet);
 	}
 	inventory->dropAll(level->isClientSide);
 	for (int i = 0; i < NUM_ARMOR; ++i) {
@@ -735,7 +714,7 @@ void LocalPlayer::swing() {
         AnimatePacket packet(AnimatePacket::Swing, this);
         packet.reliability = UNRELIABLE;
         packet.priority = MEDIUM_PRIORITY;
-        minecraft->raknetInstance->send(packet);
+        minecraft.raknetInstance->send(packet);
     }
 }
 
@@ -758,31 +737,23 @@ void LocalPlayer::_init() {
 }
 
 void LocalPlayer::startCrafting(int x, int y, int z, int tableSize) {
-#ifndef STANDALONE_SERVER
+	if (!minecraft.isCreativeMode())
-	if (!minecraft->isCreativeMode())
+		minecraft.setScreen( new WorkbenchScreen(tableSize) );
-		minecraft->setScreen( new WorkbenchScreen(tableSize) );
-#endif
 }
 
 void LocalPlayer::startStonecutting(int x, int y, int z) {
-#ifndef STANDALONE_SERVER
+	if (!minecraft.isCreativeMode())
-	if (!minecraft->isCreativeMode())
+		minecraft.setScreen( new StonecutterScreen() );
-		minecraft->setScreen( new StonecutterScreen() );
-#endif
 }
 
 void LocalPlayer::openFurnace( FurnaceTileEntity* e ) {
-#ifndef STANDALONE_SERVER
+	if (!minecraft.isCreativeMode())
-	if (!minecraft->isCreativeMode())
+		minecraft.setScreen( new FurnaceScreen(this, e) );
-		minecraft->setScreen( new FurnaceScreen(this, e) );
-#endif
 }
 
 void LocalPlayer::openContainer( ChestTileEntity* container ) {
-#ifndef STANDALONE_SERVER
+	if (!minecraft.isCreativeMode())
-	if (!minecraft->isCreativeMode())
+		minecraft.setScreen( new ChestScreen(this, container) );
-		minecraft->setScreen( new ChestScreen(this, container) );
-#endif
 }
 
 void LocalPlayer::drop( ItemInstance* item, bool randomly )
@@ -792,7 +763,7 @@ void LocalPlayer::drop( ItemInstance* item, bool randomly )
 
 	if (level->isClientSide) {
 		DropItemPacket packet(entityId, *item);
-		minecraft->raknetInstance->send(packet);
+		minecraft.raknetInstance->send(packet);
 		// delete the ItemEntity here, since we don't add it to level
 		delete item;
 	} else {
@@ -806,7 +777,7 @@ void LocalPlayer::causeFallDamage( float distance )
 	if (dmg > 0) {
 		if (level->isClientSide) {
 			SetHealthPacket packet(SetHealthPacket::HEALTH_MODIFY_OFFSET + dmg);
-			minecraft->raknetInstance->send(packet);
+			minecraft.raknetInstance->send(packet);
 		}
 	}
 	super::causeFallDamage(distance);
@@ -814,35 +785,33 @@ void LocalPlayer::causeFallDamage( float distance )
 }
 
 void LocalPlayer::displayClientMessage( const std::string& messageId ) {
-#ifndef STANDALONE_SERVER
+	minecraft.gui().displayClientMessage(messageId);
-	minecraft->gui.displayClientMessage(messageId);
-#endif
 }
 
 int LocalPlayer::startSleepInBed( int x, int y, int z ) {
 	int startSleepInBedReturnValue = super::startSleepInBed(x, y, z);
-#ifndef STANDALONE_SERVER
+
 	if(startSleepInBedReturnValue == BedSleepingResult::OK)
-		minecraft->setScreen(new InBedScreen());
+		minecraft.setScreen(new InBedScreen());
-#endif
+
 	return startSleepInBedReturnValue;
 }
 
 void LocalPlayer::stopSleepInBed( bool forcefulWakeUp, bool updateLevelList, bool saveRespawnPoint ) {
 	if(level->isClientSide) {
 		PlayerActionPacket packet(PlayerActionPacket::STOP_SLEEPING, 0, 0, 0, 0, entityId);
-		minecraft->raknetInstance->send(packet);
+		minecraft.raknetInstance->send(packet);
 	}
-#ifndef STANDALONE_SERVER
+
-	minecraft->setScreen(NULL);
+	minecraft.setScreen(NULL);
-#endif
+
 	super::stopSleepInBed(forcefulWakeUp, updateLevelList, saveRespawnPoint);
 }
 
 void LocalPlayer::openTextEdit( TileEntity* tileEntity ) {
-#if !defined(STANDALONE_SERVER) && !defined(RPI)
+#if !defined(RPI)
 	if(tileEntity->type == TileEntityType::Sign)
-		minecraft->setScreen(new TextEditScreen((SignTileEntity*) tileEntity));
+		minecraft.setScreen(new TextEditScreen((SignTileEntity*) tileEntity));
 #endif
 }
 
@@ -850,7 +819,7 @@ void LocalPlayer::updateArmorTypeHash() {
     int hash = getArmorTypeHash();
     if (hash != armorTypeHash) {
         PlayerArmorEquipmentPacket p(this);
-        minecraft->raknetInstance->send(p);
+        minecraft.raknetInstance->send(p);
         armorTypeHash = hash;
     }
 }

src/client/player/LocalPlayer.h

@@ -7,7 +7,7 @@
 #include "../../util/SmoothFloat.h"
 #include "../../world/entity/player/Player.h"
 
-class Minecraft;
+class MinecraftClient;
 class Stat;
 class CompoundTag;
 
@@ -15,7 +15,7 @@ class LocalPlayer: public Player
 {
 	typedef Player super;
 public:
-	LocalPlayer(Minecraft* minecraft, Level* level, const std::string& username, int dimension, bool isCreative);
+	LocalPlayer(MinecraftClient& minecraft, Level* level, const std::string& username, int dimension, bool isCreative);
 	~LocalPlayer();
 
 	void _init();
@@ -74,10 +74,10 @@ private:
 	bool isSolidTile(int x, int y, int z);
 	void updateArmorTypeHash();
 public:
-	IMoveInput* input;
+	IMoveInput* input = nullptr;
-	bool autoJumpEnabled;
+	bool autoJumpEnabled = true;
 protected:
-	Minecraft* minecraft;
+	MinecraftClient& minecraft;
 	int jumpTriggerTime;
 	int ascendTriggerTime;
 	int descendTriggerTime;
@@ -94,15 +94,15 @@ private:
 
 	int autoJumpTime;
 
-	int sentInventoryItemId;
+	int sentInventoryItemId = -1;
-	int sentInventoryItemData;
+	int sentInventoryItemData = -1;
 
-	int armorTypeHash;
+	int armorTypeHash = 0;
 
 	// sprinting
-	bool sprinting;
+	bool sprinting = false;
-	int  sprintDoubleTapTimer;
+	int  sprintDoubleTapTimer = 0;
-	bool prevForwardHeld;
+	bool prevForwardHeld = false;
 public:
 	void setSprinting(bool sprint) { sprinting = sprint; }
 };

src/client/renderer/Color4.h

@@ -44,7 +44,7 @@ private:
 		range(b);
 		range(a);
 	}
-	__inline void range(GLfloat& v) {
+	inline void range(GLfloat& v) {
 		if (v < 0) v = 0;
 		if (v > 1) v = 1;
 	}

src/client/renderer/GameRenderer.cpp

@@ -9,7 +9,7 @@
 #include "culling/AllowAllCuller.h"
 #include "culling/FrustumCuller.h"
 #include "entity/EntityRenderDispatcher.h"
-#include "../Minecraft.h"
+#include <Minecraft.h>
 #include "../gamemode/GameMode.h"
 #include "../particle/ParticleEngine.h"
 #include "../player/LocalPlayer.h"

src/client/renderer/ItemInHandRenderer.cpp

@@ -5,7 +5,7 @@
 #include "entity/EntityRenderDispatcher.h"
 #include "entity/EntityRenderer.h"
 #include "entity/MobRenderer.h"
-#include "../Minecraft.h"
+#include <Minecraft.h>
 #include "../player/LocalPlayer.h"
 #include "../../world/entity/player/Player.h"
 #include "../../world/item/Item.h"

src/client/renderer/LevelRenderer.cpp

@@ -4,7 +4,7 @@
 #include "DistanceChunkSorter.h"
 #include "Chunk.h"
 #include "TileRenderer.h"
-#include "../Minecraft.h"
+#include <Minecraft.h>
 #include "../../util/Mth.h"
 #include "../../world/entity/player/Player.h"
 #include "../../world/level/tile/LevelEvent.h"

src/client/renderer/LevelRenderer.h

@@ -9,7 +9,7 @@
 #include "gles.h"
 #include <vector>
 
-class Minecraft;
+class MinecraftClient;
 class Textures;
 class Culler;
 class Chunk;
@@ -33,7 +33,7 @@ public:
     float zOld;
     float destroyProgress;
 
-	LevelRenderer(Minecraft* mc);
+	LevelRenderer(MinecraftClient& mc);
 	~LevelRenderer();
 
 	void setLevel(Level* level);
@@ -77,7 +77,7 @@ private:
 	void resortChunks(int xc, int yc, int zc);
 	void deleteChunks();
 	//void checkQueryResults(int from, int to);
-	__inline int getLinearCoord(int x, int y, int z) {
+	inline int getLinearCoord(int x, int y, int z) {
 		return (z * yChunks + y) * xChunks + x;
 	}
 	int noEntityRenderFrames;

src/client/renderer/RenderList.h

@@ -18,7 +18,7 @@ public:
 	void add(int list);
 	void addR(const RenderChunk& chunk);
 
-	__inline void next() { ++listIndex; }
+	inline void next() { ++listIndex; }
 
     void render();
 	void renderChunks();

src/client/renderer/Tesselator.h

@@ -72,18 +72,18 @@ public:
 
 	int getColor();
 
-	__inline void beginOverride() {
+	inline void beginOverride() {
 		begin();
 		voidBeginAndEndCalls(true);
 	}
-	__inline void endOverrideAndDraw() {
+	inline void endOverrideAndDraw() {
 		voidBeginAndEndCalls(false);
 		draw();
 	}
-	__inline bool isOverridden() {
+	inline bool isOverridden() {
 		return _voidBeginEnd;
 	}
-	__inline RenderChunk endOverride(int bufferId) {
+	inline RenderChunk endOverride(int bufferId) {
 		voidBeginAndEndCalls(false);
 		return end(true, bufferId);
 	}

src/client/renderer/Textures.cpp

@@ -4,34 +4,20 @@
 #include "ptexture/DynamicTexture.h"
 #include "../Options.h"
 #include "../../platform/time.h"
-#include "../../AppPlatform.h"
 #include "../../util/StringUtils.h"
 
 /*static*/ int  Textures::textureChanges = 0;
-/*static*/ bool Textures::MIPMAP = false;
-/*static*/ const TextureId Textures::InvalidId = -1;
 
-Textures::Textures( Options* options_, AppPlatform* platform_ )
+Textures::~Textures() {
-:	clamp(false),
-	blur(false),
-	options(options_),
-	platform(platform_),
-	lastBoundTexture(Textures::InvalidId)
-{
-}
-
-Textures::~Textures()
-{
 	clear();
 
 	for (unsigned int i = 0; i < dynamicTextures.size(); ++i)
 		delete dynamicTextures[i];
 }
 
-void Textures::clear()
+void Textures::clear() {
-{
 	for (TextureMap::iterator it = idMap.begin(); it != idMap.end(); ++it) {
-		if (it->second != Textures::InvalidId)
+		if (it->second != TEXTURES_INVALID_ID)
 			glDeleteTextures(1, &it->second);
 	}
 	for (TextureImageMap::iterator it = loadedImages.begin(); it != loadedImages.end(); ++it) {
@@ -41,7 +27,7 @@ void Textures::clear()
 	idMap.clear();
 	loadedImages.clear();
 
-	lastBoundTexture = Textures::InvalidId;
+	lastBoundTexture = TEXTURES_INVALID_ID;
 }
 
 TextureId Textures::loadAndBindTexture( const std::string& resourceName )
@@ -51,7 +37,7 @@ TextureId Textures::loadAndBindTexture( const std::string& resourceName )
 	//t.start();
 	TextureId id = loadTexture(resourceName);
 	//t.stop();
-	if (id != Textures::InvalidId)
+	if (id != TEXTURES_INVALID_ID)
 		bind(id);
 
 	//t.printEvery(1000);
@@ -59,25 +45,24 @@ TextureId Textures::loadAndBindTexture( const std::string& resourceName )
 	return id;
 }
 
-TextureId Textures::loadTexture( const std::string& resourceName, bool inTextureFolder /* = true */ )
+TextureId Textures::loadTexture(const std::string& resourceName, bool inTextureFolder) {
-{
 	TextureMap::iterator it = idMap.find(resourceName);
 	if (it != idMap.end())
 		return it->second;
 
 	bool isUrl = Util::startsWith(resourceName, "http://") || Util::startsWith(resourceName, "https://");
-	TextureData texdata = platform->loadTexture(resourceName, isUrl ? false : inTextureFolder);
+	TextureData texdata = m_platform.loadTexture(resourceName, isUrl ? false : inTextureFolder);
 	if (texdata.data)
 		return assignTexture(resourceName, texdata);
-    else if (texdata.identifier != InvalidId) {
+    else if (texdata.identifier != TEXTURES_INVALID_ID) {
         //LOGI("Adding id: %d for %s\n", texdata.identifier, resourceName.c_str());
 		idMap.insert(std::make_pair(resourceName, texdata.identifier));
     }
 	else {
-		idMap.insert(std::make_pair(resourceName, Textures::InvalidId));
+		idMap.insert(std::make_pair(resourceName, TEXTURES_INVALID_ID));
 		//loadedImages.insert(std::make_pair(InvalidId, texdata));
 	}
-	return Textures::InvalidId;
+	return TEXTURES_INVALID_ID;
 }
 
 TextureId Textures::assignTexture( const std::string& resourceName, const TextureData& img )
@@ -87,13 +72,14 @@ TextureId Textures::assignTexture( const std::string& resourceName, const Textur
 
 	bind(id);
 
-	if (MIPMAP) {
+#ifdef TEXTURES_MIPMAP
 		glTexParameteri2(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
 		glTexParameteri2(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-	} else {
+#else
 		glTexParameteri2(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
 		glTexParameteri2(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-	}
+#endif
+
 	if (blur) {
 		glTexParameteri2(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
 		glTexParameteri2(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

src/client/renderer/Textures.h

@@ -6,9 +6,13 @@
 #include <string>
 #include <map>
 #include <utility>
+#include <IPlatform.h>
 #include "gles.h"
 #include "TextureData.h"
 
+#define TEXTURES_INVALID_ID -1
+#define TEXTURES_MIPMAP 0
+
 class DynamicTexture;
 class Options;
 class AppPlatform;
@@ -24,20 +28,21 @@ typedef std::map<TextureId, TextureData> TextureImageMap;
 class Textures
 {
 public:
-    Textures(Options* options_,  AppPlatform* platform_);
+    Textures(Options& options, IPlatform& platform) : m_options(options), m_platform(platform) {}
 	~Textures();
 
 	void addDynamicTexture(DynamicTexture* dynamicTexture);
 
-	__inline void bind(TextureId id) {
+	inline void bind(TextureId id) {
-		if (id != Textures::InvalidId && lastBoundTexture != id) {
+		if (id != TEXTURES_INVALID_ID && lastBoundTexture != id) {
 			glBindTexture2(GL_TEXTURE_2D, id);
 			lastBoundTexture = id;
 			++textureChanges;
-		} else if (id == Textures::InvalidId){
+		} else if (id == TEXTURES_INVALID_ID){
             LOGI("invalidId!\n");
         }
 	}
+
 	TextureId loadTexture(const std::string& resourceName, bool inTextureFolder = true);
 	TextureId loadAndBindTexture(const std::string& resourceName);
 
@@ -49,28 +54,26 @@ public:
 	void clear();
 	void reloadAll();
 
-	__inline static bool isTextureIdValid(TextureId t) { return t != Textures::InvalidId; }
+	inline static bool isTextureIdValid(TextureId t) { return t != TEXTURES_INVALID_ID; }
 
 private:
 	int smoothBlend(int c0, int c1);
 	int crispBlend(int c0, int c1);
 
 public:
-	static bool MIPMAP;
 	static int textureChanges;
-	static const TextureId InvalidId;
 
 private:
 	TextureMap idMap;
 	TextureImageMap loadedImages;
 
-	Options* options;
+	Options& m_options;
-	AppPlatform* platform;
+	IPlatform& m_platform;
 
-	bool clamp;
+	bool clamp = false;
-	bool blur;
+	bool blur = false;
 
-	int lastBoundTexture;
+	int lastBoundTexture = TEXTURES_INVALID_ID;
 	std::vector<DynamicTexture*> dynamicTextures;
 };
 

src/client/renderer/TileRenderer.cpp

@@ -1,6 +1,6 @@
 #include "TileRenderer.h"
 #include "Chunk.h"
-#include "../Minecraft.h"
+#include <Minecraft.h>
 #include "Tesselator.h"
 
 #include "../../world/level/LevelSource.h"

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/SoundEngine.cpp

@@ -1,6 +1,6 @@
 #include "SoundEngine.h"
 #include "../Options.h"
-#include "../Minecraft.h"
+#include <Minecraft.h>
 #include "../../world/entity/Mob.h"
 
 

src/client/sound/SoundEngine.mm

@@ -1,6 +1,6 @@
 #include "SoundEngine.h"
 #include "../Options.h"
-#include "../Minecraft.h"
+#include <Minecraft.h>
 #include "../../world/entity/Mob.h"
 
 /*

src/commands/Command.cpp

@@ -1,7 +0,0 @@
-#include "Command.hpp"
-#include "world/level/Level.h"
-#include <client/Minecraft.h>
-
-bool Command::isPlayerOp(Minecraft& mc, Player& player) {
-    return mc.level->ops.find(player.name) != 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 void execute(Minecraft& mc, Player& player, const std::vector<std::string>& args) = 0;
-    virtual void printHelp(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/CommandHelp.cpp

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

src/commands/CommandHelp.hpp

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

src/commands/CommandKick.cpp

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

src/commands/CommandKick.hpp

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

src/commands/CommandManager.cpp

@@ -1,73 +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 "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());
-}
-
-std::vector<std::string> CommandManager::getListAllCommands() {
-    std::vector<std::string> ret;
-
-    for (auto& cmd : m_commands) {
-        ret.push_back(cmd->getName());
-    }
-
-    return ret;
-}
-
-void 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 mc.addMessage("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) {
-        (*it)->execute(mc, player, args);
-    } else {
-        ChatPacket packet("/" + input);
-        mc.raknetInstance->send(packet);
-    }
-}
-
-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();
-
-    void 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,35 +0,0 @@
-#include "CommandOp.hpp"
-#include "commands/Command.hpp"
-#include "network/RakNetInstance.h"
-#include "raknet/RakPeer.h"
-#include "world/level/Level.h"
-#include <algorithm>
-#include <client/Minecraft.h>
-
-
-CommandOp::CommandOp() : Command("op") {}
-
-void CommandOp::execute(Minecraft& mc, Player& player, const std::vector<std::string>& args) {
-    if (!isPlayerOp(mc, player)) {
-        return mc.addMessage("You aren't enough priveleged to run this command");
-    }
-    
-    if (args.empty()) {
-        return printHelp(mc);
-    }
-
-    auto it = std::find_if(mc.level->players.begin(), mc.level->players.end(), [args] (auto& it) -> bool {
-        return it->name == args[0];
-    });
-
-    if (mc.level->ops.find(args[0]) != mc.level->ops.end()) {
-        return mc.addMessage("op: player " + args[0] + " already opped");
-    }
-
-    mc.level->ops.emplace((*it)->name);
-    mc.addMessage("op: successfully opped player " + args[0]);
-}
-
-void CommandOp::printHelp(Minecraft& mc) {
-    mc.addMessage("Usage: /op <player>");
-}

src/commands/CommandOp.hpp

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

src/gamemode/CreativeMode.cpp

@@ -0,0 +1,59 @@
+#include "CreativeMode.h"
+#include <Minecraft.h>
+#include <world/level/Level.h>
+#include <world/entity/player/Abilities.h>
+
+static const int DestructionTickDelay = 5;
+
+CreativeMode::CreativeMode(Minecraft& minecraft)
+: 	super(minecraft)
+{
+}
+
+void CreativeMode::startDestroyBlock(Player* player, int x, int y, int z, int face) {
+	if(player->getCarriedItem() != NULL && player->getCarriedItem()->id == Item::bow->id)
+		return;
+
+	creativeDestroyBlock(player, x, y, z, face);
+	destroyDelay = DestructionTickDelay;
+}
+
+void CreativeMode::creativeDestroyBlock(Player* player, int x, int y, int z, int face) {
+	minecraft.level->extinguishFire(x, y, z, face);
+	destroyBlock(player, x, y, z, face);
+}
+
+void CreativeMode::continueDestroyBlock(Player* player, int x, int y, int z, int face) {
+	destroyDelay--;
+	if (destroyDelay <= 0) {
+		destroyDelay = DestructionTickDelay;
+		creativeDestroyBlock(player, x, y, z, face);
+	}
+}
+
+void CreativeMode::stopDestroyBlock(Player* player) {
+	destroyDelay = 0;
+}
+
+void CreativeMode::initAbilities( Abilities& abilities ) {
+	abilities.mayfly = true;
+	abilities.instabuild = true;
+	abilities.invulnerable = true;
+}
+
+bool CreativeMode::isCreativeType() {
+	return true;
+}
+
+void CreativeMode::releaseUsingItem( Player* player ) {
+	if(player->getCarriedItem() != NULL) {
+		int oldItemId = player->getCarriedItem()->id;
+		int oldAux = player->getAuxData();
+		super::releaseUsingItem(player);
+		if(player->getCarriedItem() != NULL && player->getCarriedItem()->id == oldItemId) {
+			player->getCarriedItem()->setAuxValue(oldAux);
+		}
+	} else {
+		super::releaseUsingItem(player);
+	}
+}

src/gamemode/CreativeMode.h

@@ -9,18 +9,19 @@ class CreativeMode: public GameMode
 {
 	typedef GameMode super;
 public:
-    CreativeMode(Minecraft* minecraft);
+    CreativeMode(Minecraft& minecraft);
 
-    void startDestroyBlock(int x, int y, int z, int face);
+    void startDestroyBlock(Player* player, int x, int y, int z, int face);
-    void continueDestroyBlock(int x, int y, int z, int face);
+    void continueDestroyBlock(Player* player, int x, int y, int z, int face);
-    void stopDestroyBlock();
+    void stopDestroyBlock(Player* player);
 
 	bool isCreativeType();
 
 	void initAbilities(Abilities& abilities);
 
+	void releaseUsingItem(Player* player);
 private:
-	void creativeDestroyBlock(int x, int y, int z, int face);
+	void creativeDestroyBlock(Player* player, int x, int y, int z, int face);
 };
 
 #endif /*NET_MINECRAFT_CLIENT_GAMEMODE__CreativeMode_H__*/

src/gamemode/CreatorMode.cpp

@@ -0,0 +1,111 @@
+#include "CreatorMode.h"
+#include "world/entity/player/Player.h"
+#include "world/level/Level.h"
+#include <Minecraft.h>
+#include <world/entity/player/Abilities.h>
+
+static const int DestructionTickDelay = 5;
+
+class Creator: public ICreator {
+	//virtual void getEvents();
+
+public:
+	Creator(/*int eventLifeTime*/)
+	:	_tileEvents(32),
+		_tickId(0)
+	{
+	}
+
+	void setTick(int tick) {
+		_tickId = tick;
+	}
+
+	EventList<TileEvent>& getTileEvents() { return _tileEvents; }
+
+	void addevent_blockUse(int entityId, int x, int y, int z, int face) {
+		TileEvent t = {
+			entityId,
+			x,y,z,
+			face
+		};
+		_tileEvents.add(t, _tickId);
+	}
+
+private:
+	EventList<TileEvent> _tileEvents;
+	int _tickId;
+};
+
+CreatorMode::CreatorMode(Minecraft& minecraft)
+:	super(minecraft)
+{
+	_creator = new Creator();
+}
+
+CreatorMode::~CreatorMode() {
+	delete _creator;
+}
+
+void CreatorMode::startDestroyBlock(Player* player, int x, int y, int z, int face) {
+	if(player->getCarriedItem() != NULL && player->getCarriedItem()->id == Item::bow->id)
+		return;
+
+	CreatorDestroyBlock(player, x, y, z, face);
+	destroyDelay = DestructionTickDelay;
+}
+
+void CreatorMode::CreatorDestroyBlock(Player* player, int x, int y, int z, int face) {
+	minecraft.level->extinguishFire(x, y, z, face);
+	destroyBlock(player, x, y, z, face);
+
+}
+
+void CreatorMode::continueDestroyBlock(Player* player, int x, int y, int z, int face) {
+	destroyDelay--;
+	if (destroyDelay <= 0) {
+		destroyDelay = DestructionTickDelay;
+		CreatorDestroyBlock(player, x, y, z, face);
+	}
+}
+
+bool CreatorMode::useItemOn(Player* player, Level* level, ItemInstance* item, int x, int y, int z, int face, const Vec3& hit ) {
+	if (item && item->id == ((Item*)Item::sword_iron)->id)
+		_creator->addevent_blockUse(player->entityId, x, y, z, face);
+	return super::useItemOn(player, level, item, x, y, z, face, hit);
+}
+
+void CreatorMode::stopDestroyBlock(Player* player) {
+	destroyDelay = 0;
+}
+
+void CreatorMode::initAbilities( Abilities& abilities ) {
+	abilities.mayfly = true;
+	abilities.instabuild = true;
+	abilities.invulnerable = true;
+}
+
+bool CreatorMode::isCreativeType() {
+	return true;
+}
+
+void CreatorMode::releaseUsingItem( Player* player ) {
+	if(player->getCarriedItem() != NULL) {
+		int oldItemId = player->getCarriedItem()->id;
+		int oldAux = player->getAuxData();
+		super::releaseUsingItem(player);
+		if(player->getCarriedItem() != NULL && player->getCarriedItem()->id == oldItemId) {
+			player->getCarriedItem()->setAuxValue(oldAux);
+		}
+	} else {
+		super::releaseUsingItem(player);
+	}
+}
+
+ICreator* CreatorMode::getCreator() {
+	return _creator;
+}
+
+void CreatorMode::tick() {
+	_creator->setTick(minecraft.level->getTime());
+	super::tick();
+}

src/gamemode/CreatorMode.h

@@ -4,7 +4,7 @@
 //package net.minecraft.client.gamemode;
 
 #include "GameMode.h"
-#include "../../world/PosTranslator.h"
+#include <world/PosTranslator.h>
 
 class ICreator {
 public:
@@ -102,12 +102,12 @@ class CreatorMode: public GameMode
 {
 	typedef GameMode super;
 public:
-    CreatorMode(Minecraft* minecraft);
+    CreatorMode(Minecraft& minecraft);
 	~CreatorMode();
 
-    void startDestroyBlock(int x, int y, int z, int face);
+    void startDestroyBlock(Player* player, int x, int y, int z, int face);
-    void continueDestroyBlock(int x, int y, int z, int face);
+    void continueDestroyBlock(Player* player, int x, int y, int z, int face);
-    void stopDestroyBlock();
+    void stopDestroyBlock(Player* player);
 
 	bool useItemOn(Player* player, Level* level, ItemInstance* item, int x, int y, int z, int face, const Vec3& hit);
 
@@ -118,8 +118,9 @@ public:
 
 	void initAbilities(Abilities& abilities);
 
+	void releaseUsingItem(Player* player);
 private:
-	void CreatorDestroyBlock(int x, int y, int z, int face);
+	void CreatorDestroyBlock(Player* player, int x, int y, int z, int face);
 
 	Creator* _creator;
 };

src/gamemode/GameMode.cpp

@@ -1,35 +1,15 @@
 #include "GameMode.h"
-#include "../Minecraft.h"
+#include <Minecraft.h>
-#include "../../network/packet/UseItemPacket.h"
+#include <network/packet/UseItemPacket.h>
-#include "../../network/packet/PlayerActionPacket.h"
+#include <network/packet/PlayerActionPacket.h>
-#include "../../world/level/Level.h"
+#include <world/level/Level.h>
-#include "../../world/item/ItemInstance.h"
+#include <world/item/ItemInstance.h>
-#include "../player/LocalPlayer.h"
+#include <client/player/LocalPlayer.h>
-#include "client/Options.h"
+#include <client/Options.h>
-#ifndef STANDALONE_SERVER
+#include <network/RakNetInstance.h>
-#include "../sound/SoundEngine.h"
+#include <network/packet/RemoveBlockPacket.h>
-#include "../particle/ParticleEngine.h"
+#include <world/level/material/Material.h>
-#endif
-#include "../../network/RakNetInstance.h"
-#include "../../network/packet/RemoveBlockPacket.h"
-#ifndef STANDALONE_SERVER
-#include "../renderer/LevelRenderer.h"
-#endif
-#include "../../world/level/material/Material.h"
 
-GameMode::GameMode( Minecraft* minecraft)
-:	minecraft(minecraft),
-	destroyProgress(0),
-	oDestroyProgress(0),
-	destroyTicks(0),
-	destroyDelay(0)
-{
-}
-
-/*virtual*/
-Player* GameMode::createPlayer(Level* level) {
-    return new LocalPlayer(minecraft, level, minecraft->options.getStringValue(OPTIONS_USERNAME), level->dimension->id, isCreativeType());
-}
 
 /*virtual*/
 void GameMode::interact(Player* player, Entity* entity) {
@@ -38,23 +18,24 @@ void GameMode::interact(Player* player, Entity* entity) {
 
 /*virtual*/
 void GameMode::attack(Player* player, Entity* entity) {
-	if (minecraft->level->adventureSettings.noPvP && entity->isPlayer())
+	if (minecraft.level->adventureSettings.noPvP && entity->isPlayer())
 		return;
-	if (minecraft->level->adventureSettings.noPvM && entity->isMob())
+	if (minecraft.level->adventureSettings.noPvM && entity->isMob())
 		return;
     player->attack(entity);
 }
 
 /* virtual */
-void GameMode::startDestroyBlock( int x, int y, int z, int face ) {
+void GameMode::startDestroyBlock(Player* player, int x, int y, int z, int face ) {
-	if(minecraft->player->getCarriedItem() != NULL && minecraft->player->getCarriedItem()->id == Item::bow->id)
+	if(player->getCarriedItem() != NULL && player->getCarriedItem()->id == Item::bow->id)
 		return;
-	destroyBlock(x, y, z, face);
+
+	destroyBlock(player, x, y, z, face);
 }
 
 /*virtual*/
-bool GameMode::destroyBlock(int x, int y, int z, int face) {
+bool GameMode::destroyBlock(Player* player, int x, int y, int z, int face) {
-    Level* level = minecraft->level;
+    Level* level = minecraft.level;
     Tile* oldTile = Tile::tiles[level->getTile(x, y, z)];
 	if (!oldTile)
 		return false;
@@ -65,22 +46,12 @@ bool GameMode::destroyBlock(int x, int y, int z, int face) {
              return false;
         }
     }
-#ifndef STANDALONE_SERVER
+
-	minecraft->particleEngine->destroy(x, y, z);
-#endif
 	int data = level->getData(x, y, z);
     bool changed = level->setTile(x, y, z, 0);
     if (changed) {
-#ifndef STANDALONE_SERVER
-        minecraft->soundEngine->play(oldTile->soundType->getBreakSound(), x + 0.5f, y + 0.5f, z + 0.5f, (oldTile->soundType->getVolume() + 1) / 2, oldTile->soundType->getPitch() * 0.8f);
-#endif
         oldTile->destroy(level, x, y, z, data);
-		if (minecraft->options.getBooleanValue(OPTIONS_DESTROY_VIBRATION)) minecraft->platform()->vibrate(24);
+		minecraft.onBlockDestroyed(player, x, y, z, face);
-
-		if (minecraft->isOnline()) {
-			RemoveBlockPacket packet(minecraft->player, x, y, z);
-			minecraft->raknetInstance->send(packet);
-		}
 	}
     return changed;
 }
@@ -89,10 +60,10 @@ bool GameMode::useItemOn(Player* player, Level* level, ItemInstance* item, int x
 	float clickX = hit.x - x;
 	float clickY = hit.y - y;
 	float clickZ = hit.z - z;
-	if (level->isClientSide) {
+	item = player->inventory->getSelected();
-		item = player->inventory->getSelected();
+	if(level->isClientSide) {
 		UseItemPacket packet(x, y, z, face, item, player->entityId, clickX, clickY, clickZ);
-		minecraft->raknetInstance->send(packet);
+		minecraft.raknetInstance->send(packet);
 	}
     int t = level->getTile(x, y, z);
 	if (t == Tile::invisible_bedrock->id) return false;
@@ -118,7 +89,7 @@ bool GameMode::useItem( Player* player, Level* level, ItemInstance* item ) {
 	ItemInstance* itemInstance = item->use(level, player);
 	if(level->isClientSide) {
 		UseItemPacket packet(item, player->entityId, player->aimDirection);
-		minecraft->raknetInstance->send(packet);
+		minecraft.raknetInstance->send(packet);
 	}
 	if (itemInstance != item || (itemInstance != NULL && itemInstance->count != oldCount)) {
 	    //player.inventory.items[player.inventory.selected] = itemInstance;
@@ -149,9 +120,9 @@ void GameMode::initPlayer( Player* player ) {
 }
 
 void GameMode::releaseUsingItem(Player* player){
-	if (minecraft->level->isClientSide && player->isUsingItem()) {
+	if(minecraft.level->isClientSide) {
 		PlayerActionPacket packet(PlayerActionPacket::RELEASE_USE_ITEM,  0, 0, 0, 0, player->entityId);
-		minecraft->raknetInstance->send(packet);
+		minecraft.raknetInstance->send(packet);
 	}
 	player->releaseUsingItem();
 }
@@ -160,15 +131,3 @@ void GameMode::tick() {
 	oDestroyProgress = destroyProgress;
 }
 
-void GameMode::render( float a ) {
-#ifndef STANDALONE_SERVER
-	if (destroyProgress <= 0) {
-		minecraft->gui.progress = 0;
-		minecraft->levelRenderer->destroyProgress = 0;
-	} else {
-		float dp = oDestroyProgress + (destroyProgress - oDestroyProgress) * a;
-		minecraft->gui.progress = dp;
-		minecraft->levelRenderer->destroyProgress = dp;
-	}
-#endif
-}

src/gamemode/GameMode.h

@@ -3,7 +3,7 @@
 
 //package net.minecraft.client.gamemode;
 
-#include "../../world/level/tile/Tile.h"
+#include <world/level/tile/Tile.h>
 
 class ItemInstance;
 class Minecraft;
@@ -11,23 +11,22 @@ class Level;
 class Player;
 class Abilities;
 
-class GameMode
+class GameMode {
-{
 protected:
-	Minecraft* minecraft;
+	Minecraft& minecraft;
+
 public:
-    GameMode(Minecraft* minecraft);
+    GameMode(Minecraft& minecraft) : minecraft(minecraft) {}
 	virtual ~GameMode() {}
 
     virtual void initLevel(Level* level) {}
 
-    virtual void startDestroyBlock(int x, int y, int z, int face);
+    virtual void startDestroyBlock(Player* player, int x, int y, int z, int face);
-    virtual bool destroyBlock(int x, int y, int z, int face);
+    virtual bool destroyBlock(Player* player, int x, int y, int z, int face);
-    virtual void continueDestroyBlock(int x, int y, int z, int face) = 0;
+    virtual void continueDestroyBlock(Player* player, int x, int y, int z, int face) = 0;
-    virtual void stopDestroyBlock() {}
+    virtual void stopDestroyBlock(Player* player) {}
 
     virtual void tick();
-    virtual void render(float a);
 
     virtual float getPickRange();
     /* void postLevelGen(LevelGen levelGen, Level level) {} */
@@ -35,7 +34,6 @@ public:
     virtual bool useItem(Player* player, Level* level, ItemInstance* item);
     virtual bool useItemOn(Player* player, Level* level, ItemInstance* item, int x, int y, int z, int face, const Vec3& hit);
 
-	virtual Player* createPlayer(Level* level);
     virtual void initPlayer(Player* player);
     virtual void adjustPlayer(Player* player) {}
     virtual bool canHurtPlayer() { return false; }
@@ -53,11 +51,11 @@ public:
 
 	virtual void releaseUsingItem(Player* player);
 
-	float oDestroyProgress;
+	float oDestroyProgress = 0;
-	float destroyProgress;
+	float destroyProgress = 0;
 protected:
-	int destroyTicks;
+	int destroyTicks = 0;
-	int destroyDelay;
+	int destroyDelay = 0;
 };
 
 #endif /*NET_MINECRAFT_CLIENT_GAMEMODE__GameMode_H__*/

src/gamemode/SurvivalMode.cpp

@@ -0,0 +1,93 @@
+#include "SurvivalMode.h"
+#include <Minecraft.h>
+#include <world/level/Level.h>
+#include <world/entity/player/Abilities.h>
+
+SurvivalMode::SurvivalMode( Minecraft& minecraft )
+:	super(minecraft),
+	xDestroyBlock(-1),
+	yDestroyBlock(-1),
+	zDestroyBlock(-1)
+{
+}
+
+void SurvivalMode::continueDestroyBlock(Player* player, int x, int y, int z, int face ) {
+	if (destroyDelay > 0) {
+		destroyDelay--;
+		return;
+	}
+
+	if (x == xDestroyBlock && y == yDestroyBlock && z == zDestroyBlock) {
+		int t = minecraft.level->getTile(x, y, z);
+		if (t == 0) return;
+		Tile* tile = Tile::tiles[t];
+
+		destroyProgress += tile->getDestroyProgress(player);
+
+		if ((++destroyTicks & 3) == 1) {
+#ifndef STANDALONE_SERVER
+			if (tile != NULL) {
+				minecraft->soundEngine->play(tile->soundType->getStepSound(), x + 0.5f, y + 0.5f, z + 0.5f, (tile->soundType->getVolume() + 1) / 8, tile->soundType->getPitch() * 0.5f);
+			}
+#endif
+		}
+
+		if (destroyProgress >= 1) {
+			destroyBlock(player, x, y, z, face);
+			destroyProgress = 0;
+			oDestroyProgress = 0;
+			destroyTicks = 0;
+			destroyDelay = 5;
+		}
+	} else {
+		destroyProgress = 0;
+		oDestroyProgress = 0;
+		destroyTicks = 0;
+		xDestroyBlock = x;
+		yDestroyBlock = y;
+		zDestroyBlock = z;
+	}
+}
+
+bool SurvivalMode::destroyBlock(Player* player, int x, int y, int z, int face ) {
+	int t = minecraft.level->getTile(x, y, z);
+	int data = minecraft.level->getData(x, y, z);
+	bool changed = GameMode::destroyBlock(player, x, y, z, face);
+	bool couldDestroy = player->canDestroy(Tile::tiles[t]);
+
+	ItemInstance* item = player->inventory->getSelected();
+	if (item != NULL) {
+		item->mineBlock(t, x, y, z);
+		if (item->count == 0) {
+			//item->snap(minecraft->player);
+			player->inventory->clearSlot(player->inventory->selected);
+		}
+	}
+	if (changed && couldDestroy) {
+		ItemInstance instance(t, 1, data);
+		Tile::tiles[t]->playerDestroy(minecraft.level, player, x, y, z, data);
+	}
+	return changed;
+}
+
+void SurvivalMode::stopDestroyBlock(Player* player) {
+	destroyProgress = 0;
+	destroyDelay = 0;
+}
+
+void SurvivalMode::initAbilities( Abilities& abilities ) {
+	abilities.flying = false;
+	abilities.mayfly = false;
+	abilities.instabuild = false;
+	abilities.invulnerable = false;
+}
+
+void SurvivalMode::startDestroyBlock(Player* player, int x, int y, int z, int face ) {
+	if(player->getCarriedItem() != NULL && player->getCarriedItem()->id == Item::bow->id)
+		return;
+
+	int t = minecraft.level->getTile(x, y, z);
+	if (t > 0 && destroyProgress == 0) Tile::tiles[t]->attack(minecraft.level, x, y, z, player);
+	if (t > 0 && Tile::tiles[t]->getDestroyProgress(player) >= 1)
+		destroyBlock(player, x, y, z, face);
+}

src/gamemode/SurvivalMode.h

@@ -10,12 +10,12 @@ class SurvivalMode: public GameMode
 {
 	typedef GameMode super;
 public:
-	SurvivalMode(Minecraft* minecraft);
+	SurvivalMode(Minecraft& minecraft);
 
-	bool destroyBlock(int x, int y, int z, int face);
+	bool destroyBlock(Player* player, int x, int y, int z, int face);
-	void startDestroyBlock(int x, int y, int z, int face);
+	void startDestroyBlock(Player* player, int x, int y, int z, int face);
-	void continueDestroyBlock(int x, int y, int z, int face);
+	void continueDestroyBlock(Player* player, int x, int y, int z, int face);
-	void stopDestroyBlock();
+	void stopDestroyBlock(Player* player);
 
 	bool canHurtPlayer() { return true; }
 

src/locale/I18n.cpp

@@ -1,6 +1,6 @@
 #include "I18n.h"
 #include <sstream>
-#include "../AppPlatform.h"
+#include <IPlatform.h>
 #include "../util/StringUtils.h"
 #include "../world/level/tile/Tile.h"
 #include "../world/item/ItemInstance.h"
@@ -8,8 +8,7 @@
 
 I18n::Map I18n::_strings;
 
-void I18n::loadLanguage( AppPlatform* platform, const std::string& languageCode )
+void I18n::loadLanguage(IPlatform& platform, const std::string& languageCode ) {
-{
 	_strings.clear();
 	fillTranslations(platform, "lang/en_US.lang", true);
 
@@ -26,8 +25,7 @@ bool I18n::get( const std::string& id, std::string& out ) {
 	return false;
 }
 
-std::string I18n::get( const std::string& id )
+std::string I18n::get( const std::string& id ) {
-{
 	Map::const_iterator cit = _strings.find(id);
 	if (cit != _strings.end())
 		return cit->second;
@@ -35,13 +33,11 @@ std::string I18n::get( const std::string& id )
 	return id + '<';//lang.getElement(id);
 }
 
-void I18n::fillTranslations( AppPlatform* platform, const std::string& filename, bool overwrite )
+void I18n::fillTranslations(IPlatform& platform, const std::string& filename, bool overwrite ) {
-{
+	auto blob = platform.readAssetFile(filename);
-	BinaryBlob blob = platform->readAssetFile(filename);
+	if (blob.empty()) return;
-	if (!blob.data || blob.size <= 0)
-		return;
 
-	std::string data((const char*)blob.data, blob.size);
+	std::string data(blob.begin(), blob.end());
 	std::stringstream fin(data, std::ios_base::in);
 
 	std::string line;
@@ -58,12 +54,9 @@ void I18n::fillTranslations( AppPlatform* platform, const std::string& filename,
 		std::string value = Util::stringTrim(line.substr(spos + 1));
 		_strings.insert( std::make_pair(key, value ) );
 	}
-
-	delete[] blob.data;
 }
 
-std::string I18n::getDescriptionString( const ItemInstance& item )
+std::string I18n::getDescriptionString( const ItemInstance& item ) {
-{
 	// Convert to lower. Normally std::transform would be used, but tolower might be
 	// implemented with a macro in certain C-implementations -> messing stuff up
 	const std::string desc = item.getDescriptionId();

src/locale/I18n.h

@@ -3,17 +3,17 @@
 
 //package net.minecraft.locale;
 
+#include "IPlatform.h"
 #include <map>
 #include <string>
 
 class AppPlatform;
 class ItemInstance;
 
-class I18n
+class I18n {
-{
 	typedef std::map<std::string, std::string> Map;
 public:
-	static void loadLanguage(AppPlatform* platform, const std::string& languageCode);
+	static void loadLanguage(IPlatform& platform, const std::string& languageCode);
 
 	static bool get(const std::string& id, std::string& out);
     static std::string get(const std::string& id);
@@ -24,7 +24,7 @@ public:
 	static std::string getDescriptionString( const ItemInstance& item );
 
 private:
-	static void fillTranslations(AppPlatform* platform, const std::string& filename, bool overwrite);
+	static void fillTranslations(IPlatform& platform, const std::string& filename, bool overwrite);
 	static Map _strings;
 };
 

src/main.cpp

@@ -1,46 +1,9 @@
-/**
+#include "MinecraftClient.h"
-    Entry point for cross compilation.
 
-    This is ugly, yes. But it will change in the "half near" future
+int main() {
-    to a more correct system of solving the cross-platform entry
+    MinecraftClient minecraft(App::CreatePlatform());
-    point "problem" */
-
-#define _SECURE_SCL 0
-
-// #ifdef WIN32
-// 	#include "vld.h"
-// #endif
-
-#include "platform/log.h"
-
-#ifdef WIN32
-#endif
-#ifdef ANDROID
-#endif
-
-
-#include "NinecraftApp.h"
-#define MAIN_CLASS NinecraftApp
-
-// #ifdef PLATFORM_WINDOWS
-// 	#include "main_win32.h"
-// #endif
-
-
-#if defined(PLATFORM_DESKTOP) || defined(PLATFORM_WEB)
-    #include "main_glfw.h"
-#endif
-
-#ifdef PLATFORM_ANDROID
-    #ifdef PRE_ANDROID23
-        #include "main_android_java.h"
-    #else
-        #include "main_android.h"
-    #endif
-#endif
-
-#ifdef PLATFORM_RPI
-    #include "main_rpi.h"
-#endif
 
+    minecraft.run();
 
+    return 0;
+}

src/main_android.h

@@ -250,10 +250,10 @@ static void pointerMove(int pointerId, int x, int y) {
     Multitouch::feed(0, 0, x, y, pointerId);
 }
 
-__inline static const float padXtoSigned(int x) {
+inline static const float padXtoSigned(int x) {
     return (x - 483.0f) * 0.002070393374741201f;
 }
-__inline static const float padYtoSigned(int y) {
+inline static const float padYtoSigned(int y) {
     return (y - 180.0f) * 0.005555555555555556f;
 }
 

src/main_dedicated.cpp

@@ -1,20 +1,22 @@
 #include <iostream>
-#include "NinecraftApp.h"
+#include <IPlatform.h>
-#include "AppPlatform.h"
+#include <memory>
 #include <stdio.h>
 #include <stdlib.h>
 #include <signal.h>
 #include <unistd.h>
 
+#include "MinecraftServer.h"
+#include "platform/server/PlatformServer.h"
 #include "world/level/LevelSettings.h"
 #include "world/level/Level.h"
 #include "server/ArgumentsSettings.h"
 #include "platform/time.h"
 #include "SharedConstants.h"
 
-#define MAIN_CLASS NinecraftApp
 static App* g_app = 0;
 static int g_exitCode = 0;
+
 void signal_callback_handler(int signum) {
 	std::cout << "Signum caught: " << signum << std::endl;
 	if(signum == 2 || signum == 3){ // SIGINT ||  SIGQUIT
@@ -29,57 +31,49 @@ void signal_callback_handler(int signum) {
 
 int main(int numArguments, char* pszArgs[]) {
 	ArgumentsSettings aSettings(numArguments, pszArgs);
+
 	if(aSettings.getShowHelp()) {
-		// TODO: Map with args and print it with std::cout and for loop
-		// TODO: World size setting
-
 		ArgumentsSettings defaultSettings(0, NULL);
-
 		printf("Minecraft Pockect Edition Server %s\n", Common::getGameVersionString("").c_str());
 		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());
 		printf("--externalpath - The path to the place where the server should store the levels. [default: \"%s\"]\n", defaultSettings.getExternalPath().c_str());
 		printf("--levelname - The name of the server [default: \"%s\"]\n", defaultSettings.getLevelName().c_str());
-		printf("--gamemode - The name of the gamemode [default: \"%s\"]\n", defaultSettings.getGamemode().c_str());
 		printf("--leveldir - The name of the server [default: \"%s\"]\n", defaultSettings.getLevelDir().c_str());
 		printf("--help - Shows this message.\n");
 		printf("--port - The port to run the server on. [default: %d]\n", defaultSettings.getPort());
 		printf("--serverkey - The key that the server should use for API calls. [default: \"%s\"]\n", defaultSettings.getServerKey().c_str());
-
 		printf("-------------------------------------------------------\n");
-
 		return 0;
 	}
+
 	printf("Level Name: %s\n", aSettings.getLevelName().c_str());
 
-	AppContext appContext;
+	MinecraftServer server(App::CreatePlatform());
-	appContext.platform = new AppPlatform();
-	App* app = new MAIN_CLASS();
-	signal(SIGINT, signal_callback_handler);
-	g_app = app;
-	((MAIN_CLASS*)g_app)->externalStoragePath = aSettings.getExternalPath();
-	((MAIN_CLASS*)g_app)->externalCacheStoragePath = aSettings.getCachePath();
 
-	g_app->init(appContext);
+	signal(SIGINT, signal_callback_handler);
+	g_app = &server;
+
+	server.externalStoragePath = aSettings.getExternalPath();
+	server.externalCacheStoragePath = aSettings.getCachePath();
+
+	server.init();
 	LevelSettings settings(getEpochTimeS(), GameType::Creative);
 	float startTime = getTimeS();
-	((MAIN_CLASS*)g_app)->selectLevel(aSettings.getLevelDir(), aSettings.getLevelName(),  settings);
+	server.selectLevel(aSettings.getLevelDir(), aSettings.getLevelName(),  settings);
-	((MAIN_CLASS*)g_app)->hostMultiplayer(aSettings.getPort());
+	server.hostMultiplayer(aSettings.getPort());
 
 	std::cout << "Level has been generated in " << getTimeS() - startTime << std::endl;
-	((MAIN_CLASS*)g_app)->level->saveLevelData();
+	server.level->saveLevelData();
 	std::cout << "Level has been saved!" << std::endl;
 
-	while(!app->wantToQuit()) {
+	while(!server.wantToQuit()) {
-		app->update();
+		server.update();
 		//pthread_yield();
 		sleepMs(20);
 	}
-	((MAIN_CLASS*)g_app)->level->saveLevelData();
+
-	delete app;
+	server.level->saveLevelData();
-	appContext.platform->finish();
-	delete appContext.platform;
 
 	std::cout << "Quit correctly" << std::endl;
 	return g_exitCode;

src/main_glfw.h

@@ -2,6 +2,7 @@
 #define MAIN_GLFW_H__
 
 #include "App.h"
+#include "NinecraftApp.h"
 #include "client/renderer/entity/PlayerRenderer.h"
 #include "client/renderer/gles.h"
 #include "GLFW/glfw3.h"
@@ -16,203 +17,56 @@
 #ifdef __EMSCRIPTEN__
 #include <emscripten/emscripten.h>
 #endif
-static App* g_app = 0;
 
-int transformKey(int glfwkey) {
+// void loop() {
-	if (glfwkey >= GLFW_KEY_F1 && glfwkey <= GLFW_KEY_F12) {
+// 	using clock = std::chrono::steady_clock;
-		return glfwkey - 178;
+// 	auto frameStart = clock::now();
-	}
 
-	switch (glfwkey) {
+// 	g_app->update();
-		case GLFW_KEY_ESCAPE: return Keyboard::KEY_ESCAPE;
-		case GLFW_KEY_TAB: return Keyboard::KEY_TAB;
-		case GLFW_KEY_BACKSPACE: return Keyboard::KEY_BACKSPACE;
-		case GLFW_KEY_LEFT_SHIFT: return Keyboard::KEY_LSHIFT;
-		case GLFW_KEY_ENTER: return Keyboard::KEY_RETURN;
-		case GLFW_KEY_LEFT_CONTROL: return Keyboard::KEY_LEFT_CTRL;
-		default: return glfwkey;
-	}
-}
 
-void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods) {
+// 	glfwSwapBuffers(((AppPlatform_glfw*)g_app->platform())->window);
-	if(action == GLFW_REPEAT) return;
+// 	glfwPollEvents();
 
-	if (key == GLFW_KEY_F11 && action == GLFW_PRESS) {
+// 	glfwSwapInterval(((MAIN_CLASS*)g_app)->options.getBooleanValue(OPTIONS_VSYNC) ? 1 : 0);
-		GLFWmonitor* monitor = glfwGetWindowMonitor(window);
+// 	if(((MAIN_CLASS*)g_app)->options.getBooleanValue(OPTIONS_LIMIT_FRAMERATE)) {
-		if (monitor) {
+// 		auto frameEnd = clock::now();
-			// Currently fullscreen → go windowed
+// 		auto elapsed = std::chrono::duration_cast<std::chrono::microseconds>(frameEnd - frameStart);
-			glfwSetWindowMonitor(window, NULL, 80, 80, 854, 480, 0);
+// 		auto target = std::chrono::microseconds(33333); // ~30 fps
-		} else {
+// 		if(elapsed < target)
-			// Currently windowed → go fullscreen on primary monitor
+// 			std::this_thread::sleep_for(target - elapsed);
-			GLFWmonitor* primary = glfwGetPrimaryMonitor();
+// 	}
-			const GLFWvidmode* mode = glfwGetVideoMode(primary);
+// }
-			glfwSetWindowMonitor(window, primary, 0, 0, mode->width, mode->height, mode->refreshRate);
-		}
-		return;
-	}
-
-	Keyboard::feed(transformKey(key), action);
-}
-
-void character_callback(GLFWwindow* window, unsigned int codepoint) {
-	Keyboard::feedText(codepoint);
-}
-
-static void cursor_position_callback(GLFWwindow* window, double xpos, double ypos) {
-	static double lastX = 0.0, lastY = 0.0;
-	static bool firstMouse = true;
-
-	if (firstMouse) {
-        lastX = xpos;
-        lastY = ypos;
-        firstMouse = false;
-    }
-
-	double deltaX = xpos - lastX;
-    double deltaY = ypos - lastY;
-
-    lastX = xpos;
-    lastY = ypos;
-
-	if (glfwGetInputMode(window, GLFW_CURSOR) == GLFW_CURSOR_DISABLED) {
-		Mouse::feed(0, 0, xpos, ypos, deltaX, deltaY);
-	} else { 
-		Mouse::feed( MouseAction::ACTION_MOVE, 0, xpos, ypos);
-	}
-	Multitouch::feed(0, 0, xpos, ypos, 0);
-}
-
-void mouse_button_callback(GLFWwindow* window, int button, int action, int mods) {
-	if(action == GLFW_REPEAT) return;
-
-	double xpos, ypos;
-	glfwGetCursorPos(window, &xpos, &ypos);
-
-	if (button == GLFW_MOUSE_BUTTON_LEFT) {
-		Mouse::feed( MouseAction::ACTION_LEFT, action, xpos, ypos);
-		Multitouch::feed(1, action, xpos, ypos, 0);
-	}
-
-	if (button == GLFW_MOUSE_BUTTON_RIGHT) {
-		Mouse::feed( MouseAction::ACTION_RIGHT, action, xpos, ypos);
-	}
-}
-
-void scroll_callback(GLFWwindow* window, double xoffset, double yoffset) {
-	double xpos, ypos;
-	glfwGetCursorPos(window, &xpos, &ypos);
-
-	Mouse::feed(3, 0, xpos, ypos, 0, yoffset);
-}
-
-void window_size_callback(GLFWwindow* window, int width, int height) {
-	if (g_app) g_app->setSize(width, height);
-}
-
-void error_callback(int error, const char* desc) {
-	printf("Error: %s\n", desc);
-}
-
-
-void loop() {
-	using clock = std::chrono::steady_clock;
-	auto frameStart = clock::now();
-
-	g_app->update();
-
-	glfwSwapBuffers(((AppPlatform_glfw*)g_app->platform())->window);
-	glfwPollEvents();
-
-	glfwSwapInterval(((MAIN_CLASS*)g_app)->options.getBooleanValue(OPTIONS_VSYNC) ? 1 : 0);
-	if(((MAIN_CLASS*)g_app)->options.getBooleanValue(OPTIONS_LIMIT_FRAMERATE)) {
-		auto frameEnd = clock::now();
-		auto elapsed = std::chrono::duration_cast<std::chrono::microseconds>(frameEnd - frameStart);
-		auto target = std::chrono::microseconds(33333); // ~30 fps
-		if(elapsed < target)
-			std::this_thread::sleep_for(target - elapsed);
-	}
-}
 
 int main(void) {
 	AppContext appContext;
 
-#ifndef STANDALONE_SERVER
+	appContext.platform = new AppPlatformGlfw();
-	// Platform init.
-	appContext.platform = new AppPlatform_glfw();
-#if defined(__EMSCRIPTEN__)
-	EM_ASM(
-		FS.mkdir('/games');
-		FS.mkdir('/games/com.mojang');
-        FS.mkdir('/games/com.mojang/minecraftWorlds');
-        FS.mount(IDBFS, {}, '/games');
-        FS.syncfs(true, function (err) {});
-    );
-#endif
 
-	glfwSetErrorCallback(error_callback);
+	AppPlatformGlfw* platform = (AppPlatformGlfw*)appContext.platform;
 
-	if (!glfwInit()) {
+	if (!platform->init()) {
 		return 1;
 	}
 
-	glfwWindowHint(GLFW_CONTEXT_CREATION_API, GLFW_NATIVE_CONTEXT_API);
+	App* app = (App*)new NinecraftApp();
-#ifndef __EMSCRIPTEN__
+	app->init(appContext);
-	glfwWindowHint(GLFW_CLIENT_API, GLFW_OPENGL_API);
+	app->setSize(platform->getScreenWidth(), platform->getScreenHeight());
-	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 2);
-	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 1);
-#else
-	glfwWindowHint(GLFW_CLIENT_API, GLFW_OPENGL_ES_API);
-	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 1);
-	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0);
-#endif
 
-	AppPlatform_glfw* platform = (AppPlatform_glfw*)appContext.platform;
+	auto loop = [app]() {
-
+		app->update();
-	platform->window = glfwCreateWindow(appContext.platform->getScreenWidth(), appContext.platform->getScreenHeight(), "Minecraft PE 0.6.1", NULL, NULL);
+	};
-	
-	if (platform->window == NULL) {
-		return 1;
-	}
-
-	glfwSetKeyCallback(platform->window, key_callback);
-	glfwSetCharCallback(platform->window, character_callback);
-	glfwSetCursorPosCallback(platform->window, cursor_position_callback);
-	glfwSetMouseButtonCallback(platform->window, mouse_button_callback);
-	glfwSetScrollCallback(platform->window, scroll_callback);
-	glfwSetWindowSizeCallback(platform->window, window_size_callback);
-
-	glfwMakeContextCurrent(platform->window);
-	#ifndef __EMSCRIPTEN__
-	gladLoadGLLoader((GLADloadproc)glfwGetProcAddress);
-	glfwSwapInterval(0);
-	#endif
-#endif
-
-	App* app = new MAIN_CLASS();
-
-	g_app = app;
-	((MAIN_CLASS*)g_app)->externalStoragePath = ".";
-	((MAIN_CLASS*)g_app)->externalCacheStoragePath = ".";
-	g_app->init(appContext);
-	g_app->setSize(appContext.platform->getScreenWidth(), appContext.platform->getScreenHeight());
 
 #ifdef __EMSCRIPTEN__
 	emscripten_set_main_loop(loop, 0, 1);
 #else
 	// Main event loop
-	while(!glfwWindowShouldClose(platform->window) && !app->wantToQuit()) {
+	while(!app->wantToQuit()) {
 		loop();
 	}
 #endif
 
 	delete app;
 
-#ifndef STANDALONE_SERVER
-	// Exit.
-	glfwDestroyWindow(platform->window);
-	glfwTerminate();
-#endif
-
 	appContext.platform->finish();
 	
 	delete appContext.platform;

src/nbt/CompoundTag.h

@@ -115,7 +115,7 @@ public:
 		return it->second;
     }
 
-    __inline bool contains(const std::string& name) const {
+    inline bool contains(const std::string& name) const {
 		return tags.find(name) != tags.end();
 	}
 	bool contains(const std::string& name, int type) const {

src/network/ClientSideNetworkHandler.cpp

@@ -1,7 +1,7 @@
-
 #include "ClientSideNetworkHandler.h"
+#include <MinecraftClient.h>
 #include "client/Options.h"
-#include "network/packet/LoginStatusPacket.h"
+#include "gamemode/GameMode.h"
 #include "packet/PacketInclude.h"
 #include "RakNetInstance.h"
 #include "../world/level/chunk/ChunkSource.h"
@@ -9,12 +9,7 @@
 #include "../world/level/storage/LevelStorageSource.h"
 #include "../world/entity/player/Player.h"
 #include "../world/entity/player/Inventory.h"
-#include "../client/Minecraft.h"
+#include <Minecraft.h>
-#include "../client/gamemode/GameMode.h"
-#include "world/item/ItemInstance.h"
-#ifndef STANDALONE_SERVER
-#include "../client/gui/screens/DisconnectionScreen.h"
-#endif
 #include "../client/player/LocalPlayer.h"
 #include "../client/multiplayer/MultiPlayerLevel.h"
 #include "../client/player/input/KeyboardInput.h"
@@ -24,9 +19,6 @@
 #include "../world/level/Explosion.h"
 #include "../world/level/tile/entity/FurnaceTileEntity.h"
 #include "../world/inventory/BaseContainerMenu.h"
-#ifndef STANDALONE_SERVER
-#include "../client/particle/TakeAnimationParticle.h"
-#endif
 #include "../world/entity/EntityFactory.h"
 #include "../world/entity/item/PrimedTnt.h"
 #include "../world/entity/projectile/Arrow.h"
@@ -37,12 +29,9 @@
 
 static MultiPlayerLevel* mpcast(Level* l) { return (MultiPlayerLevel*) l; }
 
-ClientSideNetworkHandler::ClientSideNetworkHandler(Minecraft* minecraft, IRakNetInstance* raknetInstance)
+ClientSideNetworkHandler::ClientSideNetworkHandler(MinecraftClient& minecraft, IRakNetInstance* raknetInstance)
 :	minecraft(minecraft),
-	raknetInstance(raknetInstance),
+	raknetInstance(raknetInstance)
-	level(NULL),
-	requestNextChunkPosition(0),
-    requestNextChunkIndex(0)
 {
 	rakPeer = raknetInstance->getPeer();
 }
@@ -88,7 +77,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);
 }
 
@@ -99,21 +88,20 @@ void ClientSideNetworkHandler::onUnableToConnect()
 
 void ClientSideNetworkHandler::onDisconnect(const RakNet::RakNetGUID& guid)
 {
-	// TODO: Good disconnecting
 	LOGI("onDisconnect\n");
 	if (level)
 	{
 		level->isClientSide = false;
 		for (int i = (int)level->players.size()-1; i >= 0; --i ) {
 			Player* p = level->players[i];
-			if (p != minecraft->player) {
+			if (p != minecraft.getPlayer()) {
 				p->reallyRemoveIfPlayer = true;
 				level->removeEntity(p);
 			}
 		}
 	}
 #ifndef STANDALONE_SERVER
-	minecraft->gui.addMessage("Disconnected from server");
+	minecraft.gui.addMessage("Disconnected from server");
 #endif
 }
 
@@ -126,19 +114,13 @@ void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, LoginSta
 	if (packet->status == LoginStatus::Failed_ClientOld) {
 		LOGI("Disconnect! Client is outdated!\n");
 #ifndef STANDALONE_SERVER
-		minecraft->setScreen(new DisconnectionScreen("Could not connect: Outdated client!"));
+		minecraft.setScreen(new DisconnectionScreen("Could not connect: Outdated client!"));
 #endif
 	}
 	if (packet->status == LoginStatus::Failed_ServerOld) {
 		LOGI("Disconnect! Server is outdated!\n");
 #ifndef STANDALONE_SERVER
-		minecraft->setScreen(new DisconnectionScreen("Could not connect: Outdated 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
 	}
 }
@@ -150,13 +132,13 @@ void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, StartGam
 
 #ifdef RPI
 	if (packet->gameType != GameType::Creative) {
-		minecraft->setScreen(new DisconnectionScreen("Could not connect: Incompatible server!"));
+		minecraft.setScreen(new DisconnectionScreen("Could not connect: Incompatible server!"));
 		return;
 	}
 #endif
 
 	const std::string& levelId = LevelStorageSource::TempLevelId;
-	LevelStorageSource* storageSource = minecraft->getLevelSource();
+	LevelStorageSource* storageSource = minecraft.getLevelSource();
 	storageSource->deleteLevel(levelId);
 	//level = new Level(storageSource->selectLevel(levelId, true), "temp", packet->levelSeed, SharedConstants::StorageVersion);
 	MultiPlayerLevel* level = new MultiPlayerLevel(
@@ -167,22 +149,22 @@ void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, StartGam
 	level->isClientSide = true;
 
 	bool isCreative = (packet->gameType == GameType::Creative);
-	LocalPlayer* player = new LocalPlayer(minecraft, level, minecraft->options.getStringValue(OPTIONS_USERNAME), level->dimension->id, isCreative);
+	LocalPlayer* player = new LocalPlayer(minecraft, level, minecraft.options().getStringValue(OPTIONS_USERNAME), level->dimension->id, isCreative);
 	player->owner = rakPeer->GetMyGUID();
 	player->entityId = packet->entityId;
 	player->moveTo(packet->x, packet->y, packet->z, player->yRot, player->xRot);
 
 	LOGI("new pos: %f, %f [%f - %f]\n", player->x, player->z, player->bb.y0, player->bb.y1);
 
-	minecraft->setLevel(level, "ClientSideNetworkHandler -> setLevel", player);
+	minecraft.setLevel(level, "ClientSideNetworkHandler -> setLevel", player);
-	minecraft->setIsCreativeMode(isCreative);
+	minecraft.setIsCreativeMode(isCreative);
 }
 
 void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, MessagePacket* packet)
 {
 	LOGI("MessagePacket\n");
 #ifndef STANDALONE_SERVER
-	minecraft->gui.addMessage(packet->message.C_String());
+	minecraft.gui.addMessage(packet->message.C_String());
 #endif
 }
 
@@ -279,8 +261,8 @@ void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, AddPlaye
 	}
 	LOGI("AddPlayerPacket\n");
 
-	Player* player = new RemotePlayer(level, minecraft->isCreativeMode());
+	Player* player = new RemotePlayer(level, minecraft.isCreativeMode());
-	minecraft->gameMode->initAbilities(player->abilities);
+	minecraft.gameMode->initAbilities(player->abilities);
 	player->entityId = packet->entityId;
 	level->addEntity(player);
 
@@ -301,12 +283,12 @@ void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, AddPlaye
 	std::string message = packet->name.C_String();
 	message += " joined the game";
 #ifndef STANDALONE_SERVER
-	minecraft->gui.addMessage(message);
+	minecraft.gui.addMessage(message);
 #endif
 }
 
 void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, RemovePlayerPacket* packet) {
-	if (!level || source == minecraft->player->owner) return;
+	if (!level || source == minecraft.getPlayer()->owner) return;
 
 	if (Player* player = findPlayer(level, packet->entityId, &packet->owner)) {
 		player->reallyRemoveIfPlayer = true;
@@ -325,7 +307,7 @@ void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, RemovePl
 
 	//std::string message = packet->name.C_String();
 	//message += " joined the game";
-	//minecraft->gui.addMessage(message);
+	//minecraft.gui.addMessage(message);
 }
 
 void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, RemoveEntityPacket* packet)
@@ -333,7 +315,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.getPlayer(), entity?(int)(entity->isPlayer()): -1);
 	if (!entity) return;
 
 	level->removeEntity(entity);
@@ -353,7 +335,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);
@@ -365,7 +346,7 @@ void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, TakeItem
 		item = ((ItemEntity*) e)->item;
 #ifndef STANDALONE_SERVER
 		if (Entity* to = level->getEntity(packet->playerId))
-			minecraft->particleEngine->add(new TakeAnimationParticle(level, (ItemEntity*)e, to, -0.5f));
+			minecraft.particleEngine->add(new TakeAnimationParticle(level, (ItemEntity*)e, to, -0.5f));
 #endif
 	}
 	else if (e->getEntityTypeId() == EntityTypes::IdArrow)
@@ -375,10 +356,10 @@ void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, TakeItem
 		return;
 
 	// try take it and if we don't have space; re-throw it
-	if (minecraft->player->entityId == packet->playerId
+	if (minecraft.getPlayer()->entityId == packet->playerId
-	&& !minecraft->player->inventory->add(&item)) {
+	&& !minecraft.getPlayer()->inventory->add(&item)) {
 		DropItemPacket dropPacket(packet->playerId, item);
-		minecraft->raknetInstance->send(dropPacket);
+		minecraft.raknetInstance->send(dropPacket);
 	}
 	level->playSound(e, "random.pop", 0.2f, 1.0f * 2.f);
 }
@@ -396,54 +377,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)
@@ -496,16 +429,16 @@ void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, ExplodeP
 void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, LevelEventPacket* packet) {
 	if (!level) return;
 	if(packet->eventId == LevelEvent::ALL_PLAYERS_SLEEPING) {
-		minecraft->player->setAllPlayersSleeping();
+		minecraft.getPlayer()->setAllPlayersSleeping();
 	}
 	else {
-		minecraft->level->levelEvent(NULL, packet->eventId, packet->x, packet->y, packet->z, packet->data);
+		minecraft.level->levelEvent(NULL, packet->eventId, packet->x, packet->y, packet->z, packet->data);
 	}
 }
 
 void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, TileEventPacket* packet) {
 	if (!level) return;
-	minecraft->level->tileEvent(packet->x, packet->y, packet->z, packet->b0, packet->b1);
+	minecraft.level->tileEvent(packet->x, packet->y, packet->z, packet->b0, packet->b1);
 }
 
 void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, EntityEventPacket* packet) {
@@ -689,7 +622,7 @@ void ClientSideNetworkHandler::arrangeRequestChunkOrder() {
     int cz = CHUNK_CACHE_WIDTH / 2;
 
     // If player exists, let's sort around him
-    Player* p = minecraft? minecraft->player : NULL;
+    Player* p = minecraft.getPlayer();
     if (p) {
         cx = Mth::floor(p->x / (float)CHUNK_WIDTH);
         cz = Mth::floor(p->z / (float)CHUNK_DEPTH);
@@ -775,9 +708,9 @@ void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, Interact
 	{
 		Player* player = (Player*) src;
 		if (InteractPacket::Attack == packet->action)
-			minecraft->gameMode->attack(player, entity);
+			minecraft.gameMode->attack(player, entity);
 		if (InteractPacket::Interact == packet->action)
-			minecraft->gameMode->interact(player, entity);
+			minecraft.gameMode->interact(player, entity);
 	}
 }
 
@@ -817,7 +750,7 @@ void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, AnimateP
 		return;
 
     // Own player - Then don't play... :
-    if (minecraft->player->entityId == packet->entityId) {
+    if (minecraft.getPlayer()->entityId == packet->entityId) {
         if (packet->action == AnimatePacket::Swing) return;
     }
 
@@ -840,37 +773,32 @@ 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)
 {
 }
 
 void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, SetHealthPacket* packet)
 {
-	if (!level || !minecraft->player)
+	if (!level || !minecraft.getPlayer())
 		return;
 
-	printf("SetHealthPacket \n");
+	minecraft.getPlayer()->hurtTo(packet->health);
-	minecraft->player->hurtTo(packet->health);
 }
 
 void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, SetSpawnPositionPacket* packet) {
-	if (!level || !minecraft || !minecraft->player) return;
+	if (!level || !minecraft.getPlayer()) return;
 	if (!level->inRange(packet->x, packet->y, packet->z)) return;
 
-	minecraft->player->setRespawnPosition(Pos(packet->x, packet->y, packet->z));
+	minecraft.getPlayer()->setRespawnPosition(Pos(packet->x, packet->y, packet->z));
 	level->getLevelData()->setSpawn(packet->x, packet->y, packet->z);
 }
 
 void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, HurtArmorPacket* packet) {
-    if (!level || !minecraft->player) {
+    if (!level || !minecraft.getPlayer()) {
         return;
     }
 
-    minecraft->player->hurtArmor(packet->dmg);
+    minecraft.getPlayer()->hurtArmor(packet->dmg);
 }
 
 void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, RespawnPacket* packet)
@@ -883,43 +811,43 @@ void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, RespawnP
 
 void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, ContainerOpenPacket* packet)
 {
-	if (!level || !minecraft || !minecraft->player)
+	if (!level)
 		return;
 
 	if (packet->type == ContainerType::FURNACE) {
 		FurnaceTileEntity* te = new FurnaceTileEntity();
 		te->clientSideOnly = true;
-		minecraft->player->openFurnace(te);
+		minecraft.getPlayer()->openFurnace(te);
-		if (minecraft->player->containerMenu)
+		if (minecraft.getPlayer()->containerMenu)
-			minecraft->player->containerMenu->containerId = packet->containerId;
+			minecraft.getPlayer()->containerMenu->containerId = packet->containerId;
 	}
 	if (packet->type == ContainerType::CONTAINER) {
 		ChestTileEntity* te = new ChestTileEntity();
 		te->clientSideOnly = true;
-		minecraft->player->openContainer(te);
+		minecraft.getPlayer()->openContainer(te);
-		if (minecraft->player->containerMenu)
+		if (minecraft.getPlayer()->containerMenu)
-			minecraft->player->containerMenu->containerId = packet->containerId;
+			minecraft.getPlayer()->containerMenu->containerId = packet->containerId;
 	}
 }
 
 void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, ContainerClosePacket* packet)
 {
-	if (minecraft && minecraft->player && minecraft->player->containerMenu)
+	if (minecraft.getPlayer() && minecraft.getPlayer()->containerMenu)
-		minecraft->player->closeContainer();
+		minecraft.getPlayer()->closeContainer();
 }
 
 void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, ContainerSetContentPacket* packet)
 {
-	if (!minecraft || !minecraft->player)
+	if (!minecraft.getPlayer())
 		return;
 
     if (packet->containerId == 0) {
         for (unsigned int i = 0; i < packet->items.size(); ++i) {
-            minecraft->player->inventory->setItem(Inventory::MAX_SELECTION_SIZE + i, &packet->items[i]);
+            minecraft.getPlayer()->inventory->setItem(Inventory::MAX_SELECTION_SIZE + i, &packet->items[i]);
         }
-    } else if (minecraft->player->containerMenu && minecraft->player->containerMenu->containerId == packet->containerId) {
+    } else if (minecraft.getPlayer()->containerMenu && minecraft.getPlayer()->containerMenu->containerId == packet->containerId) {
         for (unsigned int i = 0; i < packet->items.size(); ++i) {
-            minecraft->player->containerMenu->setSlot(i, &packet->items[i]);
+            minecraft.getPlayer()->containerMenu->setSlot(i, &packet->items[i]);
         }
     }
 }
@@ -928,28 +856,28 @@ void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, Containe
 {
 	//LOGI("ContainerSetSlot\n");
 
-	if (!minecraft->player
+	if (!minecraft.getPlayer()
-	  || !minecraft->player->containerMenu
+	  || !minecraft.getPlayer()->containerMenu
-	  || minecraft->player->containerMenu->containerId != packet->containerId)
+	  || minecraft.getPlayer()->containerMenu->containerId != packet->containerId)
 	  return;
 
-	//minecraft->player->containerMenu->setSlot(packet->slot, packet->item.isNull()? NULL : &packet->item);
+	//minecraft.getPlayer()->containerMenu->setSlot(packet->slot, packet->item.isNull()? NULL : &packet->item);
-	minecraft->player->containerMenu->setSlot(packet->slot, &packet->item);
+	minecraft.getPlayer()->containerMenu->setSlot(packet->slot, &packet->item);
 }
 
 void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, ContainerSetDataPacket* packet)
 {
 	//LOGI("ContainerSetData\n");
-	if (minecraft->player && minecraft->player->containerMenu && minecraft->player->containerMenu->containerId == packet->containerId) {
+	if (minecraft.getPlayer() && minecraft.getPlayer()->containerMenu && minecraft.getPlayer()->containerMenu->containerId == packet->containerId) {
 		//LOGI("client: SetData2 %d, %d\n", packet->id, packet->value);
-		minecraft->player->containerMenu->setData(packet->id, packet->value);
+		minecraft.getPlayer()->containerMenu->setData(packet->id, packet->value);
 	}
 }
 
 void ClientSideNetworkHandler::handle( const RakNet::RakNetGUID& source, ChatPacket* packet )
 {
 #ifndef STANDALONE_SERVER
-	minecraft->gui.displayClientMessage(packet->message);
+	minecraft.gui.displayClientMessage(packet->message);
 #endif
 }
 

src/network/ClientSideNetworkHandler.h

@@ -8,7 +8,7 @@
 
 #include <vector>
 
-class Minecraft;
+class MinecraftClient;
 class Level;
 class IRakNetInstance;
 
@@ -29,7 +29,7 @@ typedef struct IntPair {
 class ClientSideNetworkHandler : public NetEventCallback
 {
 public:
-	ClientSideNetworkHandler(Minecraft* minecraft, IRakNetInstance* raknetInstance);
+	ClientSideNetworkHandler(MinecraftClient& minecraft, IRakNetInstance* raknetInstance);
 	virtual ~ClientSideNetworkHandler();
 
 	virtual void levelGenerated(Level* level);
@@ -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();
@@ -92,19 +87,19 @@ private:
 	void clearChunksLoaded();
 private:
 
-	Minecraft* minecraft;
+	MinecraftClient& minecraft;
-	Level* level;
+	Level* level = nullptr;
 	IRakNetInstance* raknetInstance;
 	RakNet::RakPeerInterface* rakPeer;
 
 	RakNet::RakNetGUID serverGuid;
 
 	BlockUpdateList	bufferedBlockUpdates;
-	int	requestNextChunkPosition;
+	int	requestNextChunkPosition = 0;
 
     static const int NumRequestChunks = CHUNK_CACHE_WIDTH * CHUNK_CACHE_WIDTH;
     
-    int requestNextChunkIndex;
+    int requestNextChunkIndex = 0;
     IntPair requestNextChunkIndexList[NumRequestChunks];
 	bool chunksLoaded[NumRequestChunks];
 };

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,16 +41,10 @@ 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;
-	case PACKET_ADDMOB:	
+	case PACKET_ADDMOB:
 		packet = new AddMobPacket();
 		break;
 	case PACKET_ADDPLAYER:
@@ -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,10 +33,7 @@ enum MinecraftPacketIds
 	PACKET_REMOVEENTITY,
 	PACKET_ADDITEMENTITY,
 	PACKET_TAKEITEMENTITY,
-	PACKET_TAKEITEM,
+
-	PACKET_REMOVEITEM,
-	PACKET_WANTCREATEITEM,
-	
 	PACKET_MOVEENTITY,
 	PACKET_MOVEENTITY_POS,
 	PACKET_MOVEENTITY_ROT,

src/network/RakNetInstance.cpp

@@ -5,11 +5,10 @@
 #include "../raknet/BitStream.h"
 #include "../raknet/MessageIdentifiers.h"
 #include "../raknet/GetTime.h"
-#include "../AppConstants.h"
 
 #include "../platform/log.h"
 
-#define APP_IDENTIFIER "MCCPP;" APP_VERSION_STRING ";"
+#define APP_IDENTIFIER "MCCPP;Demo;"
 #define APP_IDENTIFIER_MINECON "MCCPP;MINECON;"
 
 RakNetInstance::RakNetInstance()

src/network/ServerSideNetworkHandler.cpp

@@ -5,37 +5,53 @@
 #include "../world/entity/player/Inventory.h"
 #include "../world/Container.h"
 #include "../world/inventory/BaseContainerMenu.h"
-#include "network/packet/ContainerSetSlotPacket.h"
+#include "MinecraftClient.h"
-#include "network/packet/LoginStatusPacket.h"
+#include "gamemode/GameMode.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"
-#include "../client/Minecraft.h"
+#include <MinecraftClient.h>
 #include "../client/player/LocalPlayer.h"
-#include "../client/gamemode/GameMode.h"
 #include "../raknet/RakPeerInterface.h"
 #include "../raknet/PacketPriority.h"
-#include "platform/log.h"
-#include "util/Mth.h"
-#include "world/item/ItemInstance.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
 #include "../server/ServerPlayer.h"
 #include "../world/entity/item/FallingTile.h"
+#include "network/packet/AddEntityPacket.h"
+#include "network/packet/AddItemEntityPacket.h"
+#include "network/packet/AddMobPacket.h"
+#include "network/packet/AddPaintingPacket.h"
+#include "network/packet/AddPlayerPacket.h"
+#include "network/packet/AdventureSettingsPacket.h"
+#include "network/packet/AnimatePacket.h"
+#include "network/packet/ChatPacket.h"
+#include "network/packet/ChunkDataPacket.h"
+#include "network/packet/ContainerSetSlotPacket.h"
+#include "network/packet/DropItemPacket.h"
+#include "network/packet/EntityEventPacket.h"
+#include "network/packet/InteractPacket.h"
+#include "network/packet/LevelEventPacket.h"
+#include "network/packet/LoginPacket.h"
+#include "network/packet/LoginStatusPacket.h"
+#include "network/packet/MessagePacket.h"
+#include "network/packet/MovePlayerPacket.h"
+#include "network/packet/PlayerActionPacket.h"
+#include "network/packet/PlayerArmorEquipmentPacket.h"
+#include "network/packet/PlayerEquipmentPacket.h"
+#include "network/packet/ReadyPacket.h"
+#include "network/packet/RemoveBlockPacket.h"
+#include "network/packet/RemoveEntityPacket.h"
+#include "network/packet/RemovePlayerPacket.h"
+#include "network/packet/RequestChunkPacket.h"
+#include "network/packet/RespawnPacket.h"
+#include "network/packet/SendInventoryPacket.h"
+#include "network/packet/SetHealthPacket.h"
+#include "network/packet/SetTimePacket.h"
+#include "network/packet/SignUpdatePacket.h"
+#include "network/packet/StartGamePacket.h"
+#include "network/packet/TileEventPacket.h"
+#include "network/packet/UpdateBlockPacket.h"
+#include "network/packet/UseItemPacket.h"
+#include "world/entity/Painting.h"
+#include "world/level/tile/entity/TileEntity.h"
 
 #define TIMES(x) for(int itc ## __LINE__ = 0; itc ## __LINE__ < x; ++ itc ## __LINE__)
 
@@ -70,16 +86,19 @@ 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 (entity->isMob() && !entity->isPlayer()) { //@fix: This code is duplicated. See if it can be unified.
-		if (minecraft->player) {
+	// 	auto client = dynamic_cast<MinecraftClient*>(minecraft);
-			// 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()) {
 
-	} else if (entity->isItemEntity()) {
+	// 	if (client && client->getPlayer()) {
+	// 		// 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()) {
+
+	// } else 
+	if (entity->isItemEntity()) {
 		AddItemEntityPacket* packet = new AddItemEntityPacket((ItemEntity*)entity);
 		entity->xd = packet->xa();
 		entity->yd = packet->ya();
@@ -174,8 +193,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);
@@ -199,7 +216,7 @@ void ServerSideNetworkHandler::handle(const RakNet::RakNetGUID& source, LoginPac
 	if (!_allowIncoming) return;
 
 	LOGI("LoginPacket\n");
-	
+
 	int loginStatus = LoginStatus::Success;
 	//
 	// Bad/incompatible client version
@@ -209,14 +226,6 @@ void ServerSideNetworkHandler::handle(const RakNet::RakNetGUID& source, LoginPac
 	if (oldClient || oldServer)
 		loginStatus = oldClient? LoginStatus::Failed_ClientOld : LoginStatus::Failed_ServerOld;
 
-	for (int i = 0; i < level->players.size(); i++) {
-		ServerPlayer* player = (ServerPlayer*) level->players.at(i);
-		
-		if (player->name == packet->clientName.C_String()) {
-			loginStatus = packet->newProto ? LoginStatus::Failed_TakenNickname : LoginStatus::Failed_ClientOld;
-		}
-	}
-
 	RakNet::BitStream bitStream;
 	LoginStatusPacket(loginStatus).write(&bitStream);
 	rakPeer->Send(&bitStream, HIGH_PRIORITY, RELIABLE_ORDERED, 0, source, false);
@@ -227,16 +236,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);
@@ -263,11 +269,6 @@ void ServerSideNetworkHandler::handle(const RakNet::RakNetGUID& source, LoginPac
         ).write(&bitStream);
 
         rakPeer->Send(&bitStream, HIGH_PRIORITY, RELIABLE_ORDERED, 0, source, false);
-		
-		if (!packet->newProto) {
-			MessagePacket packet("You're using outdated client. Some features disabled.");
-			raknetInstance->send(packet);
-		}
 	}
 }
 
@@ -280,8 +281,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)
@@ -339,36 +338,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
 	/*
@@ -406,50 +375,15 @@ void ServerSideNetworkHandler::onReady_RequestedChunks(const RakNet::RakNetGUID&
 void ServerSideNetworkHandler::handle(const RakNet::RakNetGUID& source, MovePlayerPacket* packet)
 {
 	if (!level) return;
-	
+
 	//LOGI("MovePlayerPacket\n");
-	if (Entity* entity = level->getEntity(packet->entityId)) {
+	if (Entity* entity = level->getEntity(packet->entityId))
-		ServerPlayer* player = (ServerPlayer*) getPlayer(source);
+	{
+		entity->xd = entity->yd = entity->zd = 0;
+		entity->lerpTo(packet->x, packet->y, packet->z, packet->yRot, packet->xRot, 3);
 
-		float vectorDist = sqrt( (packet->x - entity->x) * (packet->x - entity->x)  + 
+		// broadcast this packet to other clients
-									(packet->z - entity->z) * (packet->z - entity->z));
+		redistributePacket(packet, source);
-		float speed = vectorDist / (minecraft->getTicks() - player->getLastMoveTicks());
-
-		if (speed < 1.f) {
-			LOGI("Packet: %f, %f, %f \n", packet->x, packet->y, packet->z);
-			LOGI("Entity before: %f, %f, %f \n", entity->x, entity->y, entity->z);
-			LOGI("OnGround: %d \n", entity->onGround);
-
-			// @note: packet->y contains y with subtracted entity->heightOffset
-			float ya = packet->y - entity->y - entity->heightOffset;
-
-			LOGI("y: %f \n", ya);
-
-			float yaOrg = ya;
-
-			// @BIGWARNING @fixme: blocks around work as shit
-			std::vector<AABB>& aABBs = level->getCubes(entity, entity->bb.expand(0, ya, 0));
-			
-			for (unsigned int i = 0; i < aABBs.size(); i++)
-				ya = aABBs[i].clipYCollide(entity->bb, ya);
-
-			bool og = yaOrg != ya && yaOrg < 0;
-			
-			entity->onGround = og;
-			entity->checkFallDamage(ya, og);
-			entity->xd = entity->yd = entity->zd = 0;	
-			entity->lerpTo(packet->x, packet->y, packet->z, packet->yRot, packet->xRot, 3);
-
-			LOGI("Entity after: %f, %f, %f \n", entity->x, entity->y, entity->z);
-			
-			// broadcast this packet to other clients
-			redistributePacket(packet, source);
-		} // else {
-		    //MovePlayerPacket refuse(player->entityId, player->x, player->y, player->z, player->xRot, player->yRot);
-		    //raknetInstance->send(refuse);
-		// }
-	
-		player->setLastMoveTicks(minecraft->getTicks());
 	}
 }
 
@@ -471,29 +405,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)
@@ -523,17 +440,17 @@ 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 )
 {
 	this->level = level;
+
+	// auto client = dynamic_cast<MinecraftClient*>(minecraft);
 	
-	if (minecraft->player) {
+	// if (client && client->getPlayer()) {
-		minecraft->player->owner = rakPeer->GetMyGUID();
+	// 	client->getPlayer()->owner = rakPeer->GetMyGUID();
-	}
+	// }
 	
 	level->addListener(this);
 #ifndef STANDALONE_SERVER
@@ -551,31 +468,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) {
@@ -585,8 +494,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);
 }
@@ -598,8 +505,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();
@@ -618,11 +523,13 @@ void ServerSideNetworkHandler::handle(const RakNet::RakNetGUID& source, AnimateP
 {
 	if (!level)
         return;
+	
+	// auto client = dynamic_cast<MinecraftClient*>(minecraft);
 
-    // Own player -> invalid
+	// // Own player -> invalid
-    if (minecraft->player && minecraft->player->entityId == packet->entityId) {
+	// if (client && client->getPlayer() && client->getPlayer()->entityId == packet->entityId) {
-        return;
+	// 	return;
-    }
+	// }
 
 	Entity* entity = level->getEntity(packet->entityId);
 	if (!entity || !entity->isPlayer())
@@ -640,73 +547,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++) {
-		// 	RemoveItemPacket removePacket(packet->playerId, items.at(i).count, items.at(i).getAuxValue(), items.at(i).id);
-		// 	raknetInstance->send(source, removePacket);
-
-		// 	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;
@@ -717,30 +563,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
@@ -751,10 +574,6 @@ void ServerSideNetworkHandler::handle(const RakNet::RakNetGUID& source, UseItemP
 			minecraft->gameMode->useItemOn(player, level, item, packet->x, packet->y, packet->z, packet->face,
 				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");
 
@@ -766,8 +585,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);
 }
@@ -801,11 +618,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;
@@ -821,48 +633,29 @@ 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;
 
-	if (p != minecraft->player)
+	// // if (p != minecraft->player)
-		static_cast<ServerPlayer*>(p)->doCloseContainer();
+	// 	static_cast<ServerPlayer*>(p)->doCloseContainer();
+
+	if (auto sp = dynamic_cast<ServerPlayer*>(p))
+		sp->doCloseContainer();
 }
 
 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;
 
@@ -870,79 +663,11 @@ 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());
@@ -954,25 +679,21 @@ 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 )
 {
-	LOGI("net idi nahui\n");
+	for (unsigned int i = 0; i < level->players.size(); ++i) {
-
+		Player* p = level->players[i];
-	// for (unsigned int i = 0; i < level->players.size(); ++i) {
+		if (p->owner == source) {
-	// 	Player* p = level->players[i];
+			if (packet->health <= -32) {
-	// 	if (p->owner == source) {
+				int diff = packet->health - SetHealthPacket::HEALTH_MODIFY_OFFSET;
-	// 		if (packet->health <= -32) {
+				if (diff > 0) p->hurt(NULL, diff);
-	// 			int diff = packet->health - SetHealthPacket::HEALTH_MODIFY_OFFSET;
+				else if (diff < 0) p->heal(-diff);
-	// 			if (diff > 0) p->hurt(NULL, diff);
+			}
-	// 			else if (diff < 0) p->heal(-diff);
+			break;
-	// 		}
+		}
-	// 		break;
+	}
-	// 	}
-	// }
 }
 
 void ServerSideNetworkHandler::handle( const RakNet::RakNetGUID& source, SignUpdatePacket* packet ) {
@@ -980,8 +701,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;
@@ -997,7 +716,7 @@ void ServerSideNetworkHandler::handle( const RakNet::RakNetGUID& source, SignUpd
 void ServerSideNetworkHandler::allowIncomingConnections( bool doAllow )
 {
 	if (doAllow) {
-		raknetInstance->announceServer(minecraft->options.getStringValue(OPTIONS_USERNAME));
+		raknetInstance->announceServer(minecraft->getServerName());
 	} else {
 		raknetInstance->announceServer("");
 	}

src/network/ServerSideNetworkHandler.h

@@ -58,8 +58,7 @@ 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);
 

src/network/command/CommandServer.cpp

@@ -1,7 +1,8 @@
 #include "CommandServer.h"
-#include "../../client/Minecraft.h"
+#include <Minecraft.h>
 #include "../../world/level/Level.h"
 #include "../../world/entity/Entity.h"
+#include "gamemode/CreatorMode.h"
 
 #ifdef WIN32
 	#define SERR(x) (WSA ## x)
@@ -14,10 +15,8 @@
 #include "../RakNetInstance.h"
 #include "../packet/ChatPacket.h"
 #include "../packet/AdventureSettingsPacket.h"
-#include "../../world/level/LevelSettings.h"
+#include <world/level/LevelSettings.h>
-#include "../../world/entity/player/Player.h"
+#include <world/entity/player/Player.h>
-#include "../../client/gamemode/CreatorMode.h"
-#include "../../client/player/LocalPlayer.h"
 #include "../RakNetInstance.h"
 
 const std::string NullString;
@@ -262,6 +261,7 @@ std::string CommandServer::parse(ConnectedClient& client, const std::string& s)
 		return ToStringOk(y);
 	}
 
+#if 0
 	//
 	// Player related get, set and query
 	//
@@ -316,6 +316,7 @@ std::string CommandServer::parse(ConnectedClient& client, const std::string& s)
 		apiPosTranslate.to(x, y, z);
 		return ToStringOk(x, y, z);
 	}
+#endif
 
 	//
 	// Entity
@@ -385,6 +386,7 @@ std::string CommandServer::parse(ConnectedClient& client, const std::string& s)
 		return NullString;
 	}
 
+#if 0
 	//
 	// Camera
 	//
@@ -430,6 +432,7 @@ std::string CommandServer::parse(ConnectedClient& client, const std::string& s)
 		e->moveTo((float)x + 0.5f, (float)y, (float)z + 0.5f, e->yRot, e->xRot);
 		return NullString;
 	}
+#endif
 
 	//
 	// Entities
@@ -445,6 +448,8 @@ std::string CommandServer::parse(ConnectedClient& client, const std::string& s)
 		return s.str();
 	}
 
+
+#if 0
 	//
 	// Set and restore Checkpoint
 	//
@@ -478,6 +483,7 @@ std::string CommandServer::parse(ConnectedClient& client, const std::string& s)
 		}
 		return success? NullString : Fail;
 	}
+#endif
 
 	//
 	// Event queries
@@ -540,9 +546,9 @@ void CommandServer::tick() {
 	_updateClients();
 	++t;
 
-	if (mc->cameraTargetPlayer == camera) {
+	// if (mc->cameraTargetPlayer == camera) {
-		camera->tick();
+	// 	camera->tick();
-	}
+	// }
 }
 
 void CommandServer::_updateAccept() {
@@ -587,9 +593,9 @@ bool CommandServer::_updateClient(ConnectedClient& client) {
 }
 
 void CommandServer::dispatchPacket( Packet& p ) {
-	if (!mc->netCallback || !mc->player) return;
+	// if (!mc->netCallback || !mc->player) return;
-	const RakNet::RakNetGUID& guid = ((Player*)mc->player)->owner;
+	// const RakNet::RakNetGUID& guid = ((Player*)mc->player)->owner;
-	mc->raknetInstance->send(p);
+	// mc->raknetInstance->send(p);
 	//p.handle(guid, mc->netCallback);
 }
 
@@ -608,6 +614,7 @@ std::string CommandServer::handleEventPollMessage( ConnectedClient& client, cons
 	if (cmd == "events.block.hits") {
 		ICreator::EventList<ICreator::TileEvent>& events = c->getTileEvents();
 		std::stringstream ss;
+		
 
 		events.write(ss, apiPosTranslate, client.lastPoll_blockHit);
 		client.lastPoll_blockHit = mc->level->getTime();
@@ -630,7 +637,7 @@ std::string CommandServer::handleSetSetting( const std::string& setting, int val
 {
 	bool status = value != 0;
 
-	if (setting == "autojump") mc->player->autoJumpEnabled = status;
+	// if (setting == "autojump") mc->player->autoJumpEnabled = status;
 
 	AdventureSettingsPacket::Flags flag = (AdventureSettingsPacket::Flags)0;
 	if (setting == "nametags_visible") flag = AdventureSettingsPacket::ShowNameTags;

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,12 +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;
 }
 
 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/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__*/