Merge remote-tracking branch 'refs/remotes/origin/dedicated-rewrite' into dedicated-rewrite

Reviewed-on: https://192.168.0.2:3000/Kolyah35/minecraft-pe-0.6.1/pulls/13

CMakeLists.txt

@@ -111,7 +111,6 @@ 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/client/Minecraft.cpp

@@ -726,6 +726,21 @@ void Minecraft::tickInput() {
 			if (key == Keyboard::KEY_F3) {
 				options.toggle(OPTIONS_RENDER_DEBUG);
 			}
+			
+			// TODO: replace it with client /give command :face_vomiting:
+			if (key == Keyboard::KEY_F4) {
+				player->inventory->add(new ItemInstance(Tile::redBrick));
+				player->inventory->add(new ItemInstance(Item::ironIngot, 64));
+				player->inventory->add(new ItemInstance(Item::ironIngot, 34));
+				player->inventory->add(new ItemInstance(Tile::stonecutterBench));
+				player->inventory->add(new ItemInstance(Tile::workBench));
+				player->inventory->add(new ItemInstance(Tile::furnace));
+				player->inventory->add(new ItemInstance(Tile::wood, 54));
+				player->inventory->add(new ItemInstance(Item::stick, 14));
+				player->inventory->add(new ItemInstance(Item::coal, 31));
+				player->inventory->add(new ItemInstance(Tile::sand, 6));
+
+			}
 
 			if (key == Keyboard::KEY_F5) {
 				options.toggle(OPTIONS_THIRD_PERSON_VIEW);

src/client/Minecraft.h

@@ -120,6 +120,8 @@ public:
 	void optionUpdated(OptionId option, bool value);
 	void optionUpdated(OptionId option, float value);
 	void optionUpdated(OptionId option, int value);
+
+	int getTicks() { return ticks; }
 #ifdef __APPLE__
     bool _isSuperFast;
     bool isSuperFast() { return _isSuperFast; }
@@ -197,7 +199,8 @@ public:
 	std::string externalCacheStoragePath;
 protected:
 	Timer timer;
-    // @note @attn @warn: this is dangerous as fuck!
+
+	// @note @attn @warn: this is dangerous as fuck!
 	volatile bool isGeneratingLevel;
 	bool _hasSignaledGeneratingLevelFinished;
 

src/client/gamemode/CreativeMode.cpp

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

@@ -1,27 +1,26 @@
-#ifndef NET_MINECRAFT_CLIENT_GAMEMODE__CreativeMode_H__
+#ifndef NET_MINECRAFT_CLIENT_GAMEMODE__CreativeMode_H__
-#define NET_MINECRAFT_CLIENT_GAMEMODE__CreativeMode_H__
+#define NET_MINECRAFT_CLIENT_GAMEMODE__CreativeMode_H__
-
+
-//package net.minecraft.client.gamemode;
+//package net.minecraft.client.gamemode;
-
+
-#include "GameMode.h"
+#include "GameMode.h"
-
+
-class CreativeMode: public GameMode
+class CreativeMode: public GameMode
-{
+{
-	typedef GameMode super;
+	typedef GameMode super;
-public:
+public:
-    CreativeMode(Minecraft* minecraft);
+    CreativeMode(Minecraft* minecraft);
-
+
-    void startDestroyBlock(int x, int y, int z, int face);
+    void startDestroyBlock(int x, int y, int z, int face);
-    void continueDestroyBlock(int x, int y, int z, int face);
+    void continueDestroyBlock(int x, int y, int z, int face);
-    void stopDestroyBlock();
+    void stopDestroyBlock();
-
+
-	bool isCreativeType();
+	bool isCreativeType();
-
+
-	void initAbilities(Abilities& abilities);
+	void initAbilities(Abilities& abilities);
-
+
-	void releaseUsingItem(Player* player);
+private:
-private:
+	void creativeDestroyBlock(int x, int y, int z, int face);
-	void creativeDestroyBlock(int x, int y, int z, int face);
+};
-};
+
-
+#endif /*NET_MINECRAFT_CLIENT_GAMEMODE__CreativeMode_H__*/
-#endif /*NET_MINECRAFT_CLIENT_GAMEMODE__CreativeMode_H__*/

src/client/gamemode/CreatorMode.cpp

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

src/client/gamemode/CreatorMode.h

@@ -1,61 +1,61 @@
-#ifndef NET_MINECRAFT_CLIENT_GAMEMODE__CreatorMode_H__
+#ifndef NET_MINECRAFT_CLIENT_GAMEMODE__CreatorMode_H__
-#define NET_MINECRAFT_CLIENT_GAMEMODE__CreatorMode_H__
+#define NET_MINECRAFT_CLIENT_GAMEMODE__CreatorMode_H__
-
+
-//package net.minecraft.client.gamemode;
+//package net.minecraft.client.gamemode;
-
+
-#include "GameMode.h"
+#include "GameMode.h"
-#include "../../world/PosTranslator.h"
+#include "../../world/PosTranslator.h"
-
+
-class ICreator {
+class ICreator {
-public:
+public:
-	virtual ~ICreator() {}
+	virtual ~ICreator() {}
-
+
-	struct TileEvent {
+	struct TileEvent {
-		int entityId;
+		int entityId;
-		int x, y, z;
+		int x, y, z;
-		int face;
+		int face;
-
+
-		void write(std::stringstream& ss, IPosTranslator& t) const {
+		void write(std::stringstream& ss, IPosTranslator& t) const {
-			int xx = x, yy = y, zz = z;
+			int xx = x, yy = y, zz = z;
-			t.to(xx, yy, zz);
+			t.to(xx, yy, zz);
-			ss << xx << "," << yy << "," << zz << "," << face << "," << entityId;
+			ss << xx << "," << yy << "," << zz << "," << face << "," << entityId;
-		}
+		}
-	};
+	};
-
+
-	template <class T>
+	template <class T>
-	class EventList {
+	class EventList {
-	public:
+	public:
-		EventList(int size) {
+		EventList(int size) {
-			_events.reserve(size);
+			_events.reserve(size);
-			_maxSize = (int)size;
+			_maxSize = (int)size;
-			clear();
+			clear();
-		}
+		}
-		void clear() {
+		void clear() {
-			_index = -1;
+			_index = -1;
-			_size = 0;
+			_size = 0;
-		}
+		}
-		void add(const T& item, int tick) {
+		void add(const T& item, int tick) {
-			if (_size < _maxSize) {
+			if (_size < _maxSize) {
-				_events.push_back(Item());
+				_events.push_back(Item());
-				++_size;
+				++_size;
-			}
+			}
-			Item& e = _events[_nextIndex()];
+			Item& e = _events[_nextIndex()];
-			e.item = item;
+			e.item = item;
-			e.timestamp = tick;
+			e.timestamp = tick;
-		}
+		}
-		int size() const {
+		int size() const {
-			return _size;
+			return _size;
-		}
+		}
-
+
-		const T& operator[](int i) const {
+		const T& operator[](int i) const {
-			return _events[_getIndex(i)].item;
+			return _events[_getIndex(i)].item;
-		}
+		}
-
+
-		T& operator[](int i) {
+		T& operator[](int i) {
-			return _events[_getIndex(i)].item;
+			return _events[_getIndex(i)].item;
-		}
+		}
-
+
-		void write(std::stringstream& ss, IPosTranslator& t, int minTimetamp) const {
+		void write(std::stringstream& ss, IPosTranslator& t, int minTimetamp) const {
 			int i = _getFirstNewerIndex(minTimetamp);
 			if (i < 0)
 				return;
@@ -66,63 +66,62 @@ public:
 				ss << "|";
 				if (++i == _size) i = 0;
 			}
-		}
+		}
-
+
-	private:
+	private:
-		int _getIndex(int i) const { return (1 + _index + i) % _size; }
+		int _getIndex(int i) const { return (1 + _index + i) % _size; }
-		int _nextIndex() {
+		int _nextIndex() {
-			if (++_index == _size) _index = 0;
+			if (++_index == _size) _index = 0;
-			return _index;
+			return _index;
-		}
+		}
-
+
-		int _getFirstNewerIndex(int timestamp) const {
+		int _getFirstNewerIndex(int timestamp) const {
-			for (int i = _index + 1, j = 0; j < _size; ++i, ++j) {
+			for (int i = _index + 1, j = 0; j < _size; ++i, ++j) {
-				if (i == _size) i = 0;
+				if (i == _size) i = 0;
-				if (_events[i].timestamp >= timestamp) return i;
+				if (_events[i].timestamp >= timestamp) return i;
-			}
+			}
-			return -1;
+			return -1;
-		}
+		}
-		struct Item {
+		struct Item {
-			int timestamp;
+			int timestamp;
-			T item;
+			T item;
-		};
+		};
-
+
-		int _index;
+		int _index;
-		int _size;
+		int _size;
-		int _maxSize;
+		int _maxSize;
-		std::vector<Item> _events;
+		std::vector<Item> _events;
-	};
+	};
-
+
-	virtual EventList<TileEvent>& getTileEvents() = 0;
+	virtual EventList<TileEvent>& getTileEvents() = 0;
-};
+};
-
+
-class Creator;
+class Creator;
-
+
-class CreatorMode: public GameMode
+class CreatorMode: public GameMode
-{
+{
-	typedef GameMode super;
+	typedef GameMode super;
-public:
+public:
-    CreatorMode(Minecraft* minecraft);
+    CreatorMode(Minecraft* minecraft);
-	~CreatorMode();
+	~CreatorMode();
-
+
-    void startDestroyBlock(int x, int y, int z, int face);
+    void startDestroyBlock(int x, int y, int z, int face);
-    void continueDestroyBlock(int x, int y, int z, int face);
+    void continueDestroyBlock(int x, int y, int z, int face);
-    void stopDestroyBlock();
+    void stopDestroyBlock();
-
+
-	bool useItemOn(Player* player, Level* level, ItemInstance* item, int x, int y, int z, int face, const Vec3& hit);
+	bool useItemOn(Player* player, Level* level, ItemInstance* item, int x, int y, int z, int face, const Vec3& hit);
-
+
-	void tick();
+	void tick();
-	ICreator* getCreator();
+	ICreator* getCreator();
-
+
-	bool isCreativeType();
+	bool isCreativeType();
-
+
-	void initAbilities(Abilities& abilities);
+	void initAbilities(Abilities& abilities);
-
+
-	void releaseUsingItem(Player* player);
+private:
-private:
+	void CreatorDestroyBlock(int x, int y, int z, int face);
-	void CreatorDestroyBlock(int x, int y, int z, int face);
+
-
+	Creator* _creator;
-	Creator* _creator;
+};
-};
+
-
+#endif /*NET_MINECRAFT_CLIENT_GAMEMODE__CreatorMode_H__*/
-#endif /*NET_MINECRAFT_CLIENT_GAMEMODE__CreatorMode_H__*/

src/client/gamemode/GameMode.cpp

@@ -1,174 +1,174 @@
-#include "GameMode.h"
+#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 "../player/LocalPlayer.h"
-#include "client/Options.h"
+#include "client/Options.h"
-#ifndef STANDALONE_SERVER
+#ifndef STANDALONE_SERVER
-#include "../sound/SoundEngine.h"
+#include "../sound/SoundEngine.h"
-#include "../particle/ParticleEngine.h"
+#include "../particle/ParticleEngine.h"
-#endif
+#endif
-#include "../../network/RakNetInstance.h"
+#include "../../network/RakNetInstance.h"
-#include "../../network/packet/RemoveBlockPacket.h"
+#include "../../network/packet/RemoveBlockPacket.h"
-#ifndef STANDALONE_SERVER
+#ifndef STANDALONE_SERVER
-#include "../renderer/LevelRenderer.h"
+#include "../renderer/LevelRenderer.h"
-#endif
+#endif
-#include "../../world/level/material/Material.h"
+#include "../../world/level/material/Material.h"
-
+
-GameMode::GameMode( Minecraft* minecraft)
+GameMode::GameMode( Minecraft* minecraft)
-:	minecraft(minecraft),
+:	minecraft(minecraft),
-	destroyProgress(0),
+	destroyProgress(0),
-	oDestroyProgress(0),
+	oDestroyProgress(0),
-	destroyTicks(0),
+	destroyTicks(0),
-	destroyDelay(0)
+	destroyDelay(0)
-{
+{
-}
+}
-
+
-/*virtual*/
+/*virtual*/
-Player* GameMode::createPlayer(Level* level) {
+Player* GameMode::createPlayer(Level* level) {
-    return new LocalPlayer(minecraft, level, minecraft->options.getStringValue(OPTIONS_USERNAME), level->dimension->id, isCreativeType());
+    return new LocalPlayer(minecraft, level, minecraft->options.getStringValue(OPTIONS_USERNAME), level->dimension->id, isCreativeType());
-}
+}
-
+
-/*virtual*/
+/*virtual*/
-void GameMode::interact(Player* player, Entity* entity) {
+void GameMode::interact(Player* player, Entity* entity) {
-    player->interact(entity);
+    player->interact(entity);
-}
+}
-
+
-/*virtual*/
+/*virtual*/
-void GameMode::attack(Player* player, Entity* entity) {
+void GameMode::attack(Player* player, Entity* entity) {
-	if (minecraft->level->adventureSettings.noPvP && entity->isPlayer())
+	if (minecraft->level->adventureSettings.noPvP && entity->isPlayer())
-		return;
+		return;
-	if (minecraft->level->adventureSettings.noPvM && entity->isMob())
+	if (minecraft->level->adventureSettings.noPvM && entity->isMob())
-		return;
+		return;
-    player->attack(entity);
+    player->attack(entity);
-}
+}
-
+
-/* virtual */
+/* virtual */
-void GameMode::startDestroyBlock( int x, int y, int z, int face ) {
+void GameMode::startDestroyBlock( int x, int y, int z, int face ) {
-	if(minecraft->player->getCarriedItem() != NULL && minecraft->player->getCarriedItem()->id == Item::bow->id)
+	if(minecraft->player->getCarriedItem() != NULL && minecraft->player->getCarriedItem()->id == Item::bow->id)
-		return;
+		return;
-	destroyBlock(x, y, z, face);
+	destroyBlock(x, y, z, face);
-}
+}
-
+
-/*virtual*/
+/*virtual*/
-bool GameMode::destroyBlock(int x, int y, int z, int face) {
+bool GameMode::destroyBlock(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)];
+    Tile* oldTile = Tile::tiles[level->getTile(x, y, z)];
-	if (!oldTile)
+	if (!oldTile)
-		return false;
+		return false;
-
+
-    if (level->adventureSettings.immutableWorld) {
+    if (level->adventureSettings.immutableWorld) {
-        if (oldTile != (Tile*)Tile::leaves
+        if (oldTile != (Tile*)Tile::leaves
-         && oldTile->material != Material::plant) {
+         && oldTile->material != Material::plant) {
-             return false;
+             return false;
-        }
+        }
-    }
+    }
-#ifndef STANDALONE_SERVER
+#ifndef STANDALONE_SERVER
-	minecraft->particleEngine->destroy(x, y, z);
+	minecraft->particleEngine->destroy(x, y, z);
-#endif
+#endif
-	int data = level->getData(x, y, z);
+	int data = level->getData(x, y, z);
-    bool changed = level->setTile(x, y, z, 0);
+    bool changed = level->setTile(x, y, z, 0);
-    if (changed) {
+    if (changed) {
-#ifndef STANDALONE_SERVER
+#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);
+        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
+#endif
-        oldTile->destroy(level, x, y, z, data);
+        oldTile->destroy(level, x, y, z, data);
-		if (minecraft->options.getBooleanValue(OPTIONS_DESTROY_VIBRATION)) minecraft->platform()->vibrate(24);
+		if (minecraft->options.getBooleanValue(OPTIONS_DESTROY_VIBRATION)) minecraft->platform()->vibrate(24);
-
+
-		if (minecraft->isOnline()) {
+		if (minecraft->isOnline()) {
-			RemoveBlockPacket packet(minecraft->player, x, y, z);
+			RemoveBlockPacket packet(minecraft->player, x, y, z);
-			minecraft->raknetInstance->send(packet);
+			minecraft->raknetInstance->send(packet);
-		}
+		}
-	}
+	}
-    return changed;
+    return changed;
-}
+}
-/*virtual*/
+/*virtual*/
-bool GameMode::useItemOn(Player* player, Level* level, ItemInstance* item, int x, int y, int z, int face, const Vec3& hit) {
+bool GameMode::useItemOn(Player* player, Level* level, ItemInstance* item, int x, int y, int z, int face, const Vec3& hit) {
-	float clickX = hit.x - x;
+	float clickX = hit.x - x;
-	float clickY = hit.y - y;
+	float clickY = hit.y - y;
-	float clickZ = hit.z - z;
+	float clickZ = hit.z - z;
-	item = player->inventory->getSelected();
+	if (level->isClientSide) {
-	if(level->isClientSide) {
+		item = player->inventory->getSelected();
-		UseItemPacket packet(x, y, z, face, item, player->entityId, clickX, clickY, clickZ);
+		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);
+    int t = level->getTile(x, y, z);
-	if (t == Tile::invisible_bedrock->id) return false;
+	if (t == Tile::invisible_bedrock->id) return false;
-    if (t > 0 && Tile::tiles[t]->use(level, x, y, z, player))
+    if (t > 0 && Tile::tiles[t]->use(level, x, y, z, player))
-		return true;
+		return true;
-
+
-	if (item == NULL) return false;
+	if (item == NULL) return false;
-	if(isCreativeType()) {
+	if(isCreativeType()) {
-		int aux = item->getAuxValue();
+		int aux = item->getAuxValue();
-		int count = item->count;
+		int count = item->count;
-		bool success = item->useOn(player, level, x, y, z, face, clickX, clickY, clickZ);
+		bool success = item->useOn(player, level, x, y, z, face, clickX, clickY, clickZ);
-		item->setAuxValue(aux);
+		item->setAuxValue(aux);
-		item->count = count;
+		item->count = count;
-		return success;
+		return success;
-	} else {
+	} else {
-		return item->useOn(player, level, x, y, z, face, clickX, clickY, clickZ);
+		return item->useOn(player, level, x, y, z, face, clickX, clickY, clickZ);
-	}
+	}
-}
+}
-
+
-bool GameMode::useItem( Player* player, Level* level, ItemInstance* item ) {
+bool GameMode::useItem( Player* player, Level* level, ItemInstance* item ) {
-	int oldCount = item->count;
+	int oldCount = item->count;
-
+
-	ItemInstance* itemInstance = item->use(level, player);
+	ItemInstance* itemInstance = item->use(level, player);
-	if(level->isClientSide) {
+	if(level->isClientSide) {
-		UseItemPacket packet(item, player->entityId, player->aimDirection);
+		UseItemPacket packet(item, player->entityId, player->aimDirection);
-		minecraft->raknetInstance->send(packet);
+		minecraft->raknetInstance->send(packet);
-	}
+	}
-	if (itemInstance != item || (itemInstance != NULL && itemInstance->count != oldCount)) {
+	if (itemInstance != item || (itemInstance != NULL && itemInstance->count != oldCount)) {
-	    //player.inventory.items[player.inventory.selected] = itemInstance;
+	    //player.inventory.items[player.inventory.selected] = itemInstance;
-	    //if (itemInstance.count == 0) {
+	    //if (itemInstance.count == 0) {
-	    //    player.inventory.items[player.inventory.selected] = NULL;
+	    //    player.inventory.items[player.inventory.selected] = NULL;
-	    //}
+	    //}
-	    return true;
+	    return true;
-	}
+	}
-	return false;
+	return false;
-}
+}
-
+
-ItemInstance* GameMode::handleInventoryMouseClick( int containerId, int slotNum, int buttonNum, Player* player ) {
+ItemInstance* GameMode::handleInventoryMouseClick( int containerId, int slotNum, int buttonNum, Player* player ) {
-	//return player.containerMenu.clicked(slotNum, buttonNum, player);
+	//return player.containerMenu.clicked(slotNum, buttonNum, player);
-	return NULL;
+	return NULL;
-}
+}
-
+
-void GameMode::handleCloseInventory( int containerId, Player* player ) {
+void GameMode::handleCloseInventory( int containerId, Player* player ) {
-	//player.containerMenu.removed(player);
+	//player.containerMenu.removed(player);
-	//player.containerMenu = player.inventoryMenu;
+	//player.containerMenu = player.inventoryMenu;
-}
+}
-
+
-float GameMode::getPickRange() {
+float GameMode::getPickRange() {
-	return 5.0f;
+	return 5.0f;
-}
+}
-
+
-void GameMode::initPlayer( Player* player ) {
+void GameMode::initPlayer( Player* player ) {
-	initAbilities(player->abilities);
+	initAbilities(player->abilities);
-}
+}
-
+
-void GameMode::releaseUsingItem(Player* player){
+void GameMode::releaseUsingItem(Player* player){
-	if(minecraft->level->isClientSide) {
+	if (minecraft->level->isClientSide && player->isUsingItem()) {
-		PlayerActionPacket packet(PlayerActionPacket::RELEASE_USE_ITEM,  0, 0, 0, 0, player->entityId);
+		PlayerActionPacket packet(PlayerActionPacket::RELEASE_USE_ITEM,  0, 0, 0, 0, player->entityId);
-		minecraft->raknetInstance->send(packet);
+		minecraft->raknetInstance->send(packet);
-	}
+	}
-	player->releaseUsingItem();
+	player->releaseUsingItem();
-}
+}
-
+
-void GameMode::tick() {
+void GameMode::tick() {
-	oDestroyProgress = destroyProgress;
+	oDestroyProgress = destroyProgress;
-}
+}
-
+
-void GameMode::render( float a ) {
+void GameMode::render( float a ) {
-#ifndef STANDALONE_SERVER
+#ifndef STANDALONE_SERVER
-	if (destroyProgress <= 0) {
+	if (destroyProgress <= 0) {
-		minecraft->gui.progress = 0;
+		minecraft->gui.progress = 0;
-		minecraft->levelRenderer->destroyProgress = 0;
+		minecraft->levelRenderer->destroyProgress = 0;
-	} else {
+	} else {
-		float dp = oDestroyProgress + (destroyProgress - oDestroyProgress) * a;
+		float dp = oDestroyProgress + (destroyProgress - oDestroyProgress) * a;
-		minecraft->gui.progress = dp;
+		minecraft->gui.progress = dp;
-		minecraft->levelRenderer->destroyProgress = dp;
+		minecraft->levelRenderer->destroyProgress = dp;
-	}
+	}
-#endif
+#endif
-}
+}

src/client/gamemode/SurvivalMode.cpp

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

src/client/gui/components/ScrollingPane.cpp

@@ -20,6 +20,9 @@ static const float kMinimumTrackingForDrag = 5;
 static const float kMinIndicatorLength = 34.0f / 3;
 static const float PKScrollIndicatorEndSize = 3;
 static const float PKScrollIndicatorThickness = 7.0f /3;
+static const float kWheelOverscrollMax = 80.0f;
+static const float kWheelOverscrollDamping = 0.6f;
+static const float kWheelOverscrollRestoreAlpha = 0.18f;
 
 ScrollingPane::ScrollingPane(
 		int optionFlags,
@@ -70,13 +73,19 @@ ScrollingPane::ScrollingPane(
 	}
 	//LOGI("%d, %d :: %d\n", bbox.w, itemBbox.w, this->columns);
 
-	rows = 1 + (numItems-1) / this->columns,
+	rows = 1 + (numItems-1) / this->columns;
 
 	/*
 	if (columns * itemBbox.w <= bbox.w) flags |= SF_LockX;
 	if (rows    * itemBbox.h <= bbox.h) flags |= SF_LockY;
 	*/
 
+	// initialize content bounds immediately
+	adjustContentSize();
+	minPoint.set((float)(this->size.w - this->adjustedContentSize.w), (float)(this->size.h - this->adjustedContentSize.h), 0);
+	this->snapContentOffsetToBounds(false);
+
+
 	dragDeltas.reserve(128);
 
 	te_moved = 0;
@@ -114,6 +123,34 @@ void ScrollingPane::tick() {
 		updateScrollFade(vScroll);
 		updateScrollFade(hScroll);
 	}
+
+	if (isNotSet(SF_HardLimits) && !Mouse::isButtonDown(MouseAction::ACTION_LEFT) && !dragging && !tracking && !decelerating) {
+		float targetX = _contentOffset.x;
+		float targetY = _contentOffset.y;
+		bool corrected = false;
+
+		if (targetX > 0.0f) {
+			targetX = Mth::lerp(targetX, 0.0f, kWheelOverscrollRestoreAlpha);
+			corrected = true;
+		} else if (targetX < minPoint.x) {
+			targetX = Mth::lerp(targetX, minPoint.x, kWheelOverscrollRestoreAlpha);
+			corrected = true;
+		}
+
+		if (targetY > 0.0f) {
+			targetY = Mth::lerp(targetY, 0.0f, kWheelOverscrollRestoreAlpha);
+			corrected = true;
+		} else if (targetY < minPoint.y) {
+			targetY = Mth::lerp(targetY, minPoint.y, kWheelOverscrollRestoreAlpha);
+			corrected = true;
+		}
+
+		if (corrected) {
+			if (Mth::abs(targetX - _contentOffset.x) < 0.25f) targetX = (targetX > 0.0f ? 0.0f : (targetX < minPoint.x ? minPoint.x : targetX));
+			if (Mth::abs(targetY - _contentOffset.y) < 0.25f) targetY = (targetY > 0.0f ? 0.0f : (targetY < minPoint.y ? minPoint.y : targetY));
+			setContentOffset(Vec3(targetX, targetY, 0));
+		}
+	}
 }
 
 bool ScrollingPane::getGridItemFor_slow(int itemIndex, GridItem& out) {
@@ -549,11 +586,39 @@ void ScrollingPane::stepThroughDecelerationAnimation(bool noAnimation) {
 }
 
 void ScrollingPane::scrollBy(float dx, float dy) {
-	// adjust the translation offsets fpx/fpy by the requested amount
+	// compute target content offset from wheel delta (in screen-space w/ opposite sign)
-	float nfpx = fpx + dx;
+	float targetX = _contentOffset.x - dx;
-	float nfpy = fpy + dy;
+	float targetY = _contentOffset.y - dy;
-	// convert back to content offset (fpx = -contentOffset.x)
+
-	setContentOffset(Vec3(-nfpx, -nfpy, 0));
+	if (isSet(SF_LockX)) targetX = _contentOffset.x;
+	if (isSet(SF_LockY)) targetY = _contentOffset.y;
+
+	if (isSet(SF_HardLimits)) {
+		targetX = Mth::clamp(targetX, minPoint.x, 0.0f);
+		targetY = Mth::clamp(targetY, minPoint.y, 0.0f);
+	} else {
+		if (targetX > 0.0f) {
+			float overshoot = targetX;
+			overshoot = Mth::Min(overshoot, kWheelOverscrollMax);
+			targetX = overshoot * kWheelOverscrollDamping;
+		} else if (targetX < minPoint.x) {
+			float overshoot = targetX - minPoint.x;
+			overshoot = Mth::Max(overshoot, -kWheelOverscrollMax);
+			targetX = minPoint.x + overshoot * kWheelOverscrollDamping;
+		}
+
+		if (targetY > 0.0f) {
+			float overshoot = targetY;
+			overshoot = Mth::Min(overshoot, kWheelOverscrollMax);
+			targetY = overshoot * kWheelOverscrollDamping;
+		} else if (targetY < minPoint.y) {
+			float overshoot = targetY - minPoint.y;
+			overshoot = Mth::Max(overshoot, -kWheelOverscrollMax);
+			targetY = minPoint.y + overshoot * kWheelOverscrollDamping;
+		}
+	}
+
+	setContentOffset(Vec3(targetX, targetY, 0));
 }
 
 void ScrollingPane::setContentOffset(float x, float y) {

src/client/gui/screens/CreditsScreen.cpp

@@ -28,6 +28,7 @@ void CreditsScreen::init() {
     buttons.push_back(bHeader);
     buttons.push_back(btnBack);
 
+    // TODO: rewrite it
     // prepare text lines
     _lines.clear();
     _lines.push_back("Minecraft: Pocket Edition");
@@ -39,6 +40,7 @@ void CreditsScreen::init() {
     _lines.push_back("Kolyah35");
     _lines.push_back("karson");
     _lines.push_back("deepfriedwaffles");
+    _lines.push_back("EpikIzCool");
     _lines.push_back("");
     // avoid color tags around the URL so it isn't mangled by the parser please
     _lines.push_back("Join our Discord server: https://discord.gg/c58YesBxve");

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

@@ -16,7 +16,12 @@
 #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;
 
@@ -193,6 +198,26 @@ 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();
 }
 
@@ -439,25 +464,29 @@ 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

@@ -1,291 +1,293 @@
-#include "TouchIngameBlockSelectionScreen.h"
+#include "TouchIngameBlockSelectionScreen.h"
-#include "../crafting/WorkbenchScreen.h"
+#include "../crafting/WorkbenchScreen.h"
-#include "../../Screen.h"
+#include "../../Screen.h"
-#include "../../components/ImageButton.h"
+#include "../../components/ImageButton.h"
-#include "../../components/InventoryPane.h"
+#include "../../components/InventoryPane.h"
-#include "../../../gamemode/GameMode.h"
+#include "../../../gamemode/GameMode.h"
-#include "../../../renderer/TileRenderer.h"
+#include "../../../renderer/TileRenderer.h"
-#include "../../../player/LocalPlayer.h"
+#include "../../../player/LocalPlayer.h"
-#include "../../../renderer/gles.h"
+#include "../../../renderer/gles.h"
-#include "../../../renderer/entity/ItemRenderer.h"
+#include "../../../renderer/entity/ItemRenderer.h"
-#include "../../../renderer/Tesselator.h"
+#include "../../../renderer/Tesselator.h"
-#include "../../../renderer/Textures.h"
+#include "../../../renderer/Textures.h"
-#include "../../../Minecraft.h"
+#include "../../../Minecraft.h"
-#include "../../../sound/SoundEngine.h"
+#include "../../../sound/SoundEngine.h"
-#include "../../../../world/entity/player/Inventory.h"
+#include "../../../../world/entity/player/Inventory.h"
-#include "../../../../platform/input/Mouse.h"
+#include "../../../../platform/input/Mouse.h"
-#include "../../../../util/Mth.h"
+#include "../../../../util/Mth.h"
-#include "../../../../world/item/ItemInstance.h"
+#include "../../../../world/item/ItemInstance.h"
-#include "../../../../world/entity/player/Player.h"
+#include "../../../../world/entity/player/Player.h"
-#include "../../../../world/item/crafting/Recipe.h"
+#include "../../../../world/item/crafting/Recipe.h"
-#include "../../../player/input/touchscreen/TouchAreaModel.h"
+#include "../../../player/input/touchscreen/TouchAreaModel.h"
-#include "../ArmorScreen.h"
+#include "../ArmorScreen.h"
-
+
-namespace Touch {
+namespace Touch {
-
+
-#if defined(__APPLE__)
+#if defined(__APPLE__)
-    static const std::string demoVersionString("Not available in the Lite version");
+    static const std::string demoVersionString("Not available in the Lite version");
-#else
+#else
-    static const std::string demoVersionString("Not available in the demo version");
+    static const std::string demoVersionString("Not available in the demo version");
-#endif
+#endif
-
+
-#ifdef __APPLE__
+#ifdef __APPLE__
-    static const float BorderPixels = 4;
+    static const float BorderPixels = 4;
-    #ifdef DEMO_MODE
+    #ifdef DEMO_MODE
-        static const float BlockPixels = 22;
+        static const float BlockPixels = 22;
-    #else
+    #else
-        static const float BlockPixels = 22;
+        static const float BlockPixels = 22;
-    #endif
+    #endif
-#else
+#else
-    static const float BorderPixels = 4;
+    static const float BorderPixels = 4;
-    static const float BlockPixels = 24;
+    static const float BlockPixels = 24;
-#endif
+#endif
-
+
-static const int ItemSize = (int)(BlockPixels + 2*BorderPixels);
+static const int ItemSize = (int)(BlockPixels + 2*BorderPixels);
-
+
-static const int Bx = 10; // Border Frame width
+static const int Bx = 10; // Border Frame width
-static const int By = 6; // Border Frame height
+static const int By = 6; // Border Frame height
-    
+    
-//
+//
-// Block selection screen
+// Block selection screen
-//
+//
-IngameBlockSelectionScreen::IngameBlockSelectionScreen() 
+IngameBlockSelectionScreen::IngameBlockSelectionScreen() 
-:	selectedItem(0),
+:	selectedItem(0),
-	_blockList(NULL),
+	_blockList(NULL),
-	_pendingClose(false),
+	_pendingClose(false),
-	bArmor  (4, "Armor"),
+	bArmor  (4, "Armor"),
-	bDone   (3, ""),
+	bDone   (3, ""),
-	//bDone   (3, "Done"),
+	//bDone   (3, "Done"),
-	bMenu   (2, "Menu"),
+	bMenu   (2, "Menu"),
-	bCraft  (1, "Craft"),
+	bCraft  (1, "Craft"),
-	bHeader (0, "Select blocks")
+	bHeader (0, "Select blocks")
-{
+{
-}
+}
-
+
-IngameBlockSelectionScreen::~IngameBlockSelectionScreen()
+IngameBlockSelectionScreen::~IngameBlockSelectionScreen()
-{
+{
-	delete _blockList;
+	delete _blockList;
-}
+}
-
+
-void IngameBlockSelectionScreen::init()
+void IngameBlockSelectionScreen::init()
-{
+{
-	Inventory* inventory = minecraft->player->inventory;
+	Inventory* inventory = minecraft->player->inventory;
-
+
-	//const int itemWidth = 2 * BorderPixels + 
+	//const int itemWidth = 2 * BorderPixels + 
-
+
-	int maxWidth = width - Bx - Bx;
+	int maxWidth = width - Bx - Bx;
-	InventoryColumns = maxWidth / ItemSize;
+	InventoryColumns = maxWidth / ItemSize;
-	const int realWidth = InventoryColumns * ItemSize;
+	const int realWidth = InventoryColumns * ItemSize;
-	const int realBx = (width - realWidth) / 2;
+	const int realBx = (width - realWidth) / 2;
-
+
-	IntRectangle rect(realBx,
+	IntRectangle rect(realBx,
-#ifdef __APPLE__
+#ifdef __APPLE__
-		24 + By - ((width==240)?1:0), realWidth, ((width==240)?1:0) + height-By-By-20-24);
+		24 + By - ((width==240)?1:0), realWidth, ((width==240)?1:0) + height-By-By-20-24);
-#else
+#else
-		24 + By, realWidth, height-By-By-20-24);
+		24 + By, realWidth, height-By-By-20-24);
-#endif
+#endif
-
+
-	_blockList = new InventoryPane(this, minecraft, rect, width, BorderPixels, inventory->getContainerSize() - Inventory::MAX_SELECTION_SIZE, ItemSize, (int)BorderPixels);
+	_blockList = new InventoryPane(this, minecraft, rect, width, BorderPixels, inventory->getContainerSize() - Inventory::MAX_SELECTION_SIZE, ItemSize, (int)BorderPixels);
-	_blockList->fillMarginX = realBx;
+	_blockList->fillMarginX = realBx;
-
+
-	//for (int i = 0; i < inventory->getContainerSize(); ++i)
+	//for (int i = 0; i < inventory->getContainerSize(); ++i)
-		//LOGI("> %d - %s\n", i, inventory->getItem(i)? inventory->getItem(i)->getDescriptionId().c_str() : "<-->\n");
+		//LOGI("> %d - %s\n", i, inventory->getItem(i)? inventory->getItem(i)->getDescriptionId().c_str() : "<-->\n");
-
+
-	InventorySize = inventory->getContainerSize();
+	// Grid indices are 0..N-1 for main inventory only; slots 0..MAX_SELECTION_SIZE-1 are hotbar links.
-	InventoryRows = 1 + (InventorySize-1) / InventoryColumns;
+	InventorySize = inventory->getContainerSize() - Inventory::MAX_SELECTION_SIZE;
-
+	InventoryRows = 1 + (InventorySize-1) / InventoryColumns;
-    //
+
-    // Buttons
+    //
-    //
+    // Buttons
-	ImageDef def;
+    //
-	def.name = "gui/spritesheet.png";
+	ImageDef def;
-	def.x = 0;
+	def.name = "gui/spritesheet.png";
-	def.y = 1;
+	def.x = 0;
-	def.width = def.height = 18;
+	def.y = 1;
-	def.setSrc(IntRectangle(60, 0, 18, 18));
+	def.width = def.height = 18;
-	bDone.setImageDef(def, true);
+	def.setSrc(IntRectangle(60, 0, 18, 18));
-    bDone.width = bDone.height = 19;
+	bDone.setImageDef(def, true);
-
+    bDone.width = bDone.height = 19;
-	bDone.scaleWhenPressed = false;
+
-
+	bDone.scaleWhenPressed = false;
-	buttons.push_back(&bHeader);
+
-	buttons.push_back(&bDone);
+	buttons.push_back(&bHeader);
-	if (!minecraft->isCreativeMode()) {
+	buttons.push_back(&bDone);
-		buttons.push_back(&bCraft);
+	if (!minecraft->isCreativeMode()) {
-		buttons.push_back(&bArmor);
+		buttons.push_back(&bCraft);
-	}
+		buttons.push_back(&bArmor);
-}
+	}
-
+}
-void IngameBlockSelectionScreen::setupPositions() {
+
-	bHeader.y = bDone.y = bCraft.y = 0;
+void IngameBlockSelectionScreen::setupPositions() {
-	bDone.x   = width -  bDone.width;
+	bHeader.y = bDone.y = bCraft.y = 0;
-	bCraft.x  = 0;//width - bDone.w - bCraft.w;
+	bDone.x   = width -  bDone.width;
-	bCraft.width = bArmor.width = 48;
+	bCraft.x  = 0;//width - bDone.w - bCraft.w;
-	bArmor.x = bCraft.width;
+	bCraft.width = bArmor.width = 48;
-
+	bArmor.x = bCraft.width;
-	if (minecraft->isCreativeMode()) {
+
-		bHeader.x = 0;
+	if (minecraft->isCreativeMode()) {
-		bHeader.width = width;// -  bDone.w;
+		bHeader.x = 0;
-		bHeader.xText = width/2; // Center of the screen
+		bHeader.width = width;// -  bDone.w;
-	} else {
+		bHeader.xText = width/2; // Center of the screen
-		bHeader.x = bCraft.width + bArmor.width;
+	} else {
-		bHeader.width = width - bCraft.width - bArmor.width;// -  bDone.w;
+		bHeader.x = bCraft.width + bArmor.width;
-		bHeader.xText = bHeader.x + (bHeader.width - bDone.width) /2;
+		bHeader.width = width - bCraft.width - bArmor.width;// -  bDone.w;
-	}
+		bHeader.xText = bHeader.x + (bHeader.width - bDone.width) /2;
-
+	}
-	clippingArea.x = 0;
+
-	clippingArea.w = minecraft->width;
+	clippingArea.x = 0;
-	clippingArea.y = 0;
+	clippingArea.w = minecraft->width;
-	clippingArea.h = (int)(Gui::GuiScale * 24);
+	clippingArea.y = 0;
-}
+	clippingArea.h = (int)(Gui::GuiScale * 24);
-
+}
-void IngameBlockSelectionScreen::removed()
+
-{
+void IngameBlockSelectionScreen::removed()
-	minecraft->gui.inventoryUpdated();
+{
-}
+	minecraft->gui.inventoryUpdated();
-
+}
-int IngameBlockSelectionScreen::getSlotPosX(int slotX) {
+
-    // @todo: Number of columns
+int IngameBlockSelectionScreen::getSlotPosX(int slotX) {
-	return width / 2 - InventoryColumns * 10 + slotX * 20 + 2;
+    // @todo: Number of columns
-}
+	return width / 2 - InventoryColumns * 10 + slotX * 20 + 2;
-
+}
-int IngameBlockSelectionScreen::getSlotPosY(int slotY) {
+
-	return height - 16 - 3 - 22 * 2 - 22 * slotY;
+int IngameBlockSelectionScreen::getSlotPosY(int slotY) {
-}
+	return height - 16 - 3 - 22 * 2 - 22 * slotY;
-
+}
-int IngameBlockSelectionScreen::getSlotHeight() {
+
-	// same as non-touch implementation
+int IngameBlockSelectionScreen::getSlotHeight() {
-	return 22;
+	// same as non-touch implementation
-}
+	return 22;
-
+}
-void IngameBlockSelectionScreen::mouseClicked(int x, int y, int buttonNum) {
+
-	_pendingClose = _blockList->_clickArea->isInside((float)x, (float)y);
+void IngameBlockSelectionScreen::mouseClicked(int x, int y, int buttonNum) {
-	if (!_pendingClose)
+	_pendingClose = _blockList->_clickArea->isInside((float)x, (float)y);
-		super::mouseClicked(x, y, buttonNum);
+	if (!_pendingClose)
-}
+		super::mouseClicked(x, y, buttonNum);
-
+}
-void IngameBlockSelectionScreen::mouseReleased(int x, int y, int buttonNum) {
+
-	if (_pendingClose && _blockList->_clickArea->isInside((float)x, (float)y))
+void IngameBlockSelectionScreen::mouseReleased(int x, int y, int buttonNum) {
-		minecraft->setScreen(NULL);
+	if (_pendingClose && _blockList->_clickArea->isInside((float)x, (float)y))
-	else
+		minecraft->setScreen(NULL);
-		super::mouseReleased(x, y, buttonNum);
+	else
-}
+		super::mouseReleased(x, y, buttonNum);
-
+}
-void IngameBlockSelectionScreen::mouseWheel(int dx, int dy, int xm, int ym)
+
-{
+void IngameBlockSelectionScreen::mouseWheel(int dx, int dy, int xm, int ym)
-	if (dy == 0) return;
+{
-	if (_blockList) {
+	if (dy == 0) return;
-		float amount = -dy * getSlotHeight();
+	if (_blockList) {
-		_blockList->scrollBy(0, amount);
+		float amount = -dy * getSlotHeight();
-	}
+		_blockList->scrollBy(0, amount);
-	int cols = InventoryColumns;
+	}
-	int maxIndex = InventorySize - 1;
+	int cols = InventoryColumns;
-	int idx = selectedItem;
+	int maxIndex = InventorySize - 1;
-	if (dy > 0) {
+	int idx = selectedItem;
-		if (idx >= cols) idx -= cols;
+	if (dy > 0) {
-	} else {
+		if (idx >= cols) idx -= cols;
-		if (idx + cols <= maxIndex) idx += cols;
+	} else {
-	}
+		if (idx + cols <= maxIndex) idx += cols;
-	selectedItem = idx;
+	}
-}
+	selectedItem = idx;
-
+}
-bool IngameBlockSelectionScreen::addItem(const InventoryPane* pane, int itemId)
+
-{
+bool IngameBlockSelectionScreen::addItem(const InventoryPane* pane, int itemId)
-	Inventory* inventory = minecraft->player->inventory;
+{
-	itemId += Inventory::MAX_SELECTION_SIZE;
+	Inventory* inventory = minecraft->player->inventory;
-
+	itemId += Inventory::MAX_SELECTION_SIZE;
-	if (!inventory->getItem(itemId))
+
-		return false;
+	if (!inventory->getItem(itemId))
-
+		return false;
-	inventory->moveToSelectionSlot(0, itemId, true);
+
-
+	inventory->moveToSelectionSlot(0, itemId, true);
-	inventory->selectSlot(0);
+
-#ifdef __APPLE__
+	inventory->selectSlot(0);
-	minecraft->soundEngine->playUI("random.pop", 0.3f, 0.3f);//1.0f + 0.2f*(Mth::random()-Mth::random()));
+#ifdef __APPLE__
-#else
+	minecraft->soundEngine->playUI("random.pop", 0.3f, 0.3f);//1.0f + 0.2f*(Mth::random()-Mth::random()));
-    minecraft->soundEngine->playUI("random.pop2", 1.0f, 0.3f);//1.0f + 0.2f*(Mth::random()-Mth::random()));
+#else
-#endif
+    minecraft->soundEngine->playUI("random.pop2", 1.0f, 0.3f);//1.0f + 0.2f*(Mth::random()-Mth::random()));
-
+#endif
-	// Flash the selected gui item
+
-	minecraft->gui.flashSlot(inventory->selected);
+	// Flash the selected gui item
-    return true;
+	minecraft->gui.flashSlot(inventory->selected);
-}
+    return true;
-
+}
-void IngameBlockSelectionScreen::tick()
+
-{
+void IngameBlockSelectionScreen::tick()
-	_blockList->tick();
+{
-	super::tick();
+	_blockList->tick();
-}
+	super::tick();
-
+}
-void IngameBlockSelectionScreen::render( int xm, int ym, float a )
+
-{
+void IngameBlockSelectionScreen::render( int xm, int ym, float a )
-	glDisable2(GL_DEPTH_TEST);
+{
-	glEnable2(GL_BLEND);
+	glDisable2(GL_DEPTH_TEST);
-
+	glEnable2(GL_BLEND);
-	Screen::render(xm, ym, a);
+
-	_blockList->render(xm, ym, a);
+	Screen::render(xm, ym, a);
-
+	_blockList->render(xm, ym, a);
-	// render frame
+
-	IntRectangle& bbox = _blockList->rect;
+	// render frame
-	Tesselator::instance.colorABGR(0xffffffff);
+	IntRectangle& bbox = _blockList->rect;
-	minecraft->textures->loadAndBindTexture("gui/itemframe.png");
+	Tesselator::instance.colorABGR(0xffffffff);
-	glEnable2(GL_BLEND);
+	minecraft->textures->loadAndBindTexture("gui/itemframe.png");
-	glColor4f2(1, 1, 1, 1);
+	glEnable2(GL_BLEND);
-	glBlendFunc2(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+	glColor4f2(1, 1, 1, 1);
-	blit(0, bbox.y-By, 0, 0, width, bbox.h+By+By, 215, 256); // why bbox.h + 1*B?
+	glBlendFunc2(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-	glDisable2(GL_BLEND);
+	blit(0, bbox.y-By, 0, 0, width, bbox.h+By+By, 215, 256); // why bbox.h + 1*B?
-
+	glDisable2(GL_BLEND);
-	glEnable2(GL_DEPTH_TEST);
+
-}
+	glEnable2(GL_DEPTH_TEST);
-
+}
-void IngameBlockSelectionScreen::renderDemoOverlay() {
+
-#ifdef DEMO_MODE
+void IngameBlockSelectionScreen::renderDemoOverlay() {
-	fill(	getSlotPosX(0) - 3, getSlotPosY(1) - 3,
+#ifdef DEMO_MODE
-			getSlotPosX(9) - 3, getSlotPosY(-1) - 3, 0xa0 << 24);
+	fill(	getSlotPosX(0) - 3, getSlotPosY(1) - 3,
-
+			getSlotPosX(9) - 3, getSlotPosY(-1) - 3, 0xa0 << 24);
-	const int centerX = (getSlotPosX(4) + getSlotPosX(5)) / 2;
+
-	const int centerY = (getSlotPosY(0) + getSlotPosY(1)) / 2 + 5;
+	const int centerX = (getSlotPosX(4) + getSlotPosX(5)) / 2;
-	drawCenteredString(minecraft->font, demoVersionString, centerX, centerY, 0xffffffff);
+	const int centerY = (getSlotPosY(0) + getSlotPosY(1)) / 2 + 5;
-#endif /*DEMO_MODE*/
+	drawCenteredString(minecraft->font, demoVersionString, centerX, centerY, 0xffffffff);
-}
+#endif /*DEMO_MODE*/
-
+}
-void IngameBlockSelectionScreen::buttonClicked(Button* button) {
+
-	if (button->id == bDone.id)
+void IngameBlockSelectionScreen::buttonClicked(Button* button) {
-		minecraft->setScreen(NULL);
+	if (button->id == bDone.id)
-
+		minecraft->setScreen(NULL);
-    if (button->id == bMenu.id)
+
-        minecraft->screenChooser.setScreen(SCREEN_PAUSE);
+    if (button->id == bMenu.id)
-
+        minecraft->screenChooser.setScreen(SCREEN_PAUSE);
-	if (button->id == bCraft.id)
+
-		minecraft->setScreen(new WorkbenchScreen(Recipe::SIZE_2X2));
+	if (button->id == bCraft.id)
-
+		minecraft->setScreen(new WorkbenchScreen(Recipe::SIZE_2X2));
-	if (button == &bArmor)
+
-		minecraft->setScreen(new ArmorScreen());
+	if (button == &bArmor)
-}
+		minecraft->setScreen(new ArmorScreen());
-
+}
-bool IngameBlockSelectionScreen::isAllowed( int slot )
+
-{
+bool IngameBlockSelectionScreen::isAllowed( int slot )
-	if (slot < 0 || slot >= minecraft->player->inventory->getContainerSize())
+{
-		return false;
+	const int gridCount = minecraft->player->inventory->getContainerSize() - Inventory::MAX_SELECTION_SIZE;
-
+	if (slot < 0 || slot >= gridCount)
-#ifdef DEMO_MODE
+		return false;
-	if (slot >= (minecraft->isCreativeMode()? 28 : 27)) return false;
+
-#endif
+#ifdef DEMO_MODE
-	return true;
+	if (slot >= (minecraft->isCreativeMode()? 28 : 27)) return false;
-}
+#endif
-
+	return true;
-bool IngameBlockSelectionScreen::hasClippingArea( IntRectangle& out )
+}
-{
+
-	out = clippingArea;
+bool IngameBlockSelectionScreen::hasClippingArea( IntRectangle& out )
-	return true;
+{
-}
+	out = clippingArea;
-
+	return true;
-std::vector<const ItemInstance*> IngameBlockSelectionScreen::getItems( const InventoryPane* forPane )
+}
-{
+
-	std::vector<const ItemInstance*> out;
+std::vector<const ItemInstance*> IngameBlockSelectionScreen::getItems( const InventoryPane* forPane )
-	for (int i = Inventory::MAX_SELECTION_SIZE; i < minecraft->player->inventory->getContainerSize(); ++i)
+{
-		out.push_back(minecraft->player->inventory->getItem(i));
+	std::vector<const ItemInstance*> out;
-	return out;
+	for (int i = Inventory::MAX_SELECTION_SIZE; i < minecraft->player->inventory->getContainerSize(); ++i)
-}
+		out.push_back(minecraft->player->inventory->getItem(i));
-
+	return out;
-}
+}
+
+}

src/client/player/LocalPlayer.cpp

@@ -388,6 +388,12 @@ void LocalPlayer::calculateFlight(float xa, float ya, float za) {
     ya = 0;
     za = za * flySpeed;
 
+    if (sprinting) {
+        float sprintBoost = getWalkingSpeedModifier(); // 1.3x
+        xa *= sprintBoost;
+        za *= sprintBoost;
+    }
+
 #ifdef ANDROID
     if (Keyboard::isKeyDown(103)) ya = .2f * flySpeed;
     if (Keyboard::isKeyDown(102)) ya = -.2f * flySpeed;
@@ -450,7 +456,7 @@ void LocalPlayer::tick() {
 		{
 			sentInventoryItemId   = newItemId;
 			sentInventoryItemData = newItemData;
-			PlayerEquipmentPacket packet(entityId, newItemId, newItemData);
+			PlayerEquipmentPacket packet(entityId, newItemId, newItemData, inventory->selected, inventory->getSlot(newItemId, newItemData));
 			minecraft->raknetInstance->send(packet);
 		}
 	}
@@ -506,7 +512,7 @@ void LocalPlayer::aiStep() {
 		if (sprintDoubleTapTimer > 0) sprintDoubleTapTimer--;
 		prevForwardHeld = forwardHeld;
 	}
-	if (input->sneaking || abilities.flying)
+	if (input->sneaking)
 		sprinting = false;
 
     if (input->sneaking) {

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/network/ClientSideNetworkHandler.cpp

@@ -1,6 +1,7 @@
 
 #include "ClientSideNetworkHandler.h"
 #include "client/Options.h"
+#include "network/packet/LoginStatusPacket.h"
 #include "packet/PacketInclude.h"
 #include "RakNetInstance.h"
 #include "../world/level/chunk/ChunkSource.h"
@@ -10,6 +11,7 @@
 #include "../world/entity/player/Inventory.h"
 #include "../client/Minecraft.h"
 #include "../client/gamemode/GameMode.h"
+#include "world/item/ItemInstance.h"
 #ifndef STANDALONE_SERVER
 #include "../client/gui/screens/DisconnectionScreen.h"
 #endif
@@ -86,7 +88,7 @@ void ClientSideNetworkHandler::onConnect(const RakNet::RakNetGUID& hostGuid)
 	serverGuid = hostGuid;
 
 	clearChunksLoaded();
-	LoginPacket packet(minecraft->options.getStringValue(OPTIONS_USERNAME).c_str(), SharedConstants::NetworkProtocolVersion);
+	LoginPacket packet(minecraft->options.getStringValue(OPTIONS_USERNAME).c_str(), SharedConstants::NetworkProtocolVersion, true);
 	raknetInstance->send(packet);
 }
 
@@ -130,6 +132,12 @@ void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, LoginSta
 		LOGI("Disconnect! Server is outdated!\n");
 #ifndef STANDALONE_SERVER
 		minecraft->setScreen(new DisconnectionScreen("Could not connect: Outdated server!"));
+#endif
+	}
+	if (packet->status == LoginStatus::Failed_TakenNickname) {
+		LOGI("Disconnect! Nickname is taken!\n");
+#ifndef STANDALONE_SERVER
+		minecraft->setScreen(new DisconnectionScreen("Could not connect: Nickname is taken!"));
 #endif
 	}
 }
@@ -386,6 +394,55 @@ void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, MovePlay
 	}
 }
 
+void ClientSideNetworkHandler::handle(const RakNet::RakNetGUID& source, SendInventoryPacket* packet) {
+	if (!level) return;
+
+	// TODO: Linked slots
+	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)
@@ -782,6 +839,10 @@ 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)
 {
 }

src/network/ClientSideNetworkHandler.h

@@ -77,6 +77,11 @@ 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();

src/network/NetEventCallback.h

@@ -18,6 +18,8 @@ class RemovePlayerPacket;
 class RemoveEntityPacket;
 class MoveEntityPacket;
 //class TeleportEntityPacket;
+class RemoveItemPacket;
+class TakeItemPacket;
 class MovePlayerPacket;
 class PlaceBlockPacket;
 class RemoveBlockPacket;
@@ -48,6 +50,7 @@ class ContainerClosePacket;
 class ContainerSetSlotPacket;
 class ContainerSetDataPacket;
 class ContainerSetContentPacket;
+class WantCreatePacket;
 class ChatPacket;
 class SignUpdatePacket;
 class Minecraft;
@@ -119,6 +122,9 @@ 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,6 +2,7 @@
 #include "Packet.h"
 #include "../world/level/chunk/LevelChunk.h"
 
+#include "network/packet/TakeItemPacket.h"
 #include "packet/PacketInclude.h"
 
 Packet::Packet()
@@ -41,10 +42,16 @@ 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:
@@ -68,6 +75,9 @@ 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,7 +33,10 @@ enum MinecraftPacketIds
 	PACKET_REMOVEENTITY,
 	PACKET_ADDITEMENTITY,
 	PACKET_TAKEITEMENTITY,
-
+	PACKET_TAKEITEM,
+	PACKET_REMOVEITEM,
+	PACKET_WANTCREATEITEM,
+	
 	PACKET_MOVEENTITY,
 	PACKET_MOVEENTITY_POS,
 	PACKET_MOVEENTITY_ROT,

src/network/ServerSideNetworkHandler.cpp

@@ -5,6 +5,14 @@
 #include "../world/entity/player/Inventory.h"
 #include "../world/Container.h"
 #include "../world/inventory/BaseContainerMenu.h"
+#include "network/packet/ContainerSetSlotPacket.h"
+#include "network/packet/LoginStatusPacket.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"
@@ -13,6 +21,14 @@
 #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>
 #ifndef STANDALONE_SERVER
 #include "../client/sound/SoundEngine.h"
 #endif
@@ -156,6 +172,8 @@ 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);
@@ -179,7 +197,7 @@ void ServerSideNetworkHandler::handle(const RakNet::RakNetGUID& source, LoginPac
 	if (!_allowIncoming) return;
 
 	LOGI("LoginPacket\n");
-
+	
 	int loginStatus = LoginStatus::Success;
 	//
 	// Bad/incompatible client version
@@ -189,6 +207,14 @@ 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);
@@ -199,13 +225,16 @@ 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);
@@ -232,6 +261,11 @@ 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);
+		}
 	}
 }
 
@@ -244,6 +278,8 @@ 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)
@@ -301,6 +337,36 @@ 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
 	/*
@@ -342,11 +408,22 @@ void ServerSideNetworkHandler::handle(const RakNet::RakNetGUID& source, MovePlay
 	//LOGI("MovePlayerPacket\n");
 	if (Entity* entity = level->getEntity(packet->entityId))
 	{
-		entity->xd = entity->yd = entity->zd = 0;
+		ServerPlayer* player = (ServerPlayer*) getPlayer(source);
-		entity->lerpTo(packet->x, packet->y, packet->z, packet->yRot, packet->xRot, 3);
 
-		// broadcast this packet to other clients
+		float vectorDist = sqrt( (packet->x - entity->x) * (packet->x - entity->x)  + 
-		redistributePacket(packet, source);
+									(packet->y - entity->y) * (packet->y - entity->y) +
+									(packet->z - entity->z) * (packet->z - entity->z));
+		float speed = vectorDist / (minecraft->getTicks() - player->getLastMoveTicks());
+
+		if (speed < 2.5f) {
+			entity->xd = entity->yd = entity->zd = 0;
+			entity->lerpTo(packet->x, packet->y, packet->z, packet->yRot, packet->xRot, 3);
+		
+			// broadcast this packet to other clients
+			redistributePacket(packet, source);
+		}
+	
+		player->setLastMoveTicks(minecraft->getTicks());
 	}
 }
 
@@ -368,12 +445,29 @@ 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
+			// 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)
@@ -403,6 +497,8 @@ 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 )
@@ -429,23 +525,31 @@ 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) {
+	if (slot >= 0 && slot != packet->inventorySlot && packet->itemId != 0) {
-		if (packet->itemId == 0) {
+		LOGW("PlayerEquipmentPacket: Item in player inventory but slots doesn't match!");
-			player->inventory->clearSlot(slot);
+		packet->inventorySlot = 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) {
@@ -455,6 +559,8 @@ 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);
 }
@@ -466,6 +572,8 @@ 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();
@@ -506,12 +614,73 @@ 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\n");
+	LOGI("UseItemPacket: id %i data %i\n", packet->itemId, packet->itemData);
 	Entity* entity = level->getEntity(packet->entityId);
 	if (entity && entity->isPlayer()) {
 		Player* player = (Player*) entity;
@@ -522,7 +691,30 @@ void ServerSideNetworkHandler::handle(const RakNet::RakNetGUID& source, UseItemP
 		if (t && t->use(level, x, y, z, player)) return;
 		if (packet->item.isNull()) return;
 
-		ItemInstance* item = &packet->item;
+		ItemInstance* packetItem = &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
@@ -533,6 +725,10 @@ 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");
 
@@ -544,6 +740,8 @@ 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);
 }
@@ -577,6 +775,11 @@ 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;
@@ -592,15 +795,27 @@ 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;
@@ -612,6 +827,16 @@ void ServerSideNetworkHandler::handle(const RakNet::RakNetGUID& source, Containe
 void ServerSideNetworkHandler::handle(const RakNet::RakNetGUID& source, ContainerSetSlotPacket* packet) {
 	if (!level) return;
 
+	const char* type = "unknown";
+
+	switch (packet->setType) {
+		case ContainerSetSlotPacket::SETTYPE_ADD: type = "add"; break;
+		case ContainerSetSlotPacket::SETTYPE_SET: type = "set"; break;
+		case ContainerSetSlotPacket::SETTYPE_TAKE: type = "take"; break;
+	};
+
+	LOGI("ContainerSetSlot: slot %i item %s type %s\n", packet->slot, packet->item.getName().c_str(), type);
+
 	Player* p = findPlayer(level, &source);
 	if (!p) return;
 
@@ -619,11 +844,79 @@ 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());
@@ -635,10 +928,14 @@ 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("SetHealthPacket\n");
+
 	for (unsigned int i = 0; i < level->players.size(); ++i) {
 		Player* p = level->players[i];
 		if (p->owner == source) {
@@ -657,6 +954,8 @@ 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;

src/network/ServerSideNetworkHandler.h

@@ -58,7 +58,8 @@ 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/packet/LoginPacket.h

@@ -9,17 +9,20 @@ 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)
+	LoginPacket(const RakNet::RakString& clientName, int clientVersion, bool newProto)
 	:	clientName(clientName),
 		clientNetworkVersion(clientVersion),
-		clientNetworkLowestSupportedVersion(clientVersion)
+		clientNetworkLowestSupportedVersion(clientVersion),
+		newProto(newProto)
 	{
 	}
 
@@ -29,6 +32,7 @@ public:
 		bitStream->Write(clientName);
 		bitStream->Write(clientNetworkVersion);
 		bitStream->Write(clientNetworkLowestSupportedVersion);
+		bitStream->Write(newProto);
 	}
 
 	void read(RakNet::BitStream* bitStream)
@@ -39,6 +43,11 @@ 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,10 +3,12 @@
 
 #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,5 +50,7 @@
 #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,15 +9,19 @@ public:
 	int entityId;
 	unsigned short itemId;
 	unsigned short itemAuxValue;
+	unsigned char selectedSlot;
+	unsigned char inventorySlot;
 
 	PlayerEquipmentPacket()
 	{
 	}
 
-	PlayerEquipmentPacket(int entityId, int itemId, int data)
+	PlayerEquipmentPacket(int entityId, int itemId, int data, int selSlot, int invSlot)
 	:	entityId(entityId),
 		itemId(itemId),
-		itemAuxValue(data)
+		itemAuxValue(data),
+		selectedSlot(selSlot),
+		inventorySlot(invSlot)
 	{
 	}
 
@@ -28,6 +32,8 @@ public:
 		bitStream->Write(entityId);
 		bitStream->Write(itemId);
 		bitStream->Write(itemAuxValue);
+		bitStream->Write(selectedSlot);
+		bitStream->Write(inventorySlot);
 	}
 
 	void read(RakNet::BitStream* bitStream)
@@ -35,6 +41,8 @@ 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

@@ -0,0 +1,54 @@
+#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,13 +2,14 @@
 #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),
@@ -21,10 +22,15 @@ 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)
@@ -39,6 +45,13 @@ 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)
@@ -50,6 +63,12 @@ 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)
@@ -62,6 +81,8 @@ 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

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

src/network/packet/WantCreatePacket.h

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

src/server/ServerLevel.cpp

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

src/server/ServerPlayer.cpp

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

src/server/ServerPlayer.h

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

src/world/entity/player/Inventory.cpp

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

src/world/entity/player/Inventory.h

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

src/world/inventory/FillingContainer.cpp

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

src/world/item/ItemInstance.cpp

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

src/world/item/ItemInstance.h

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

src/world/level/storage/ExternalFileLevelStorage.cpp

@@ -1,3 +1,6 @@
+#include <cstddef>
+#include <fstream>
+#include <ios>
 #if !defined(DEMO_MODE) && !defined(APPLE_DEMO_PROMOTION)
 
 #include "LevelData.h"
@@ -88,6 +91,9 @@ ExternalFileLevelStorage::ExternalFileLevelStorage(const std::string& levelId, c
 {
 	createFolderIfNotExists(levelPath.c_str());
 
+	std::string playerFolder = levelPath + "/players";
+	createFolderIfNotExists(playerFolder.c_str());
+
 	std::string datFileName   = levelPath + "/" + fnLevelDat;
 	std::string levelFileName = levelPath + "/" + fnPlayerDat;
 	loadedLevelData = new LevelData();
@@ -113,6 +119,7 @@ void ExternalFileLevelStorage::saveLevelData(LevelData& levelData, std::vector<P
 
 void ExternalFileLevelStorage::saveLevelData( const std::string& levelPath, LevelData& levelData, std::vector<Player*>* players )
 {
+	// @todo: completely rewrite
 	std::string directory = levelPath + "/";
     std::string tmpFile = directory + fnLevelDatNew;
     std::string datFile = directory + fnLevelDat;
@@ -141,6 +148,67 @@ void ExternalFileLevelStorage::saveLevelData( const std::string& levelPath, Leve
 
     // Remove the temporary save, if the rename didn't do it
     remove(tmpFile.c_str());
+
+	// Save players
+	// fuck mojang for that
+	if (!players || players->empty()) {
+		return;
+	}
+
+	for (auto& player : *players) {
+		if (player != NULL) {
+			savePlayer(*player, directory);
+		}
+	}
+}
+
+void ExternalFileLevelStorage::savePlayer(Player& player, const std::string& worldDir) {
+	std::string playerPath = worldDir + "/players/" + player.name + ".dat";
+
+	LOGI("Saving player %s to %s...\n", player.name.c_str(), playerPath.c_str());
+
+	RakNet::BitStream data;
+	RakDataOutput buf(data);
+	CompoundTag playerTag;
+	player.saveWithoutId(&playerTag);
+
+	NbtIo::write(&playerTag, &buf);
+
+	std::ofstream file(playerPath, std::ios::out | std::ios::binary);
+	file.write((const char*)data.GetData(), (size_t)data.GetNumberOfBytesUsed());
+}
+
+bool ExternalFileLevelStorage::loadPlayer(Player& player, const std::string& worldDir) {
+	std::string playerPath = worldDir + "/players/" + player.name + ".dat";
+
+	LOGI("Loading player %s from %s...\n", player.name.c_str(), playerPath.c_str());
+
+	std::ifstream file(playerPath, std::ios::in | std::ios::binary);
+	if (!file.is_open()) {
+		return false;
+	}
+
+	std::vector<uint8_t> data((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
+
+	RakNet::BitStream bitStream(data.data(), data.size(), false);
+	RakDataInput stream(bitStream);
+
+	CompoundTag* tag = NbtIo::read(&stream);
+	if (tag) {
+		player.load(tag);
+		tag->deleteChildren();
+		delete tag;
+	}
+
+	return true;
+}
+
+void ExternalFileLevelStorage::savePlayer(Player& player) {
+	ExternalFileLevelStorage::savePlayer(player, levelPath);
+}
+
+bool ExternalFileLevelStorage::loadPlayer(Player& player) {
+	return ExternalFileLevelStorage::loadPlayer(player, levelPath);
 }
 
 LevelData* ExternalFileLevelStorage::prepareLevel(Level* _level)

src/world/level/storage/ExternalFileLevelStorage.h

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

src/world/level/storage/LevelStorage.h

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